]> 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
rwSWIGged
[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,unsigned 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,unsigned 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,unsigned 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_AllowReentrance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20888 PyObject *resultobj = 0;
20889 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20890 bool arg2 = (bool) true ;
20891 void *argp1 = 0 ;
20892 int res1 = 0 ;
20893 bool val2 ;
20894 int ecode2 = 0 ;
20895 PyObject * obj0 = 0 ;
20896 PyObject * obj1 = 0 ;
20897 char * kwnames[] = {
20898 (char *) "self",(char *) "allow", NULL
20899 };
20900
20901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EvtHandler_AllowReentrance",kwnames,&obj0,&obj1)) SWIG_fail;
20902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20903 if (!SWIG_IsOK(res1)) {
20904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AllowReentrance" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20905 }
20906 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20907 if (obj1) {
20908 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20909 if (!SWIG_IsOK(ecode2)) {
20910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_AllowReentrance" "', expected argument " "2"" of type '" "bool""'");
20911 }
20912 arg2 = static_cast< bool >(val2);
20913 }
20914 {
20915 PyThreadState* __tstate = wxPyBeginAllowThreads();
20916 (arg1)->AllowReentrance(arg2);
20917 wxPyEndAllowThreads(__tstate);
20918 if (PyErr_Occurred()) SWIG_fail;
20919 }
20920 resultobj = SWIG_Py_Void();
20921 return resultobj;
20922 fail:
20923 return NULL;
20924 }
20925
20926
20927 SWIGINTERN PyObject *_wrap_EvtHandler_IsReentranceAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20928 PyObject *resultobj = 0;
20929 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20930 bool result;
20931 void *argp1 = 0 ;
20932 int res1 = 0 ;
20933 PyObject *swig_obj[1] ;
20934
20935 if (!args) SWIG_fail;
20936 swig_obj[0] = args;
20937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20938 if (!SWIG_IsOK(res1)) {
20939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_IsReentranceAllowed" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20940 }
20941 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20942 {
20943 PyThreadState* __tstate = wxPyBeginAllowThreads();
20944 result = (bool)(arg1)->IsReentranceAllowed();
20945 wxPyEndAllowThreads(__tstate);
20946 if (PyErr_Occurred()) SWIG_fail;
20947 }
20948 {
20949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20950 }
20951 return resultobj;
20952 fail:
20953 return NULL;
20954 }
20955
20956
20957 SWIGINTERN PyObject *_wrap_EvtHandler_IsEventHandlingInProgress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20958 PyObject *resultobj = 0;
20959 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20960 bool result;
20961 void *argp1 = 0 ;
20962 int res1 = 0 ;
20963 PyObject *swig_obj[1] ;
20964
20965 if (!args) SWIG_fail;
20966 swig_obj[0] = args;
20967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20968 if (!SWIG_IsOK(res1)) {
20969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_IsEventHandlingInProgress" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20970 }
20971 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20972 {
20973 PyThreadState* __tstate = wxPyBeginAllowThreads();
20974 result = (bool)(arg1)->IsEventHandlingInProgress();
20975 wxPyEndAllowThreads(__tstate);
20976 if (PyErr_Occurred()) SWIG_fail;
20977 }
20978 {
20979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20980 }
20981 return resultobj;
20982 fail:
20983 return NULL;
20984 }
20985
20986
20987 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20988 PyObject *resultobj = 0;
20989 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20990 int arg2 ;
20991 int arg3 ;
20992 int arg4 ;
20993 PyObject *arg5 = (PyObject *) 0 ;
20994 void *argp1 = 0 ;
20995 int res1 = 0 ;
20996 int val2 ;
20997 int ecode2 = 0 ;
20998 int val3 ;
20999 int ecode3 = 0 ;
21000 int val4 ;
21001 int ecode4 = 0 ;
21002 PyObject * obj0 = 0 ;
21003 PyObject * obj1 = 0 ;
21004 PyObject * obj2 = 0 ;
21005 PyObject * obj3 = 0 ;
21006 PyObject * obj4 = 0 ;
21007 char * kwnames[] = {
21008 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
21009 };
21010
21011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21013 if (!SWIG_IsOK(res1)) {
21014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21015 }
21016 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21017 ecode2 = SWIG_AsVal_int(obj1, &val2);
21018 if (!SWIG_IsOK(ecode2)) {
21019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
21020 }
21021 arg2 = static_cast< int >(val2);
21022 ecode3 = SWIG_AsVal_int(obj2, &val3);
21023 if (!SWIG_IsOK(ecode3)) {
21024 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
21025 }
21026 arg3 = static_cast< int >(val3);
21027 ecode4 = SWIG_AsVal_int(obj3, &val4);
21028 if (!SWIG_IsOK(ecode4)) {
21029 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
21030 }
21031 arg4 = static_cast< int >(val4);
21032 arg5 = obj4;
21033 {
21034 PyThreadState* __tstate = wxPyBeginAllowThreads();
21035 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
21036 wxPyEndAllowThreads(__tstate);
21037 if (PyErr_Occurred()) SWIG_fail;
21038 }
21039 resultobj = SWIG_Py_Void();
21040 return resultobj;
21041 fail:
21042 return NULL;
21043 }
21044
21045
21046 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21047 PyObject *resultobj = 0;
21048 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21049 int arg2 ;
21050 int arg3 = (int) -1 ;
21051 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
21052 bool result;
21053 void *argp1 = 0 ;
21054 int res1 = 0 ;
21055 int val2 ;
21056 int ecode2 = 0 ;
21057 int val3 ;
21058 int ecode3 = 0 ;
21059 int val4 ;
21060 int ecode4 = 0 ;
21061 PyObject * obj0 = 0 ;
21062 PyObject * obj1 = 0 ;
21063 PyObject * obj2 = 0 ;
21064 PyObject * obj3 = 0 ;
21065 char * kwnames[] = {
21066 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
21067 };
21068
21069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
21070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21071 if (!SWIG_IsOK(res1)) {
21072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21073 }
21074 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21075 ecode2 = SWIG_AsVal_int(obj1, &val2);
21076 if (!SWIG_IsOK(ecode2)) {
21077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
21078 }
21079 arg2 = static_cast< int >(val2);
21080 if (obj2) {
21081 ecode3 = SWIG_AsVal_int(obj2, &val3);
21082 if (!SWIG_IsOK(ecode3)) {
21083 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
21084 }
21085 arg3 = static_cast< int >(val3);
21086 }
21087 if (obj3) {
21088 ecode4 = SWIG_AsVal_int(obj3, &val4);
21089 if (!SWIG_IsOK(ecode4)) {
21090 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
21091 }
21092 arg4 = static_cast< wxEventType >(val4);
21093 }
21094 {
21095 PyThreadState* __tstate = wxPyBeginAllowThreads();
21096 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
21097 wxPyEndAllowThreads(__tstate);
21098 if (PyErr_Occurred()) SWIG_fail;
21099 }
21100 {
21101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21102 }
21103 return resultobj;
21104 fail:
21105 return NULL;
21106 }
21107
21108
21109 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21110 PyObject *resultobj = 0;
21111 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21112 PyObject *arg2 = (PyObject *) 0 ;
21113 bool arg3 = (bool) true ;
21114 void *argp1 = 0 ;
21115 int res1 = 0 ;
21116 bool val3 ;
21117 int ecode3 = 0 ;
21118 PyObject * obj0 = 0 ;
21119 PyObject * obj1 = 0 ;
21120 PyObject * obj2 = 0 ;
21121 char * kwnames[] = {
21122 (char *) "self",(char *) "_self",(char *) "incref", NULL
21123 };
21124
21125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21127 if (!SWIG_IsOK(res1)) {
21128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21129 }
21130 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21131 arg2 = obj1;
21132 if (obj2) {
21133 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21134 if (!SWIG_IsOK(ecode3)) {
21135 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
21136 }
21137 arg3 = static_cast< bool >(val3);
21138 }
21139 {
21140 PyThreadState* __tstate = wxPyBeginAllowThreads();
21141 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
21142 wxPyEndAllowThreads(__tstate);
21143 if (PyErr_Occurred()) SWIG_fail;
21144 }
21145 resultobj = SWIG_Py_Void();
21146 return resultobj;
21147 fail:
21148 return NULL;
21149 }
21150
21151
21152 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21153 PyObject *obj;
21154 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21155 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
21156 return SWIG_Py_Void();
21157 }
21158
21159 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21160 return SWIG_Python_InitShadowInstance(args);
21161 }
21162
21163 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21164 PyObject *resultobj = 0;
21165 wxEventType result;
21166
21167 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
21168 {
21169 PyThreadState* __tstate = wxPyBeginAllowThreads();
21170 result = (wxEventType)wxNewEventType();
21171 wxPyEndAllowThreads(__tstate);
21172 if (PyErr_Occurred()) SWIG_fail;
21173 }
21174 resultobj = SWIG_From_int(static_cast< int >(result));
21175 return resultobj;
21176 fail:
21177 return NULL;
21178 }
21179
21180
21181 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21182 PyObject *resultobj = 0;
21183 wxEvent *arg1 = (wxEvent *) 0 ;
21184 void *argp1 = 0 ;
21185 int res1 = 0 ;
21186 PyObject *swig_obj[1] ;
21187
21188 if (!args) SWIG_fail;
21189 swig_obj[0] = args;
21190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
21191 if (!SWIG_IsOK(res1)) {
21192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
21193 }
21194 arg1 = reinterpret_cast< wxEvent * >(argp1);
21195 {
21196 PyThreadState* __tstate = wxPyBeginAllowThreads();
21197 delete arg1;
21198
21199 wxPyEndAllowThreads(__tstate);
21200 if (PyErr_Occurred()) SWIG_fail;
21201 }
21202 resultobj = SWIG_Py_Void();
21203 return resultobj;
21204 fail:
21205 return NULL;
21206 }
21207
21208
21209 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21210 PyObject *resultobj = 0;
21211 wxEvent *arg1 = (wxEvent *) 0 ;
21212 wxEventType arg2 ;
21213 void *argp1 = 0 ;
21214 int res1 = 0 ;
21215 int val2 ;
21216 int ecode2 = 0 ;
21217 PyObject * obj0 = 0 ;
21218 PyObject * obj1 = 0 ;
21219 char * kwnames[] = {
21220 (char *) "self",(char *) "typ", NULL
21221 };
21222
21223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
21224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21225 if (!SWIG_IsOK(res1)) {
21226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
21227 }
21228 arg1 = reinterpret_cast< wxEvent * >(argp1);
21229 ecode2 = SWIG_AsVal_int(obj1, &val2);
21230 if (!SWIG_IsOK(ecode2)) {
21231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
21232 }
21233 arg2 = static_cast< wxEventType >(val2);
21234 {
21235 PyThreadState* __tstate = wxPyBeginAllowThreads();
21236 (arg1)->SetEventType(arg2);
21237 wxPyEndAllowThreads(__tstate);
21238 if (PyErr_Occurred()) SWIG_fail;
21239 }
21240 resultobj = SWIG_Py_Void();
21241 return resultobj;
21242 fail:
21243 return NULL;
21244 }
21245
21246
21247 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21248 PyObject *resultobj = 0;
21249 wxEvent *arg1 = (wxEvent *) 0 ;
21250 wxEventType result;
21251 void *argp1 = 0 ;
21252 int res1 = 0 ;
21253 PyObject *swig_obj[1] ;
21254
21255 if (!args) SWIG_fail;
21256 swig_obj[0] = args;
21257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21258 if (!SWIG_IsOK(res1)) {
21259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
21260 }
21261 arg1 = reinterpret_cast< wxEvent * >(argp1);
21262 {
21263 PyThreadState* __tstate = wxPyBeginAllowThreads();
21264 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
21265 wxPyEndAllowThreads(__tstate);
21266 if (PyErr_Occurred()) SWIG_fail;
21267 }
21268 resultobj = SWIG_From_int(static_cast< int >(result));
21269 return resultobj;
21270 fail:
21271 return NULL;
21272 }
21273
21274
21275 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21276 PyObject *resultobj = 0;
21277 wxEvent *arg1 = (wxEvent *) 0 ;
21278 wxObject *result = 0 ;
21279 void *argp1 = 0 ;
21280 int res1 = 0 ;
21281 PyObject *swig_obj[1] ;
21282
21283 if (!args) SWIG_fail;
21284 swig_obj[0] = args;
21285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21286 if (!SWIG_IsOK(res1)) {
21287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
21288 }
21289 arg1 = reinterpret_cast< wxEvent * >(argp1);
21290 {
21291 PyThreadState* __tstate = wxPyBeginAllowThreads();
21292 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
21293 wxPyEndAllowThreads(__tstate);
21294 if (PyErr_Occurred()) SWIG_fail;
21295 }
21296 {
21297 resultobj = wxPyMake_wxObject(result, (bool)0);
21298 }
21299 return resultobj;
21300 fail:
21301 return NULL;
21302 }
21303
21304
21305 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21306 PyObject *resultobj = 0;
21307 wxEvent *arg1 = (wxEvent *) 0 ;
21308 wxObject *arg2 = (wxObject *) 0 ;
21309 void *argp1 = 0 ;
21310 int res1 = 0 ;
21311 void *argp2 = 0 ;
21312 int res2 = 0 ;
21313 PyObject * obj0 = 0 ;
21314 PyObject * obj1 = 0 ;
21315 char * kwnames[] = {
21316 (char *) "self",(char *) "obj", NULL
21317 };
21318
21319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
21320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21321 if (!SWIG_IsOK(res1)) {
21322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
21323 }
21324 arg1 = reinterpret_cast< wxEvent * >(argp1);
21325 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
21326 if (!SWIG_IsOK(res2)) {
21327 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
21328 }
21329 arg2 = reinterpret_cast< wxObject * >(argp2);
21330 {
21331 PyThreadState* __tstate = wxPyBeginAllowThreads();
21332 (arg1)->SetEventObject(arg2);
21333 wxPyEndAllowThreads(__tstate);
21334 if (PyErr_Occurred()) SWIG_fail;
21335 }
21336 resultobj = SWIG_Py_Void();
21337 return resultobj;
21338 fail:
21339 return NULL;
21340 }
21341
21342
21343 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21344 PyObject *resultobj = 0;
21345 wxEvent *arg1 = (wxEvent *) 0 ;
21346 long result;
21347 void *argp1 = 0 ;
21348 int res1 = 0 ;
21349 PyObject *swig_obj[1] ;
21350
21351 if (!args) SWIG_fail;
21352 swig_obj[0] = args;
21353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21354 if (!SWIG_IsOK(res1)) {
21355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
21356 }
21357 arg1 = reinterpret_cast< wxEvent * >(argp1);
21358 {
21359 PyThreadState* __tstate = wxPyBeginAllowThreads();
21360 result = (long)((wxEvent const *)arg1)->GetTimestamp();
21361 wxPyEndAllowThreads(__tstate);
21362 if (PyErr_Occurred()) SWIG_fail;
21363 }
21364 resultobj = SWIG_From_long(static_cast< long >(result));
21365 return resultobj;
21366 fail:
21367 return NULL;
21368 }
21369
21370
21371 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21372 PyObject *resultobj = 0;
21373 wxEvent *arg1 = (wxEvent *) 0 ;
21374 long arg2 = (long) 0 ;
21375 void *argp1 = 0 ;
21376 int res1 = 0 ;
21377 long val2 ;
21378 int ecode2 = 0 ;
21379 PyObject * obj0 = 0 ;
21380 PyObject * obj1 = 0 ;
21381 char * kwnames[] = {
21382 (char *) "self",(char *) "ts", NULL
21383 };
21384
21385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
21386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21387 if (!SWIG_IsOK(res1)) {
21388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
21389 }
21390 arg1 = reinterpret_cast< wxEvent * >(argp1);
21391 if (obj1) {
21392 ecode2 = SWIG_AsVal_long(obj1, &val2);
21393 if (!SWIG_IsOK(ecode2)) {
21394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
21395 }
21396 arg2 = static_cast< long >(val2);
21397 }
21398 {
21399 PyThreadState* __tstate = wxPyBeginAllowThreads();
21400 (arg1)->SetTimestamp(arg2);
21401 wxPyEndAllowThreads(__tstate);
21402 if (PyErr_Occurred()) SWIG_fail;
21403 }
21404 resultobj = SWIG_Py_Void();
21405 return resultobj;
21406 fail:
21407 return NULL;
21408 }
21409
21410
21411 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21412 PyObject *resultobj = 0;
21413 wxEvent *arg1 = (wxEvent *) 0 ;
21414 int result;
21415 void *argp1 = 0 ;
21416 int res1 = 0 ;
21417 PyObject *swig_obj[1] ;
21418
21419 if (!args) SWIG_fail;
21420 swig_obj[0] = args;
21421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21422 if (!SWIG_IsOK(res1)) {
21423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
21424 }
21425 arg1 = reinterpret_cast< wxEvent * >(argp1);
21426 {
21427 PyThreadState* __tstate = wxPyBeginAllowThreads();
21428 result = (int)((wxEvent const *)arg1)->GetId();
21429 wxPyEndAllowThreads(__tstate);
21430 if (PyErr_Occurred()) SWIG_fail;
21431 }
21432 resultobj = SWIG_From_int(static_cast< int >(result));
21433 return resultobj;
21434 fail:
21435 return NULL;
21436 }
21437
21438
21439 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21440 PyObject *resultobj = 0;
21441 wxEvent *arg1 = (wxEvent *) 0 ;
21442 int arg2 ;
21443 void *argp1 = 0 ;
21444 int res1 = 0 ;
21445 int val2 ;
21446 int ecode2 = 0 ;
21447 PyObject * obj0 = 0 ;
21448 PyObject * obj1 = 0 ;
21449 char * kwnames[] = {
21450 (char *) "self",(char *) "Id", NULL
21451 };
21452
21453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
21454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21455 if (!SWIG_IsOK(res1)) {
21456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
21457 }
21458 arg1 = reinterpret_cast< wxEvent * >(argp1);
21459 ecode2 = SWIG_AsVal_int(obj1, &val2);
21460 if (!SWIG_IsOK(ecode2)) {
21461 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
21462 }
21463 arg2 = static_cast< int >(val2);
21464 {
21465 PyThreadState* __tstate = wxPyBeginAllowThreads();
21466 (arg1)->SetId(arg2);
21467 wxPyEndAllowThreads(__tstate);
21468 if (PyErr_Occurred()) SWIG_fail;
21469 }
21470 resultobj = SWIG_Py_Void();
21471 return resultobj;
21472 fail:
21473 return NULL;
21474 }
21475
21476
21477 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(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_IsCommandEvent" "', 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)->IsCommandEvent();
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_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21508 PyObject *resultobj = 0;
21509 wxEvent *arg1 = (wxEvent *) 0 ;
21510 bool arg2 = (bool) true ;
21511 void *argp1 = 0 ;
21512 int res1 = 0 ;
21513 bool val2 ;
21514 int ecode2 = 0 ;
21515 PyObject * obj0 = 0 ;
21516 PyObject * obj1 = 0 ;
21517 char * kwnames[] = {
21518 (char *) "self",(char *) "skip", NULL
21519 };
21520
21521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
21522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21523 if (!SWIG_IsOK(res1)) {
21524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
21525 }
21526 arg1 = reinterpret_cast< wxEvent * >(argp1);
21527 if (obj1) {
21528 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21529 if (!SWIG_IsOK(ecode2)) {
21530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
21531 }
21532 arg2 = static_cast< bool >(val2);
21533 }
21534 {
21535 PyThreadState* __tstate = wxPyBeginAllowThreads();
21536 (arg1)->Skip(arg2);
21537 wxPyEndAllowThreads(__tstate);
21538 if (PyErr_Occurred()) SWIG_fail;
21539 }
21540 resultobj = SWIG_Py_Void();
21541 return resultobj;
21542 fail:
21543 return NULL;
21544 }
21545
21546
21547 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21548 PyObject *resultobj = 0;
21549 wxEvent *arg1 = (wxEvent *) 0 ;
21550 bool result;
21551 void *argp1 = 0 ;
21552 int res1 = 0 ;
21553 PyObject *swig_obj[1] ;
21554
21555 if (!args) SWIG_fail;
21556 swig_obj[0] = args;
21557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21558 if (!SWIG_IsOK(res1)) {
21559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
21560 }
21561 arg1 = reinterpret_cast< wxEvent * >(argp1);
21562 {
21563 PyThreadState* __tstate = wxPyBeginAllowThreads();
21564 result = (bool)((wxEvent const *)arg1)->GetSkipped();
21565 wxPyEndAllowThreads(__tstate);
21566 if (PyErr_Occurred()) SWIG_fail;
21567 }
21568 {
21569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21570 }
21571 return resultobj;
21572 fail:
21573 return NULL;
21574 }
21575
21576
21577 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21578 PyObject *resultobj = 0;
21579 wxEvent *arg1 = (wxEvent *) 0 ;
21580 bool result;
21581 void *argp1 = 0 ;
21582 int res1 = 0 ;
21583 PyObject *swig_obj[1] ;
21584
21585 if (!args) SWIG_fail;
21586 swig_obj[0] = args;
21587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21588 if (!SWIG_IsOK(res1)) {
21589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
21590 }
21591 arg1 = reinterpret_cast< wxEvent * >(argp1);
21592 {
21593 PyThreadState* __tstate = wxPyBeginAllowThreads();
21594 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
21595 wxPyEndAllowThreads(__tstate);
21596 if (PyErr_Occurred()) SWIG_fail;
21597 }
21598 {
21599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21600 }
21601 return resultobj;
21602 fail:
21603 return NULL;
21604 }
21605
21606
21607 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21608 PyObject *resultobj = 0;
21609 wxEvent *arg1 = (wxEvent *) 0 ;
21610 int result;
21611 void *argp1 = 0 ;
21612 int res1 = 0 ;
21613 PyObject *swig_obj[1] ;
21614
21615 if (!args) SWIG_fail;
21616 swig_obj[0] = args;
21617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21618 if (!SWIG_IsOK(res1)) {
21619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21620 }
21621 arg1 = reinterpret_cast< wxEvent * >(argp1);
21622 {
21623 PyThreadState* __tstate = wxPyBeginAllowThreads();
21624 result = (int)(arg1)->StopPropagation();
21625 wxPyEndAllowThreads(__tstate);
21626 if (PyErr_Occurred()) SWIG_fail;
21627 }
21628 resultobj = SWIG_From_int(static_cast< int >(result));
21629 return resultobj;
21630 fail:
21631 return NULL;
21632 }
21633
21634
21635 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21636 PyObject *resultobj = 0;
21637 wxEvent *arg1 = (wxEvent *) 0 ;
21638 int arg2 ;
21639 void *argp1 = 0 ;
21640 int res1 = 0 ;
21641 int val2 ;
21642 int ecode2 = 0 ;
21643 PyObject * obj0 = 0 ;
21644 PyObject * obj1 = 0 ;
21645 char * kwnames[] = {
21646 (char *) "self",(char *) "propagationLevel", NULL
21647 };
21648
21649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
21650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21651 if (!SWIG_IsOK(res1)) {
21652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21653 }
21654 arg1 = reinterpret_cast< wxEvent * >(argp1);
21655 ecode2 = SWIG_AsVal_int(obj1, &val2);
21656 if (!SWIG_IsOK(ecode2)) {
21657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
21658 }
21659 arg2 = static_cast< int >(val2);
21660 {
21661 PyThreadState* __tstate = wxPyBeginAllowThreads();
21662 (arg1)->ResumePropagation(arg2);
21663 wxPyEndAllowThreads(__tstate);
21664 if (PyErr_Occurred()) SWIG_fail;
21665 }
21666 resultobj = SWIG_Py_Void();
21667 return resultobj;
21668 fail:
21669 return NULL;
21670 }
21671
21672
21673 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21674 PyObject *resultobj = 0;
21675 wxEvent *arg1 = (wxEvent *) 0 ;
21676 wxEvent *result = 0 ;
21677 void *argp1 = 0 ;
21678 int res1 = 0 ;
21679 PyObject *swig_obj[1] ;
21680
21681 if (!args) SWIG_fail;
21682 swig_obj[0] = args;
21683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21684 if (!SWIG_IsOK(res1)) {
21685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
21686 }
21687 arg1 = reinterpret_cast< wxEvent * >(argp1);
21688 {
21689 PyThreadState* __tstate = wxPyBeginAllowThreads();
21690 result = (wxEvent *)(arg1)->Clone();
21691 wxPyEndAllowThreads(__tstate);
21692 if (PyErr_Occurred()) SWIG_fail;
21693 }
21694 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
21695 return resultobj;
21696 fail:
21697 return NULL;
21698 }
21699
21700
21701 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21702 PyObject *obj;
21703 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21704 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
21705 return SWIG_Py_Void();
21706 }
21707
21708 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21709 PyObject *resultobj = 0;
21710 wxEvent *arg1 = 0 ;
21711 wxPropagationDisabler *result = 0 ;
21712 void *argp1 = 0 ;
21713 int res1 = 0 ;
21714 PyObject * obj0 = 0 ;
21715 char * kwnames[] = {
21716 (char *) "event", NULL
21717 };
21718
21719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
21720 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21721 if (!SWIG_IsOK(res1)) {
21722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21723 }
21724 if (!argp1) {
21725 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21726 }
21727 arg1 = reinterpret_cast< wxEvent * >(argp1);
21728 {
21729 PyThreadState* __tstate = wxPyBeginAllowThreads();
21730 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
21731 wxPyEndAllowThreads(__tstate);
21732 if (PyErr_Occurred()) SWIG_fail;
21733 }
21734 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
21735 return resultobj;
21736 fail:
21737 return NULL;
21738 }
21739
21740
21741 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21742 PyObject *resultobj = 0;
21743 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
21744 void *argp1 = 0 ;
21745 int res1 = 0 ;
21746 PyObject *swig_obj[1] ;
21747
21748 if (!args) SWIG_fail;
21749 swig_obj[0] = args;
21750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
21751 if (!SWIG_IsOK(res1)) {
21752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
21753 }
21754 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
21755 {
21756 PyThreadState* __tstate = wxPyBeginAllowThreads();
21757 delete arg1;
21758
21759 wxPyEndAllowThreads(__tstate);
21760 if (PyErr_Occurred()) SWIG_fail;
21761 }
21762 resultobj = SWIG_Py_Void();
21763 return resultobj;
21764 fail:
21765 return NULL;
21766 }
21767
21768
21769 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21770 PyObject *obj;
21771 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21772 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
21773 return SWIG_Py_Void();
21774 }
21775
21776 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21777 return SWIG_Python_InitShadowInstance(args);
21778 }
21779
21780 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21781 PyObject *resultobj = 0;
21782 wxEvent *arg1 = 0 ;
21783 wxPropagateOnce *result = 0 ;
21784 void *argp1 = 0 ;
21785 int res1 = 0 ;
21786 PyObject * obj0 = 0 ;
21787 char * kwnames[] = {
21788 (char *) "event", NULL
21789 };
21790
21791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
21792 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21793 if (!SWIG_IsOK(res1)) {
21794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21795 }
21796 if (!argp1) {
21797 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21798 }
21799 arg1 = reinterpret_cast< wxEvent * >(argp1);
21800 {
21801 PyThreadState* __tstate = wxPyBeginAllowThreads();
21802 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
21803 wxPyEndAllowThreads(__tstate);
21804 if (PyErr_Occurred()) SWIG_fail;
21805 }
21806 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
21807 return resultobj;
21808 fail:
21809 return NULL;
21810 }
21811
21812
21813 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21814 PyObject *resultobj = 0;
21815 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
21816 void *argp1 = 0 ;
21817 int res1 = 0 ;
21818 PyObject *swig_obj[1] ;
21819
21820 if (!args) SWIG_fail;
21821 swig_obj[0] = args;
21822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
21823 if (!SWIG_IsOK(res1)) {
21824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
21825 }
21826 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
21827 {
21828 PyThreadState* __tstate = wxPyBeginAllowThreads();
21829 delete arg1;
21830
21831 wxPyEndAllowThreads(__tstate);
21832 if (PyErr_Occurred()) SWIG_fail;
21833 }
21834 resultobj = SWIG_Py_Void();
21835 return resultobj;
21836 fail:
21837 return NULL;
21838 }
21839
21840
21841 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21842 PyObject *obj;
21843 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21844 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
21845 return SWIG_Py_Void();
21846 }
21847
21848 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21849 return SWIG_Python_InitShadowInstance(args);
21850 }
21851
21852 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21853 PyObject *resultobj = 0;
21854 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21855 int arg2 = (int) 0 ;
21856 wxCommandEvent *result = 0 ;
21857 int val1 ;
21858 int ecode1 = 0 ;
21859 int val2 ;
21860 int ecode2 = 0 ;
21861 PyObject * obj0 = 0 ;
21862 PyObject * obj1 = 0 ;
21863 char * kwnames[] = {
21864 (char *) "commandType",(char *) "winid", NULL
21865 };
21866
21867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21868 if (obj0) {
21869 ecode1 = SWIG_AsVal_int(obj0, &val1);
21870 if (!SWIG_IsOK(ecode1)) {
21871 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21872 }
21873 arg1 = static_cast< wxEventType >(val1);
21874 }
21875 if (obj1) {
21876 ecode2 = SWIG_AsVal_int(obj1, &val2);
21877 if (!SWIG_IsOK(ecode2)) {
21878 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
21879 }
21880 arg2 = static_cast< int >(val2);
21881 }
21882 {
21883 PyThreadState* __tstate = wxPyBeginAllowThreads();
21884 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
21885 wxPyEndAllowThreads(__tstate);
21886 if (PyErr_Occurred()) SWIG_fail;
21887 }
21888 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
21889 return resultobj;
21890 fail:
21891 return NULL;
21892 }
21893
21894
21895 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21896 PyObject *resultobj = 0;
21897 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21898 int result;
21899 void *argp1 = 0 ;
21900 int res1 = 0 ;
21901 PyObject *swig_obj[1] ;
21902
21903 if (!args) SWIG_fail;
21904 swig_obj[0] = args;
21905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21906 if (!SWIG_IsOK(res1)) {
21907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21908 }
21909 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21910 {
21911 PyThreadState* __tstate = wxPyBeginAllowThreads();
21912 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
21913 wxPyEndAllowThreads(__tstate);
21914 if (PyErr_Occurred()) SWIG_fail;
21915 }
21916 resultobj = SWIG_From_int(static_cast< int >(result));
21917 return resultobj;
21918 fail:
21919 return NULL;
21920 }
21921
21922
21923 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21924 PyObject *resultobj = 0;
21925 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21926 wxString *arg2 = 0 ;
21927 void *argp1 = 0 ;
21928 int res1 = 0 ;
21929 bool temp2 = false ;
21930 PyObject * obj0 = 0 ;
21931 PyObject * obj1 = 0 ;
21932 char * kwnames[] = {
21933 (char *) "self",(char *) "s", NULL
21934 };
21935
21936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
21937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21938 if (!SWIG_IsOK(res1)) {
21939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
21940 }
21941 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21942 {
21943 arg2 = wxString_in_helper(obj1);
21944 if (arg2 == NULL) SWIG_fail;
21945 temp2 = true;
21946 }
21947 {
21948 PyThreadState* __tstate = wxPyBeginAllowThreads();
21949 (arg1)->SetString((wxString const &)*arg2);
21950 wxPyEndAllowThreads(__tstate);
21951 if (PyErr_Occurred()) SWIG_fail;
21952 }
21953 resultobj = SWIG_Py_Void();
21954 {
21955 if (temp2)
21956 delete arg2;
21957 }
21958 return resultobj;
21959 fail:
21960 {
21961 if (temp2)
21962 delete arg2;
21963 }
21964 return NULL;
21965 }
21966
21967
21968 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21969 PyObject *resultobj = 0;
21970 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21971 wxString result;
21972 void *argp1 = 0 ;
21973 int res1 = 0 ;
21974 PyObject *swig_obj[1] ;
21975
21976 if (!args) SWIG_fail;
21977 swig_obj[0] = args;
21978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21979 if (!SWIG_IsOK(res1)) {
21980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21981 }
21982 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21983 {
21984 PyThreadState* __tstate = wxPyBeginAllowThreads();
21985 result = ((wxCommandEvent const *)arg1)->GetString();
21986 wxPyEndAllowThreads(__tstate);
21987 if (PyErr_Occurred()) SWIG_fail;
21988 }
21989 {
21990 #if wxUSE_UNICODE
21991 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21992 #else
21993 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21994 #endif
21995 }
21996 return resultobj;
21997 fail:
21998 return NULL;
21999 }
22000
22001
22002 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22003 PyObject *resultobj = 0;
22004 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22005 bool result;
22006 void *argp1 = 0 ;
22007 int res1 = 0 ;
22008 PyObject *swig_obj[1] ;
22009
22010 if (!args) SWIG_fail;
22011 swig_obj[0] = args;
22012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22013 if (!SWIG_IsOK(res1)) {
22014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22015 }
22016 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22017 {
22018 PyThreadState* __tstate = wxPyBeginAllowThreads();
22019 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
22020 wxPyEndAllowThreads(__tstate);
22021 if (PyErr_Occurred()) SWIG_fail;
22022 }
22023 {
22024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22025 }
22026 return resultobj;
22027 fail:
22028 return NULL;
22029 }
22030
22031
22032 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22033 PyObject *resultobj = 0;
22034 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22035 bool result;
22036 void *argp1 = 0 ;
22037 int res1 = 0 ;
22038 PyObject *swig_obj[1] ;
22039
22040 if (!args) SWIG_fail;
22041 swig_obj[0] = args;
22042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22043 if (!SWIG_IsOK(res1)) {
22044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22045 }
22046 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22047 {
22048 PyThreadState* __tstate = wxPyBeginAllowThreads();
22049 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
22050 wxPyEndAllowThreads(__tstate);
22051 if (PyErr_Occurred()) SWIG_fail;
22052 }
22053 {
22054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22055 }
22056 return resultobj;
22057 fail:
22058 return NULL;
22059 }
22060
22061
22062 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22063 PyObject *resultobj = 0;
22064 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22065 long arg2 ;
22066 void *argp1 = 0 ;
22067 int res1 = 0 ;
22068 long val2 ;
22069 int ecode2 = 0 ;
22070 PyObject * obj0 = 0 ;
22071 PyObject * obj1 = 0 ;
22072 char * kwnames[] = {
22073 (char *) "self",(char *) "extraLong", NULL
22074 };
22075
22076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
22077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22078 if (!SWIG_IsOK(res1)) {
22079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22080 }
22081 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22082 ecode2 = SWIG_AsVal_long(obj1, &val2);
22083 if (!SWIG_IsOK(ecode2)) {
22084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
22085 }
22086 arg2 = static_cast< long >(val2);
22087 {
22088 PyThreadState* __tstate = wxPyBeginAllowThreads();
22089 (arg1)->SetExtraLong(arg2);
22090 wxPyEndAllowThreads(__tstate);
22091 if (PyErr_Occurred()) SWIG_fail;
22092 }
22093 resultobj = SWIG_Py_Void();
22094 return resultobj;
22095 fail:
22096 return NULL;
22097 }
22098
22099
22100 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22101 PyObject *resultobj = 0;
22102 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22103 long result;
22104 void *argp1 = 0 ;
22105 int res1 = 0 ;
22106 PyObject *swig_obj[1] ;
22107
22108 if (!args) SWIG_fail;
22109 swig_obj[0] = args;
22110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22111 if (!SWIG_IsOK(res1)) {
22112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22113 }
22114 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22115 {
22116 PyThreadState* __tstate = wxPyBeginAllowThreads();
22117 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
22118 wxPyEndAllowThreads(__tstate);
22119 if (PyErr_Occurred()) SWIG_fail;
22120 }
22121 resultobj = SWIG_From_long(static_cast< long >(result));
22122 return resultobj;
22123 fail:
22124 return NULL;
22125 }
22126
22127
22128 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22129 PyObject *resultobj = 0;
22130 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22131 int arg2 ;
22132 void *argp1 = 0 ;
22133 int res1 = 0 ;
22134 int val2 ;
22135 int ecode2 = 0 ;
22136 PyObject * obj0 = 0 ;
22137 PyObject * obj1 = 0 ;
22138 char * kwnames[] = {
22139 (char *) "self",(char *) "i", NULL
22140 };
22141
22142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
22143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22144 if (!SWIG_IsOK(res1)) {
22145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22146 }
22147 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22148 ecode2 = SWIG_AsVal_int(obj1, &val2);
22149 if (!SWIG_IsOK(ecode2)) {
22150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
22151 }
22152 arg2 = static_cast< int >(val2);
22153 {
22154 PyThreadState* __tstate = wxPyBeginAllowThreads();
22155 (arg1)->SetInt(arg2);
22156 wxPyEndAllowThreads(__tstate);
22157 if (PyErr_Occurred()) SWIG_fail;
22158 }
22159 resultobj = SWIG_Py_Void();
22160 return resultobj;
22161 fail:
22162 return NULL;
22163 }
22164
22165
22166 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22167 PyObject *resultobj = 0;
22168 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22169 int result;
22170 void *argp1 = 0 ;
22171 int res1 = 0 ;
22172 PyObject *swig_obj[1] ;
22173
22174 if (!args) SWIG_fail;
22175 swig_obj[0] = args;
22176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22177 if (!SWIG_IsOK(res1)) {
22178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22179 }
22180 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22181 {
22182 PyThreadState* __tstate = wxPyBeginAllowThreads();
22183 result = (int)((wxCommandEvent const *)arg1)->GetInt();
22184 wxPyEndAllowThreads(__tstate);
22185 if (PyErr_Occurred()) SWIG_fail;
22186 }
22187 resultobj = SWIG_From_int(static_cast< int >(result));
22188 return resultobj;
22189 fail:
22190 return NULL;
22191 }
22192
22193
22194 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22195 PyObject *resultobj = 0;
22196 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22197 PyObject *result = 0 ;
22198 void *argp1 = 0 ;
22199 int res1 = 0 ;
22200 PyObject *swig_obj[1] ;
22201
22202 if (!args) SWIG_fail;
22203 swig_obj[0] = args;
22204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22205 if (!SWIG_IsOK(res1)) {
22206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22207 }
22208 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22209 {
22210 PyThreadState* __tstate = wxPyBeginAllowThreads();
22211 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
22212 wxPyEndAllowThreads(__tstate);
22213 if (PyErr_Occurred()) SWIG_fail;
22214 }
22215 resultobj = result;
22216 return resultobj;
22217 fail:
22218 return NULL;
22219 }
22220
22221
22222 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22223 PyObject *resultobj = 0;
22224 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22225 PyObject *arg2 = (PyObject *) 0 ;
22226 void *argp1 = 0 ;
22227 int res1 = 0 ;
22228 PyObject * obj0 = 0 ;
22229 PyObject * obj1 = 0 ;
22230 char * kwnames[] = {
22231 (char *) "self",(char *) "clientData", NULL
22232 };
22233
22234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
22235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22236 if (!SWIG_IsOK(res1)) {
22237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22238 }
22239 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22240 arg2 = obj1;
22241 {
22242 PyThreadState* __tstate = wxPyBeginAllowThreads();
22243 wxCommandEvent_SetClientData(arg1,arg2);
22244 wxPyEndAllowThreads(__tstate);
22245 if (PyErr_Occurred()) SWIG_fail;
22246 }
22247 resultobj = SWIG_Py_Void();
22248 return resultobj;
22249 fail:
22250 return NULL;
22251 }
22252
22253
22254 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22255 PyObject *resultobj = 0;
22256 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22257 wxEvent *result = 0 ;
22258 void *argp1 = 0 ;
22259 int res1 = 0 ;
22260 PyObject *swig_obj[1] ;
22261
22262 if (!args) SWIG_fail;
22263 swig_obj[0] = args;
22264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22265 if (!SWIG_IsOK(res1)) {
22266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22267 }
22268 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22269 {
22270 PyThreadState* __tstate = wxPyBeginAllowThreads();
22271 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
22272 wxPyEndAllowThreads(__tstate);
22273 if (PyErr_Occurred()) SWIG_fail;
22274 }
22275 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
22276 return resultobj;
22277 fail:
22278 return NULL;
22279 }
22280
22281
22282 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22283 PyObject *obj;
22284 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22285 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
22286 return SWIG_Py_Void();
22287 }
22288
22289 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22290 return SWIG_Python_InitShadowInstance(args);
22291 }
22292
22293 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22294 PyObject *resultobj = 0;
22295 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22296 int arg2 = (int) 0 ;
22297 wxNotifyEvent *result = 0 ;
22298 int val1 ;
22299 int ecode1 = 0 ;
22300 int val2 ;
22301 int ecode2 = 0 ;
22302 PyObject * obj0 = 0 ;
22303 PyObject * obj1 = 0 ;
22304 char * kwnames[] = {
22305 (char *) "commandType",(char *) "winid", NULL
22306 };
22307
22308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22309 if (obj0) {
22310 ecode1 = SWIG_AsVal_int(obj0, &val1);
22311 if (!SWIG_IsOK(ecode1)) {
22312 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22313 }
22314 arg1 = static_cast< wxEventType >(val1);
22315 }
22316 if (obj1) {
22317 ecode2 = SWIG_AsVal_int(obj1, &val2);
22318 if (!SWIG_IsOK(ecode2)) {
22319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
22320 }
22321 arg2 = static_cast< int >(val2);
22322 }
22323 {
22324 PyThreadState* __tstate = wxPyBeginAllowThreads();
22325 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
22326 wxPyEndAllowThreads(__tstate);
22327 if (PyErr_Occurred()) SWIG_fail;
22328 }
22329 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
22330 return resultobj;
22331 fail:
22332 return NULL;
22333 }
22334
22335
22336 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22337 PyObject *resultobj = 0;
22338 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22339 void *argp1 = 0 ;
22340 int res1 = 0 ;
22341 PyObject *swig_obj[1] ;
22342
22343 if (!args) SWIG_fail;
22344 swig_obj[0] = args;
22345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22346 if (!SWIG_IsOK(res1)) {
22347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22348 }
22349 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22350 {
22351 PyThreadState* __tstate = wxPyBeginAllowThreads();
22352 (arg1)->Veto();
22353 wxPyEndAllowThreads(__tstate);
22354 if (PyErr_Occurred()) SWIG_fail;
22355 }
22356 resultobj = SWIG_Py_Void();
22357 return resultobj;
22358 fail:
22359 return NULL;
22360 }
22361
22362
22363 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22364 PyObject *resultobj = 0;
22365 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22366 void *argp1 = 0 ;
22367 int res1 = 0 ;
22368 PyObject *swig_obj[1] ;
22369
22370 if (!args) SWIG_fail;
22371 swig_obj[0] = args;
22372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22373 if (!SWIG_IsOK(res1)) {
22374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22375 }
22376 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22377 {
22378 PyThreadState* __tstate = wxPyBeginAllowThreads();
22379 (arg1)->Allow();
22380 wxPyEndAllowThreads(__tstate);
22381 if (PyErr_Occurred()) SWIG_fail;
22382 }
22383 resultobj = SWIG_Py_Void();
22384 return resultobj;
22385 fail:
22386 return NULL;
22387 }
22388
22389
22390 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22391 PyObject *resultobj = 0;
22392 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22393 bool result;
22394 void *argp1 = 0 ;
22395 int res1 = 0 ;
22396 PyObject *swig_obj[1] ;
22397
22398 if (!args) SWIG_fail;
22399 swig_obj[0] = args;
22400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22401 if (!SWIG_IsOK(res1)) {
22402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22403 }
22404 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22405 {
22406 PyThreadState* __tstate = wxPyBeginAllowThreads();
22407 result = (bool)(arg1)->IsAllowed();
22408 wxPyEndAllowThreads(__tstate);
22409 if (PyErr_Occurred()) SWIG_fail;
22410 }
22411 {
22412 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22413 }
22414 return resultobj;
22415 fail:
22416 return NULL;
22417 }
22418
22419
22420 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22421 PyObject *obj;
22422 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22423 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
22424 return SWIG_Py_Void();
22425 }
22426
22427 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22428 return SWIG_Python_InitShadowInstance(args);
22429 }
22430
22431 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22432 PyObject *resultobj = 0;
22433 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22434 int arg2 = (int) 0 ;
22435 int arg3 = (int) 0 ;
22436 int arg4 = (int) 0 ;
22437 wxScrollEvent *result = 0 ;
22438 int val1 ;
22439 int ecode1 = 0 ;
22440 int val2 ;
22441 int ecode2 = 0 ;
22442 int val3 ;
22443 int ecode3 = 0 ;
22444 int val4 ;
22445 int ecode4 = 0 ;
22446 PyObject * obj0 = 0 ;
22447 PyObject * obj1 = 0 ;
22448 PyObject * obj2 = 0 ;
22449 PyObject * obj3 = 0 ;
22450 char * kwnames[] = {
22451 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
22452 };
22453
22454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22455 if (obj0) {
22456 ecode1 = SWIG_AsVal_int(obj0, &val1);
22457 if (!SWIG_IsOK(ecode1)) {
22458 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22459 }
22460 arg1 = static_cast< wxEventType >(val1);
22461 }
22462 if (obj1) {
22463 ecode2 = SWIG_AsVal_int(obj1, &val2);
22464 if (!SWIG_IsOK(ecode2)) {
22465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
22466 }
22467 arg2 = static_cast< int >(val2);
22468 }
22469 if (obj2) {
22470 ecode3 = SWIG_AsVal_int(obj2, &val3);
22471 if (!SWIG_IsOK(ecode3)) {
22472 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
22473 }
22474 arg3 = static_cast< int >(val3);
22475 }
22476 if (obj3) {
22477 ecode4 = SWIG_AsVal_int(obj3, &val4);
22478 if (!SWIG_IsOK(ecode4)) {
22479 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
22480 }
22481 arg4 = static_cast< int >(val4);
22482 }
22483 {
22484 PyThreadState* __tstate = wxPyBeginAllowThreads();
22485 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
22486 wxPyEndAllowThreads(__tstate);
22487 if (PyErr_Occurred()) SWIG_fail;
22488 }
22489 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
22490 return resultobj;
22491 fail:
22492 return NULL;
22493 }
22494
22495
22496 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22497 PyObject *resultobj = 0;
22498 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22499 int result;
22500 void *argp1 = 0 ;
22501 int res1 = 0 ;
22502 PyObject *swig_obj[1] ;
22503
22504 if (!args) SWIG_fail;
22505 swig_obj[0] = args;
22506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22507 if (!SWIG_IsOK(res1)) {
22508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22509 }
22510 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22511 {
22512 PyThreadState* __tstate = wxPyBeginAllowThreads();
22513 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
22514 wxPyEndAllowThreads(__tstate);
22515 if (PyErr_Occurred()) SWIG_fail;
22516 }
22517 resultobj = SWIG_From_int(static_cast< int >(result));
22518 return resultobj;
22519 fail:
22520 return NULL;
22521 }
22522
22523
22524 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22525 PyObject *resultobj = 0;
22526 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22527 int result;
22528 void *argp1 = 0 ;
22529 int res1 = 0 ;
22530 PyObject *swig_obj[1] ;
22531
22532 if (!args) SWIG_fail;
22533 swig_obj[0] = args;
22534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22535 if (!SWIG_IsOK(res1)) {
22536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22537 }
22538 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22539 {
22540 PyThreadState* __tstate = wxPyBeginAllowThreads();
22541 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
22542 wxPyEndAllowThreads(__tstate);
22543 if (PyErr_Occurred()) SWIG_fail;
22544 }
22545 resultobj = SWIG_From_int(static_cast< int >(result));
22546 return resultobj;
22547 fail:
22548 return NULL;
22549 }
22550
22551
22552 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22553 PyObject *resultobj = 0;
22554 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22555 int arg2 ;
22556 void *argp1 = 0 ;
22557 int res1 = 0 ;
22558 int val2 ;
22559 int ecode2 = 0 ;
22560 PyObject * obj0 = 0 ;
22561 PyObject * obj1 = 0 ;
22562 char * kwnames[] = {
22563 (char *) "self",(char *) "orient", NULL
22564 };
22565
22566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22568 if (!SWIG_IsOK(res1)) {
22569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22570 }
22571 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22572 ecode2 = SWIG_AsVal_int(obj1, &val2);
22573 if (!SWIG_IsOK(ecode2)) {
22574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22575 }
22576 arg2 = static_cast< int >(val2);
22577 {
22578 PyThreadState* __tstate = wxPyBeginAllowThreads();
22579 (arg1)->SetOrientation(arg2);
22580 wxPyEndAllowThreads(__tstate);
22581 if (PyErr_Occurred()) SWIG_fail;
22582 }
22583 resultobj = SWIG_Py_Void();
22584 return resultobj;
22585 fail:
22586 return NULL;
22587 }
22588
22589
22590 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22591 PyObject *resultobj = 0;
22592 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22593 int arg2 ;
22594 void *argp1 = 0 ;
22595 int res1 = 0 ;
22596 int val2 ;
22597 int ecode2 = 0 ;
22598 PyObject * obj0 = 0 ;
22599 PyObject * obj1 = 0 ;
22600 char * kwnames[] = {
22601 (char *) "self",(char *) "pos", NULL
22602 };
22603
22604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22606 if (!SWIG_IsOK(res1)) {
22607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22608 }
22609 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22610 ecode2 = SWIG_AsVal_int(obj1, &val2);
22611 if (!SWIG_IsOK(ecode2)) {
22612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22613 }
22614 arg2 = static_cast< int >(val2);
22615 {
22616 PyThreadState* __tstate = wxPyBeginAllowThreads();
22617 (arg1)->SetPosition(arg2);
22618 wxPyEndAllowThreads(__tstate);
22619 if (PyErr_Occurred()) SWIG_fail;
22620 }
22621 resultobj = SWIG_Py_Void();
22622 return resultobj;
22623 fail:
22624 return NULL;
22625 }
22626
22627
22628 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22629 PyObject *obj;
22630 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22631 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
22632 return SWIG_Py_Void();
22633 }
22634
22635 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22636 return SWIG_Python_InitShadowInstance(args);
22637 }
22638
22639 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22640 PyObject *resultobj = 0;
22641 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22642 int arg2 = (int) 0 ;
22643 int arg3 = (int) 0 ;
22644 wxScrollWinEvent *result = 0 ;
22645 int val1 ;
22646 int ecode1 = 0 ;
22647 int val2 ;
22648 int ecode2 = 0 ;
22649 int val3 ;
22650 int ecode3 = 0 ;
22651 PyObject * obj0 = 0 ;
22652 PyObject * obj1 = 0 ;
22653 PyObject * obj2 = 0 ;
22654 char * kwnames[] = {
22655 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
22656 };
22657
22658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22659 if (obj0) {
22660 ecode1 = SWIG_AsVal_int(obj0, &val1);
22661 if (!SWIG_IsOK(ecode1)) {
22662 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22663 }
22664 arg1 = static_cast< wxEventType >(val1);
22665 }
22666 if (obj1) {
22667 ecode2 = SWIG_AsVal_int(obj1, &val2);
22668 if (!SWIG_IsOK(ecode2)) {
22669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
22670 }
22671 arg2 = static_cast< int >(val2);
22672 }
22673 if (obj2) {
22674 ecode3 = SWIG_AsVal_int(obj2, &val3);
22675 if (!SWIG_IsOK(ecode3)) {
22676 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
22677 }
22678 arg3 = static_cast< int >(val3);
22679 }
22680 {
22681 PyThreadState* __tstate = wxPyBeginAllowThreads();
22682 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
22683 wxPyEndAllowThreads(__tstate);
22684 if (PyErr_Occurred()) SWIG_fail;
22685 }
22686 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
22687 return resultobj;
22688 fail:
22689 return NULL;
22690 }
22691
22692
22693 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22694 PyObject *resultobj = 0;
22695 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22696 int result;
22697 void *argp1 = 0 ;
22698 int res1 = 0 ;
22699 PyObject *swig_obj[1] ;
22700
22701 if (!args) SWIG_fail;
22702 swig_obj[0] = args;
22703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22704 if (!SWIG_IsOK(res1)) {
22705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22706 }
22707 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22708 {
22709 PyThreadState* __tstate = wxPyBeginAllowThreads();
22710 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
22711 wxPyEndAllowThreads(__tstate);
22712 if (PyErr_Occurred()) SWIG_fail;
22713 }
22714 resultobj = SWIG_From_int(static_cast< int >(result));
22715 return resultobj;
22716 fail:
22717 return NULL;
22718 }
22719
22720
22721 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22722 PyObject *resultobj = 0;
22723 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22724 int result;
22725 void *argp1 = 0 ;
22726 int res1 = 0 ;
22727 PyObject *swig_obj[1] ;
22728
22729 if (!args) SWIG_fail;
22730 swig_obj[0] = args;
22731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22732 if (!SWIG_IsOK(res1)) {
22733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22734 }
22735 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22736 {
22737 PyThreadState* __tstate = wxPyBeginAllowThreads();
22738 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
22739 wxPyEndAllowThreads(__tstate);
22740 if (PyErr_Occurred()) SWIG_fail;
22741 }
22742 resultobj = SWIG_From_int(static_cast< int >(result));
22743 return resultobj;
22744 fail:
22745 return NULL;
22746 }
22747
22748
22749 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22750 PyObject *resultobj = 0;
22751 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22752 int arg2 ;
22753 void *argp1 = 0 ;
22754 int res1 = 0 ;
22755 int val2 ;
22756 int ecode2 = 0 ;
22757 PyObject * obj0 = 0 ;
22758 PyObject * obj1 = 0 ;
22759 char * kwnames[] = {
22760 (char *) "self",(char *) "orient", NULL
22761 };
22762
22763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22765 if (!SWIG_IsOK(res1)) {
22766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22767 }
22768 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22769 ecode2 = SWIG_AsVal_int(obj1, &val2);
22770 if (!SWIG_IsOK(ecode2)) {
22771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22772 }
22773 arg2 = static_cast< int >(val2);
22774 {
22775 PyThreadState* __tstate = wxPyBeginAllowThreads();
22776 (arg1)->SetOrientation(arg2);
22777 wxPyEndAllowThreads(__tstate);
22778 if (PyErr_Occurred()) SWIG_fail;
22779 }
22780 resultobj = SWIG_Py_Void();
22781 return resultobj;
22782 fail:
22783 return NULL;
22784 }
22785
22786
22787 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22788 PyObject *resultobj = 0;
22789 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22790 int arg2 ;
22791 void *argp1 = 0 ;
22792 int res1 = 0 ;
22793 int val2 ;
22794 int ecode2 = 0 ;
22795 PyObject * obj0 = 0 ;
22796 PyObject * obj1 = 0 ;
22797 char * kwnames[] = {
22798 (char *) "self",(char *) "pos", NULL
22799 };
22800
22801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22803 if (!SWIG_IsOK(res1)) {
22804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22805 }
22806 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22807 ecode2 = SWIG_AsVal_int(obj1, &val2);
22808 if (!SWIG_IsOK(ecode2)) {
22809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22810 }
22811 arg2 = static_cast< int >(val2);
22812 {
22813 PyThreadState* __tstate = wxPyBeginAllowThreads();
22814 (arg1)->SetPosition(arg2);
22815 wxPyEndAllowThreads(__tstate);
22816 if (PyErr_Occurred()) SWIG_fail;
22817 }
22818 resultobj = SWIG_Py_Void();
22819 return resultobj;
22820 fail:
22821 return NULL;
22822 }
22823
22824
22825 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22826 PyObject *obj;
22827 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22828 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
22829 return SWIG_Py_Void();
22830 }
22831
22832 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22833 return SWIG_Python_InitShadowInstance(args);
22834 }
22835
22836 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22837 PyObject *resultobj = 0;
22838 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22839 wxMouseEvent *result = 0 ;
22840 int val1 ;
22841 int ecode1 = 0 ;
22842 PyObject * obj0 = 0 ;
22843 char * kwnames[] = {
22844 (char *) "mouseType", NULL
22845 };
22846
22847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
22848 if (obj0) {
22849 ecode1 = SWIG_AsVal_int(obj0, &val1);
22850 if (!SWIG_IsOK(ecode1)) {
22851 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22852 }
22853 arg1 = static_cast< wxEventType >(val1);
22854 }
22855 {
22856 PyThreadState* __tstate = wxPyBeginAllowThreads();
22857 result = (wxMouseEvent *)new wxMouseEvent(arg1);
22858 wxPyEndAllowThreads(__tstate);
22859 if (PyErr_Occurred()) SWIG_fail;
22860 }
22861 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_NEW | 0 );
22862 return resultobj;
22863 fail:
22864 return NULL;
22865 }
22866
22867
22868 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22869 PyObject *resultobj = 0;
22870 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22871 bool result;
22872 void *argp1 = 0 ;
22873 int res1 = 0 ;
22874 PyObject *swig_obj[1] ;
22875
22876 if (!args) SWIG_fail;
22877 swig_obj[0] = args;
22878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22879 if (!SWIG_IsOK(res1)) {
22880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22881 }
22882 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22883 {
22884 PyThreadState* __tstate = wxPyBeginAllowThreads();
22885 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
22886 wxPyEndAllowThreads(__tstate);
22887 if (PyErr_Occurred()) SWIG_fail;
22888 }
22889 {
22890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22891 }
22892 return resultobj;
22893 fail:
22894 return NULL;
22895 }
22896
22897
22898 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22899 PyObject *resultobj = 0;
22900 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22901 int arg2 = (int) wxMOUSE_BTN_ANY ;
22902 bool result;
22903 void *argp1 = 0 ;
22904 int res1 = 0 ;
22905 int val2 ;
22906 int ecode2 = 0 ;
22907 PyObject * obj0 = 0 ;
22908 PyObject * obj1 = 0 ;
22909 char * kwnames[] = {
22910 (char *) "self",(char *) "but", NULL
22911 };
22912
22913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
22914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22915 if (!SWIG_IsOK(res1)) {
22916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22917 }
22918 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22919 if (obj1) {
22920 ecode2 = SWIG_AsVal_int(obj1, &val2);
22921 if (!SWIG_IsOK(ecode2)) {
22922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
22923 }
22924 arg2 = static_cast< int >(val2);
22925 }
22926 {
22927 PyThreadState* __tstate = wxPyBeginAllowThreads();
22928 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
22929 wxPyEndAllowThreads(__tstate);
22930 if (PyErr_Occurred()) SWIG_fail;
22931 }
22932 {
22933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22934 }
22935 return resultobj;
22936 fail:
22937 return NULL;
22938 }
22939
22940
22941 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22942 PyObject *resultobj = 0;
22943 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22944 int arg2 = (int) wxMOUSE_BTN_ANY ;
22945 bool result;
22946 void *argp1 = 0 ;
22947 int res1 = 0 ;
22948 int val2 ;
22949 int ecode2 = 0 ;
22950 PyObject * obj0 = 0 ;
22951 PyObject * obj1 = 0 ;
22952 char * kwnames[] = {
22953 (char *) "self",(char *) "but", NULL
22954 };
22955
22956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
22957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22958 if (!SWIG_IsOK(res1)) {
22959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22960 }
22961 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22962 if (obj1) {
22963 ecode2 = SWIG_AsVal_int(obj1, &val2);
22964 if (!SWIG_IsOK(ecode2)) {
22965 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
22966 }
22967 arg2 = static_cast< int >(val2);
22968 }
22969 {
22970 PyThreadState* __tstate = wxPyBeginAllowThreads();
22971 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
22972 wxPyEndAllowThreads(__tstate);
22973 if (PyErr_Occurred()) SWIG_fail;
22974 }
22975 {
22976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22977 }
22978 return resultobj;
22979 fail:
22980 return NULL;
22981 }
22982
22983
22984 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22985 PyObject *resultobj = 0;
22986 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22987 int arg2 = (int) wxMOUSE_BTN_ANY ;
22988 bool result;
22989 void *argp1 = 0 ;
22990 int res1 = 0 ;
22991 int val2 ;
22992 int ecode2 = 0 ;
22993 PyObject * obj0 = 0 ;
22994 PyObject * obj1 = 0 ;
22995 char * kwnames[] = {
22996 (char *) "self",(char *) "but", NULL
22997 };
22998
22999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
23000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23001 if (!SWIG_IsOK(res1)) {
23002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23003 }
23004 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23005 if (obj1) {
23006 ecode2 = SWIG_AsVal_int(obj1, &val2);
23007 if (!SWIG_IsOK(ecode2)) {
23008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
23009 }
23010 arg2 = static_cast< int >(val2);
23011 }
23012 {
23013 PyThreadState* __tstate = wxPyBeginAllowThreads();
23014 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
23015 wxPyEndAllowThreads(__tstate);
23016 if (PyErr_Occurred()) SWIG_fail;
23017 }
23018 {
23019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23020 }
23021 return resultobj;
23022 fail:
23023 return NULL;
23024 }
23025
23026
23027 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23028 PyObject *resultobj = 0;
23029 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23030 int arg2 ;
23031 bool result;
23032 void *argp1 = 0 ;
23033 int res1 = 0 ;
23034 int val2 ;
23035 int ecode2 = 0 ;
23036 PyObject * obj0 = 0 ;
23037 PyObject * obj1 = 0 ;
23038 char * kwnames[] = {
23039 (char *) "self",(char *) "button", NULL
23040 };
23041
23042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
23043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23044 if (!SWIG_IsOK(res1)) {
23045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23046 }
23047 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23048 ecode2 = SWIG_AsVal_int(obj1, &val2);
23049 if (!SWIG_IsOK(ecode2)) {
23050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
23051 }
23052 arg2 = static_cast< int >(val2);
23053 {
23054 PyThreadState* __tstate = wxPyBeginAllowThreads();
23055 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
23056 wxPyEndAllowThreads(__tstate);
23057 if (PyErr_Occurred()) SWIG_fail;
23058 }
23059 {
23060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23061 }
23062 return resultobj;
23063 fail:
23064 return NULL;
23065 }
23066
23067
23068 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23069 PyObject *resultobj = 0;
23070 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23071 int arg2 ;
23072 bool result;
23073 void *argp1 = 0 ;
23074 int res1 = 0 ;
23075 int val2 ;
23076 int ecode2 = 0 ;
23077 PyObject * obj0 = 0 ;
23078 PyObject * obj1 = 0 ;
23079 char * kwnames[] = {
23080 (char *) "self",(char *) "but", NULL
23081 };
23082
23083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
23084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23085 if (!SWIG_IsOK(res1)) {
23086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23087 }
23088 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23089 ecode2 = SWIG_AsVal_int(obj1, &val2);
23090 if (!SWIG_IsOK(ecode2)) {
23091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
23092 }
23093 arg2 = static_cast< int >(val2);
23094 {
23095 PyThreadState* __tstate = wxPyBeginAllowThreads();
23096 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
23097 wxPyEndAllowThreads(__tstate);
23098 if (PyErr_Occurred()) SWIG_fail;
23099 }
23100 {
23101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23102 }
23103 return resultobj;
23104 fail:
23105 return NULL;
23106 }
23107
23108
23109 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23110 PyObject *resultobj = 0;
23111 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23112 int result;
23113 void *argp1 = 0 ;
23114 int res1 = 0 ;
23115 PyObject *swig_obj[1] ;
23116
23117 if (!args) SWIG_fail;
23118 swig_obj[0] = args;
23119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23120 if (!SWIG_IsOK(res1)) {
23121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23122 }
23123 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23124 {
23125 PyThreadState* __tstate = wxPyBeginAllowThreads();
23126 result = (int)((wxMouseEvent const *)arg1)->GetButton();
23127 wxPyEndAllowThreads(__tstate);
23128 if (PyErr_Occurred()) SWIG_fail;
23129 }
23130 resultobj = SWIG_From_int(static_cast< int >(result));
23131 return resultobj;
23132 fail:
23133 return NULL;
23134 }
23135
23136
23137 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23138 PyObject *resultobj = 0;
23139 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23140 bool result;
23141 void *argp1 = 0 ;
23142 int res1 = 0 ;
23143 PyObject *swig_obj[1] ;
23144
23145 if (!args) SWIG_fail;
23146 swig_obj[0] = args;
23147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23148 if (!SWIG_IsOK(res1)) {
23149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23150 }
23151 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23152 {
23153 PyThreadState* __tstate = wxPyBeginAllowThreads();
23154 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
23155 wxPyEndAllowThreads(__tstate);
23156 if (PyErr_Occurred()) SWIG_fail;
23157 }
23158 {
23159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23160 }
23161 return resultobj;
23162 fail:
23163 return NULL;
23164 }
23165
23166
23167 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23168 PyObject *resultobj = 0;
23169 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23170 bool result;
23171 void *argp1 = 0 ;
23172 int res1 = 0 ;
23173 PyObject *swig_obj[1] ;
23174
23175 if (!args) SWIG_fail;
23176 swig_obj[0] = args;
23177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23178 if (!SWIG_IsOK(res1)) {
23179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23180 }
23181 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23182 {
23183 PyThreadState* __tstate = wxPyBeginAllowThreads();
23184 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
23185 wxPyEndAllowThreads(__tstate);
23186 if (PyErr_Occurred()) SWIG_fail;
23187 }
23188 {
23189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23190 }
23191 return resultobj;
23192 fail:
23193 return NULL;
23194 }
23195
23196
23197 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23198 PyObject *resultobj = 0;
23199 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23200 bool result;
23201 void *argp1 = 0 ;
23202 int res1 = 0 ;
23203 PyObject *swig_obj[1] ;
23204
23205 if (!args) SWIG_fail;
23206 swig_obj[0] = args;
23207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23208 if (!SWIG_IsOK(res1)) {
23209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23210 }
23211 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23212 {
23213 PyThreadState* __tstate = wxPyBeginAllowThreads();
23214 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
23215 wxPyEndAllowThreads(__tstate);
23216 if (PyErr_Occurred()) SWIG_fail;
23217 }
23218 {
23219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23220 }
23221 return resultobj;
23222 fail:
23223 return NULL;
23224 }
23225
23226
23227 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23228 PyObject *resultobj = 0;
23229 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23230 bool result;
23231 void *argp1 = 0 ;
23232 int res1 = 0 ;
23233 PyObject *swig_obj[1] ;
23234
23235 if (!args) SWIG_fail;
23236 swig_obj[0] = args;
23237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23238 if (!SWIG_IsOK(res1)) {
23239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23240 }
23241 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23242 {
23243 PyThreadState* __tstate = wxPyBeginAllowThreads();
23244 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
23245 wxPyEndAllowThreads(__tstate);
23246 if (PyErr_Occurred()) SWIG_fail;
23247 }
23248 {
23249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23250 }
23251 return resultobj;
23252 fail:
23253 return NULL;
23254 }
23255
23256
23257 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23258 PyObject *resultobj = 0;
23259 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23260 bool result;
23261 void *argp1 = 0 ;
23262 int res1 = 0 ;
23263 PyObject *swig_obj[1] ;
23264
23265 if (!args) SWIG_fail;
23266 swig_obj[0] = args;
23267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23268 if (!SWIG_IsOK(res1)) {
23269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23270 }
23271 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23272 {
23273 PyThreadState* __tstate = wxPyBeginAllowThreads();
23274 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
23275 wxPyEndAllowThreads(__tstate);
23276 if (PyErr_Occurred()) SWIG_fail;
23277 }
23278 {
23279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23280 }
23281 return resultobj;
23282 fail:
23283 return NULL;
23284 }
23285
23286
23287 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23288 PyObject *resultobj = 0;
23289 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23290 bool result;
23291 void *argp1 = 0 ;
23292 int res1 = 0 ;
23293 PyObject *swig_obj[1] ;
23294
23295 if (!args) SWIG_fail;
23296 swig_obj[0] = args;
23297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23298 if (!SWIG_IsOK(res1)) {
23299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23300 }
23301 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23302 {
23303 PyThreadState* __tstate = wxPyBeginAllowThreads();
23304 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
23305 wxPyEndAllowThreads(__tstate);
23306 if (PyErr_Occurred()) SWIG_fail;
23307 }
23308 {
23309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23310 }
23311 return resultobj;
23312 fail:
23313 return NULL;
23314 }
23315
23316
23317 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23318 PyObject *resultobj = 0;
23319 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23320 bool result;
23321 void *argp1 = 0 ;
23322 int res1 = 0 ;
23323 PyObject *swig_obj[1] ;
23324
23325 if (!args) SWIG_fail;
23326 swig_obj[0] = args;
23327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23328 if (!SWIG_IsOK(res1)) {
23329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23330 }
23331 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23332 {
23333 PyThreadState* __tstate = wxPyBeginAllowThreads();
23334 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
23335 wxPyEndAllowThreads(__tstate);
23336 if (PyErr_Occurred()) SWIG_fail;
23337 }
23338 {
23339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23340 }
23341 return resultobj;
23342 fail:
23343 return NULL;
23344 }
23345
23346
23347 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23348 PyObject *resultobj = 0;
23349 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23350 bool result;
23351 void *argp1 = 0 ;
23352 int res1 = 0 ;
23353 PyObject *swig_obj[1] ;
23354
23355 if (!args) SWIG_fail;
23356 swig_obj[0] = args;
23357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23358 if (!SWIG_IsOK(res1)) {
23359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23360 }
23361 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23362 {
23363 PyThreadState* __tstate = wxPyBeginAllowThreads();
23364 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
23365 wxPyEndAllowThreads(__tstate);
23366 if (PyErr_Occurred()) SWIG_fail;
23367 }
23368 {
23369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23370 }
23371 return resultobj;
23372 fail:
23373 return NULL;
23374 }
23375
23376
23377 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23378 PyObject *resultobj = 0;
23379 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23380 bool result;
23381 void *argp1 = 0 ;
23382 int res1 = 0 ;
23383 PyObject *swig_obj[1] ;
23384
23385 if (!args) SWIG_fail;
23386 swig_obj[0] = args;
23387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23388 if (!SWIG_IsOK(res1)) {
23389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23390 }
23391 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23392 {
23393 PyThreadState* __tstate = wxPyBeginAllowThreads();
23394 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
23395 wxPyEndAllowThreads(__tstate);
23396 if (PyErr_Occurred()) SWIG_fail;
23397 }
23398 {
23399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23400 }
23401 return resultobj;
23402 fail:
23403 return NULL;
23404 }
23405
23406
23407 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23408 PyObject *resultobj = 0;
23409 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23410 bool result;
23411 void *argp1 = 0 ;
23412 int res1 = 0 ;
23413 PyObject *swig_obj[1] ;
23414
23415 if (!args) SWIG_fail;
23416 swig_obj[0] = args;
23417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23418 if (!SWIG_IsOK(res1)) {
23419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23420 }
23421 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23422 {
23423 PyThreadState* __tstate = wxPyBeginAllowThreads();
23424 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
23425 wxPyEndAllowThreads(__tstate);
23426 if (PyErr_Occurred()) SWIG_fail;
23427 }
23428 {
23429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23430 }
23431 return resultobj;
23432 fail:
23433 return NULL;
23434 }
23435
23436
23437 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23438 PyObject *resultobj = 0;
23439 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23440 bool result;
23441 void *argp1 = 0 ;
23442 int res1 = 0 ;
23443 PyObject *swig_obj[1] ;
23444
23445 if (!args) SWIG_fail;
23446 swig_obj[0] = args;
23447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23448 if (!SWIG_IsOK(res1)) {
23449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23450 }
23451 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23452 {
23453 PyThreadState* __tstate = wxPyBeginAllowThreads();
23454 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
23455 wxPyEndAllowThreads(__tstate);
23456 if (PyErr_Occurred()) SWIG_fail;
23457 }
23458 {
23459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23460 }
23461 return resultobj;
23462 fail:
23463 return NULL;
23464 }
23465
23466
23467 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23468 PyObject *resultobj = 0;
23469 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23470 bool result;
23471 void *argp1 = 0 ;
23472 int res1 = 0 ;
23473 PyObject *swig_obj[1] ;
23474
23475 if (!args) SWIG_fail;
23476 swig_obj[0] = args;
23477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23478 if (!SWIG_IsOK(res1)) {
23479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23480 }
23481 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23482 {
23483 PyThreadState* __tstate = wxPyBeginAllowThreads();
23484 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
23485 wxPyEndAllowThreads(__tstate);
23486 if (PyErr_Occurred()) SWIG_fail;
23487 }
23488 {
23489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23490 }
23491 return resultobj;
23492 fail:
23493 return NULL;
23494 }
23495
23496
23497 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23498 PyObject *resultobj = 0;
23499 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23500 bool result;
23501 void *argp1 = 0 ;
23502 int res1 = 0 ;
23503 PyObject *swig_obj[1] ;
23504
23505 if (!args) SWIG_fail;
23506 swig_obj[0] = args;
23507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23508 if (!SWIG_IsOK(res1)) {
23509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23510 }
23511 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23512 {
23513 PyThreadState* __tstate = wxPyBeginAllowThreads();
23514 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
23515 wxPyEndAllowThreads(__tstate);
23516 if (PyErr_Occurred()) SWIG_fail;
23517 }
23518 {
23519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23520 }
23521 return resultobj;
23522 fail:
23523 return NULL;
23524 }
23525
23526
23527 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23528 PyObject *resultobj = 0;
23529 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23530 bool result;
23531 void *argp1 = 0 ;
23532 int res1 = 0 ;
23533 PyObject *swig_obj[1] ;
23534
23535 if (!args) SWIG_fail;
23536 swig_obj[0] = args;
23537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23538 if (!SWIG_IsOK(res1)) {
23539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23540 }
23541 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23542 {
23543 PyThreadState* __tstate = wxPyBeginAllowThreads();
23544 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
23545 wxPyEndAllowThreads(__tstate);
23546 if (PyErr_Occurred()) SWIG_fail;
23547 }
23548 {
23549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23550 }
23551 return resultobj;
23552 fail:
23553 return NULL;
23554 }
23555
23556
23557 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23558 PyObject *resultobj = 0;
23559 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23560 bool result;
23561 void *argp1 = 0 ;
23562 int res1 = 0 ;
23563 PyObject *swig_obj[1] ;
23564
23565 if (!args) SWIG_fail;
23566 swig_obj[0] = args;
23567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23568 if (!SWIG_IsOK(res1)) {
23569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23570 }
23571 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23572 {
23573 PyThreadState* __tstate = wxPyBeginAllowThreads();
23574 result = (bool)(arg1)->LeftIsDown();
23575 wxPyEndAllowThreads(__tstate);
23576 if (PyErr_Occurred()) SWIG_fail;
23577 }
23578 {
23579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23580 }
23581 return resultobj;
23582 fail:
23583 return NULL;
23584 }
23585
23586
23587 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23588 PyObject *resultobj = 0;
23589 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23590 bool result;
23591 void *argp1 = 0 ;
23592 int res1 = 0 ;
23593 PyObject *swig_obj[1] ;
23594
23595 if (!args) SWIG_fail;
23596 swig_obj[0] = args;
23597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23598 if (!SWIG_IsOK(res1)) {
23599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23600 }
23601 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23602 {
23603 PyThreadState* __tstate = wxPyBeginAllowThreads();
23604 result = (bool)(arg1)->MiddleIsDown();
23605 wxPyEndAllowThreads(__tstate);
23606 if (PyErr_Occurred()) SWIG_fail;
23607 }
23608 {
23609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23610 }
23611 return resultobj;
23612 fail:
23613 return NULL;
23614 }
23615
23616
23617 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23618 PyObject *resultobj = 0;
23619 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23620 bool result;
23621 void *argp1 = 0 ;
23622 int res1 = 0 ;
23623 PyObject *swig_obj[1] ;
23624
23625 if (!args) SWIG_fail;
23626 swig_obj[0] = args;
23627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23628 if (!SWIG_IsOK(res1)) {
23629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23630 }
23631 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23632 {
23633 PyThreadState* __tstate = wxPyBeginAllowThreads();
23634 result = (bool)(arg1)->RightIsDown();
23635 wxPyEndAllowThreads(__tstate);
23636 if (PyErr_Occurred()) SWIG_fail;
23637 }
23638 {
23639 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23640 }
23641 return resultobj;
23642 fail:
23643 return NULL;
23644 }
23645
23646
23647 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23648 PyObject *resultobj = 0;
23649 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23650 bool result;
23651 void *argp1 = 0 ;
23652 int res1 = 0 ;
23653 PyObject *swig_obj[1] ;
23654
23655 if (!args) SWIG_fail;
23656 swig_obj[0] = args;
23657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23658 if (!SWIG_IsOK(res1)) {
23659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23660 }
23661 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23662 {
23663 PyThreadState* __tstate = wxPyBeginAllowThreads();
23664 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
23665 wxPyEndAllowThreads(__tstate);
23666 if (PyErr_Occurred()) SWIG_fail;
23667 }
23668 {
23669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23670 }
23671 return resultobj;
23672 fail:
23673 return NULL;
23674 }
23675
23676
23677 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23678 PyObject *resultobj = 0;
23679 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23680 bool result;
23681 void *argp1 = 0 ;
23682 int res1 = 0 ;
23683 PyObject *swig_obj[1] ;
23684
23685 if (!args) SWIG_fail;
23686 swig_obj[0] = args;
23687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23688 if (!SWIG_IsOK(res1)) {
23689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23690 }
23691 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23692 {
23693 PyThreadState* __tstate = wxPyBeginAllowThreads();
23694 result = (bool)((wxMouseEvent const *)arg1)->Moving();
23695 wxPyEndAllowThreads(__tstate);
23696 if (PyErr_Occurred()) SWIG_fail;
23697 }
23698 {
23699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23700 }
23701 return resultobj;
23702 fail:
23703 return NULL;
23704 }
23705
23706
23707 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23708 PyObject *resultobj = 0;
23709 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23710 bool result;
23711 void *argp1 = 0 ;
23712 int res1 = 0 ;
23713 PyObject *swig_obj[1] ;
23714
23715 if (!args) SWIG_fail;
23716 swig_obj[0] = args;
23717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23718 if (!SWIG_IsOK(res1)) {
23719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23720 }
23721 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23722 {
23723 PyThreadState* __tstate = wxPyBeginAllowThreads();
23724 result = (bool)((wxMouseEvent const *)arg1)->Entering();
23725 wxPyEndAllowThreads(__tstate);
23726 if (PyErr_Occurred()) SWIG_fail;
23727 }
23728 {
23729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23730 }
23731 return resultobj;
23732 fail:
23733 return NULL;
23734 }
23735
23736
23737 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23738 PyObject *resultobj = 0;
23739 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23740 bool result;
23741 void *argp1 = 0 ;
23742 int res1 = 0 ;
23743 PyObject *swig_obj[1] ;
23744
23745 if (!args) SWIG_fail;
23746 swig_obj[0] = args;
23747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23748 if (!SWIG_IsOK(res1)) {
23749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23750 }
23751 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23752 {
23753 PyThreadState* __tstate = wxPyBeginAllowThreads();
23754 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
23755 wxPyEndAllowThreads(__tstate);
23756 if (PyErr_Occurred()) SWIG_fail;
23757 }
23758 {
23759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23760 }
23761 return resultobj;
23762 fail:
23763 return NULL;
23764 }
23765
23766
23767 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23768 PyObject *resultobj = 0;
23769 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23770 wxPoint result;
23771 void *argp1 = 0 ;
23772 int res1 = 0 ;
23773 PyObject *swig_obj[1] ;
23774
23775 if (!args) SWIG_fail;
23776 swig_obj[0] = args;
23777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23778 if (!SWIG_IsOK(res1)) {
23779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23780 }
23781 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23782 {
23783 PyThreadState* __tstate = wxPyBeginAllowThreads();
23784 result = (arg1)->GetPosition();
23785 wxPyEndAllowThreads(__tstate);
23786 if (PyErr_Occurred()) SWIG_fail;
23787 }
23788 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23789 return resultobj;
23790 fail:
23791 return NULL;
23792 }
23793
23794
23795 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23796 PyObject *resultobj = 0;
23797 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23798 long *arg2 = (long *) 0 ;
23799 long *arg3 = (long *) 0 ;
23800 void *argp1 = 0 ;
23801 int res1 = 0 ;
23802 long temp2 ;
23803 int res2 = SWIG_TMPOBJ ;
23804 long temp3 ;
23805 int res3 = SWIG_TMPOBJ ;
23806 PyObject *swig_obj[1] ;
23807
23808 arg2 = &temp2;
23809 arg3 = &temp3;
23810 if (!args) SWIG_fail;
23811 swig_obj[0] = args;
23812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23813 if (!SWIG_IsOK(res1)) {
23814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23815 }
23816 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23817 {
23818 PyThreadState* __tstate = wxPyBeginAllowThreads();
23819 (arg1)->GetPosition(arg2,arg3);
23820 wxPyEndAllowThreads(__tstate);
23821 if (PyErr_Occurred()) SWIG_fail;
23822 }
23823 resultobj = SWIG_Py_Void();
23824 if (SWIG_IsTmpObj(res2)) {
23825 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
23826 } else {
23827 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23828 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
23829 }
23830 if (SWIG_IsTmpObj(res3)) {
23831 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
23832 } else {
23833 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23834 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
23835 }
23836 return resultobj;
23837 fail:
23838 return NULL;
23839 }
23840
23841
23842 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23843 PyObject *resultobj = 0;
23844 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23845 wxDC *arg2 = 0 ;
23846 wxPoint result;
23847 void *argp1 = 0 ;
23848 int res1 = 0 ;
23849 void *argp2 = 0 ;
23850 int res2 = 0 ;
23851 PyObject * obj0 = 0 ;
23852 PyObject * obj1 = 0 ;
23853 char * kwnames[] = {
23854 (char *) "self",(char *) "dc", NULL
23855 };
23856
23857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23859 if (!SWIG_IsOK(res1)) {
23860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23861 }
23862 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23863 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
23864 if (!SWIG_IsOK(res2)) {
23865 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23866 }
23867 if (!argp2) {
23868 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23869 }
23870 arg2 = reinterpret_cast< wxDC * >(argp2);
23871 {
23872 PyThreadState* __tstate = wxPyBeginAllowThreads();
23873 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
23874 wxPyEndAllowThreads(__tstate);
23875 if (PyErr_Occurred()) SWIG_fail;
23876 }
23877 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23878 return resultobj;
23879 fail:
23880 return NULL;
23881 }
23882
23883
23884 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23885 PyObject *resultobj = 0;
23886 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23887 int result;
23888 void *argp1 = 0 ;
23889 int res1 = 0 ;
23890 PyObject *swig_obj[1] ;
23891
23892 if (!args) SWIG_fail;
23893 swig_obj[0] = args;
23894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23895 if (!SWIG_IsOK(res1)) {
23896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23897 }
23898 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23899 {
23900 PyThreadState* __tstate = wxPyBeginAllowThreads();
23901 result = (int)((wxMouseEvent const *)arg1)->GetX();
23902 wxPyEndAllowThreads(__tstate);
23903 if (PyErr_Occurred()) SWIG_fail;
23904 }
23905 resultobj = SWIG_From_int(static_cast< int >(result));
23906 return resultobj;
23907 fail:
23908 return NULL;
23909 }
23910
23911
23912 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23913 PyObject *resultobj = 0;
23914 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23915 int result;
23916 void *argp1 = 0 ;
23917 int res1 = 0 ;
23918 PyObject *swig_obj[1] ;
23919
23920 if (!args) SWIG_fail;
23921 swig_obj[0] = args;
23922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23923 if (!SWIG_IsOK(res1)) {
23924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23925 }
23926 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23927 {
23928 PyThreadState* __tstate = wxPyBeginAllowThreads();
23929 result = (int)((wxMouseEvent const *)arg1)->GetY();
23930 wxPyEndAllowThreads(__tstate);
23931 if (PyErr_Occurred()) SWIG_fail;
23932 }
23933 resultobj = SWIG_From_int(static_cast< int >(result));
23934 return resultobj;
23935 fail:
23936 return NULL;
23937 }
23938
23939
23940 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23941 PyObject *resultobj = 0;
23942 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23943 int result;
23944 void *argp1 = 0 ;
23945 int res1 = 0 ;
23946 PyObject *swig_obj[1] ;
23947
23948 if (!args) SWIG_fail;
23949 swig_obj[0] = args;
23950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23951 if (!SWIG_IsOK(res1)) {
23952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23953 }
23954 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23955 {
23956 PyThreadState* __tstate = wxPyBeginAllowThreads();
23957 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
23958 wxPyEndAllowThreads(__tstate);
23959 if (PyErr_Occurred()) SWIG_fail;
23960 }
23961 resultobj = SWIG_From_int(static_cast< int >(result));
23962 return resultobj;
23963 fail:
23964 return NULL;
23965 }
23966
23967
23968 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23969 PyObject *resultobj = 0;
23970 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23971 int result;
23972 void *argp1 = 0 ;
23973 int res1 = 0 ;
23974 PyObject *swig_obj[1] ;
23975
23976 if (!args) SWIG_fail;
23977 swig_obj[0] = args;
23978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23979 if (!SWIG_IsOK(res1)) {
23980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23981 }
23982 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23983 {
23984 PyThreadState* __tstate = wxPyBeginAllowThreads();
23985 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
23986 wxPyEndAllowThreads(__tstate);
23987 if (PyErr_Occurred()) SWIG_fail;
23988 }
23989 resultobj = SWIG_From_int(static_cast< int >(result));
23990 return resultobj;
23991 fail:
23992 return NULL;
23993 }
23994
23995
23996 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23997 PyObject *resultobj = 0;
23998 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23999 int result;
24000 void *argp1 = 0 ;
24001 int res1 = 0 ;
24002 PyObject *swig_obj[1] ;
24003
24004 if (!args) SWIG_fail;
24005 swig_obj[0] = args;
24006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24007 if (!SWIG_IsOK(res1)) {
24008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24009 }
24010 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24011 {
24012 PyThreadState* __tstate = wxPyBeginAllowThreads();
24013 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
24014 wxPyEndAllowThreads(__tstate);
24015 if (PyErr_Occurred()) SWIG_fail;
24016 }
24017 resultobj = SWIG_From_int(static_cast< int >(result));
24018 return resultobj;
24019 fail:
24020 return NULL;
24021 }
24022
24023
24024 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24025 PyObject *resultobj = 0;
24026 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24027 bool result;
24028 void *argp1 = 0 ;
24029 int res1 = 0 ;
24030 PyObject *swig_obj[1] ;
24031
24032 if (!args) SWIG_fail;
24033 swig_obj[0] = args;
24034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24035 if (!SWIG_IsOK(res1)) {
24036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24037 }
24038 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24039 {
24040 PyThreadState* __tstate = wxPyBeginAllowThreads();
24041 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
24042 wxPyEndAllowThreads(__tstate);
24043 if (PyErr_Occurred()) SWIG_fail;
24044 }
24045 {
24046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24047 }
24048 return resultobj;
24049 fail:
24050 return NULL;
24051 }
24052
24053
24054 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24055 PyObject *resultobj = 0;
24056 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24057 int arg2 ;
24058 void *argp1 = 0 ;
24059 int res1 = 0 ;
24060 int val2 ;
24061 int ecode2 = 0 ;
24062 PyObject *swig_obj[2] ;
24063
24064 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
24065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24066 if (!SWIG_IsOK(res1)) {
24067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24068 }
24069 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24070 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24071 if (!SWIG_IsOK(ecode2)) {
24072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
24073 }
24074 arg2 = static_cast< int >(val2);
24075 if (arg1) (arg1)->m_x = arg2;
24076
24077 resultobj = SWIG_Py_Void();
24078 return resultobj;
24079 fail:
24080 return NULL;
24081 }
24082
24083
24084 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24085 PyObject *resultobj = 0;
24086 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24087 int result;
24088 void *argp1 = 0 ;
24089 int res1 = 0 ;
24090 PyObject *swig_obj[1] ;
24091
24092 if (!args) SWIG_fail;
24093 swig_obj[0] = args;
24094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24095 if (!SWIG_IsOK(res1)) {
24096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24097 }
24098 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24099 result = (int) ((arg1)->m_x);
24100 resultobj = SWIG_From_int(static_cast< int >(result));
24101 return resultobj;
24102 fail:
24103 return NULL;
24104 }
24105
24106
24107 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24108 PyObject *resultobj = 0;
24109 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24110 int arg2 ;
24111 void *argp1 = 0 ;
24112 int res1 = 0 ;
24113 int val2 ;
24114 int ecode2 = 0 ;
24115 PyObject *swig_obj[2] ;
24116
24117 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
24118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24119 if (!SWIG_IsOK(res1)) {
24120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24121 }
24122 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24123 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24124 if (!SWIG_IsOK(ecode2)) {
24125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
24126 }
24127 arg2 = static_cast< int >(val2);
24128 if (arg1) (arg1)->m_y = arg2;
24129
24130 resultobj = SWIG_Py_Void();
24131 return resultobj;
24132 fail:
24133 return NULL;
24134 }
24135
24136
24137 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24138 PyObject *resultobj = 0;
24139 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24140 int result;
24141 void *argp1 = 0 ;
24142 int res1 = 0 ;
24143 PyObject *swig_obj[1] ;
24144
24145 if (!args) SWIG_fail;
24146 swig_obj[0] = args;
24147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24148 if (!SWIG_IsOK(res1)) {
24149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24150 }
24151 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24152 result = (int) ((arg1)->m_y);
24153 resultobj = SWIG_From_int(static_cast< int >(result));
24154 return resultobj;
24155 fail:
24156 return NULL;
24157 }
24158
24159
24160 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24161 PyObject *resultobj = 0;
24162 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24163 bool arg2 ;
24164 void *argp1 = 0 ;
24165 int res1 = 0 ;
24166 bool val2 ;
24167 int ecode2 = 0 ;
24168 PyObject *swig_obj[2] ;
24169
24170 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
24171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24172 if (!SWIG_IsOK(res1)) {
24173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24174 }
24175 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24176 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24177 if (!SWIG_IsOK(ecode2)) {
24178 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
24179 }
24180 arg2 = static_cast< bool >(val2);
24181 if (arg1) (arg1)->m_leftDown = arg2;
24182
24183 resultobj = SWIG_Py_Void();
24184 return resultobj;
24185 fail:
24186 return NULL;
24187 }
24188
24189
24190 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24191 PyObject *resultobj = 0;
24192 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24193 bool result;
24194 void *argp1 = 0 ;
24195 int res1 = 0 ;
24196 PyObject *swig_obj[1] ;
24197
24198 if (!args) SWIG_fail;
24199 swig_obj[0] = args;
24200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24201 if (!SWIG_IsOK(res1)) {
24202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24203 }
24204 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24205 result = (bool) ((arg1)->m_leftDown);
24206 {
24207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24208 }
24209 return resultobj;
24210 fail:
24211 return NULL;
24212 }
24213
24214
24215 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24216 PyObject *resultobj = 0;
24217 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24218 bool arg2 ;
24219 void *argp1 = 0 ;
24220 int res1 = 0 ;
24221 bool val2 ;
24222 int ecode2 = 0 ;
24223 PyObject *swig_obj[2] ;
24224
24225 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
24226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24227 if (!SWIG_IsOK(res1)) {
24228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24229 }
24230 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24231 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24232 if (!SWIG_IsOK(ecode2)) {
24233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
24234 }
24235 arg2 = static_cast< bool >(val2);
24236 if (arg1) (arg1)->m_middleDown = arg2;
24237
24238 resultobj = SWIG_Py_Void();
24239 return resultobj;
24240 fail:
24241 return NULL;
24242 }
24243
24244
24245 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24246 PyObject *resultobj = 0;
24247 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24248 bool result;
24249 void *argp1 = 0 ;
24250 int res1 = 0 ;
24251 PyObject *swig_obj[1] ;
24252
24253 if (!args) SWIG_fail;
24254 swig_obj[0] = args;
24255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24256 if (!SWIG_IsOK(res1)) {
24257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24258 }
24259 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24260 result = (bool) ((arg1)->m_middleDown);
24261 {
24262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24263 }
24264 return resultobj;
24265 fail:
24266 return NULL;
24267 }
24268
24269
24270 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24271 PyObject *resultobj = 0;
24272 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24273 bool arg2 ;
24274 void *argp1 = 0 ;
24275 int res1 = 0 ;
24276 bool val2 ;
24277 int ecode2 = 0 ;
24278 PyObject *swig_obj[2] ;
24279
24280 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
24281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24282 if (!SWIG_IsOK(res1)) {
24283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24284 }
24285 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24286 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24287 if (!SWIG_IsOK(ecode2)) {
24288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
24289 }
24290 arg2 = static_cast< bool >(val2);
24291 if (arg1) (arg1)->m_rightDown = arg2;
24292
24293 resultobj = SWIG_Py_Void();
24294 return resultobj;
24295 fail:
24296 return NULL;
24297 }
24298
24299
24300 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24301 PyObject *resultobj = 0;
24302 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24303 bool result;
24304 void *argp1 = 0 ;
24305 int res1 = 0 ;
24306 PyObject *swig_obj[1] ;
24307
24308 if (!args) SWIG_fail;
24309 swig_obj[0] = args;
24310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24311 if (!SWIG_IsOK(res1)) {
24312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24313 }
24314 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24315 result = (bool) ((arg1)->m_rightDown);
24316 {
24317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24318 }
24319 return resultobj;
24320 fail:
24321 return NULL;
24322 }
24323
24324
24325 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24326 PyObject *resultobj = 0;
24327 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24328 bool arg2 ;
24329 void *argp1 = 0 ;
24330 int res1 = 0 ;
24331 bool val2 ;
24332 int ecode2 = 0 ;
24333 PyObject *swig_obj[2] ;
24334
24335 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
24336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24337 if (!SWIG_IsOK(res1)) {
24338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24339 }
24340 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24341 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24342 if (!SWIG_IsOK(ecode2)) {
24343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
24344 }
24345 arg2 = static_cast< bool >(val2);
24346 if (arg1) (arg1)->m_controlDown = arg2;
24347
24348 resultobj = SWIG_Py_Void();
24349 return resultobj;
24350 fail:
24351 return NULL;
24352 }
24353
24354
24355 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24356 PyObject *resultobj = 0;
24357 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24358 bool result;
24359 void *argp1 = 0 ;
24360 int res1 = 0 ;
24361 PyObject *swig_obj[1] ;
24362
24363 if (!args) SWIG_fail;
24364 swig_obj[0] = args;
24365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24366 if (!SWIG_IsOK(res1)) {
24367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24368 }
24369 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24370 result = (bool) ((arg1)->m_controlDown);
24371 {
24372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24373 }
24374 return resultobj;
24375 fail:
24376 return NULL;
24377 }
24378
24379
24380 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24381 PyObject *resultobj = 0;
24382 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24383 bool arg2 ;
24384 void *argp1 = 0 ;
24385 int res1 = 0 ;
24386 bool val2 ;
24387 int ecode2 = 0 ;
24388 PyObject *swig_obj[2] ;
24389
24390 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
24391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24392 if (!SWIG_IsOK(res1)) {
24393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24394 }
24395 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24396 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24397 if (!SWIG_IsOK(ecode2)) {
24398 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
24399 }
24400 arg2 = static_cast< bool >(val2);
24401 if (arg1) (arg1)->m_shiftDown = arg2;
24402
24403 resultobj = SWIG_Py_Void();
24404 return resultobj;
24405 fail:
24406 return NULL;
24407 }
24408
24409
24410 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24411 PyObject *resultobj = 0;
24412 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24413 bool result;
24414 void *argp1 = 0 ;
24415 int res1 = 0 ;
24416 PyObject *swig_obj[1] ;
24417
24418 if (!args) SWIG_fail;
24419 swig_obj[0] = args;
24420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24421 if (!SWIG_IsOK(res1)) {
24422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24423 }
24424 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24425 result = (bool) ((arg1)->m_shiftDown);
24426 {
24427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24428 }
24429 return resultobj;
24430 fail:
24431 return NULL;
24432 }
24433
24434
24435 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24436 PyObject *resultobj = 0;
24437 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24438 bool arg2 ;
24439 void *argp1 = 0 ;
24440 int res1 = 0 ;
24441 bool val2 ;
24442 int ecode2 = 0 ;
24443 PyObject *swig_obj[2] ;
24444
24445 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
24446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24447 if (!SWIG_IsOK(res1)) {
24448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24449 }
24450 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24451 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24452 if (!SWIG_IsOK(ecode2)) {
24453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
24454 }
24455 arg2 = static_cast< bool >(val2);
24456 if (arg1) (arg1)->m_altDown = arg2;
24457
24458 resultobj = SWIG_Py_Void();
24459 return resultobj;
24460 fail:
24461 return NULL;
24462 }
24463
24464
24465 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24466 PyObject *resultobj = 0;
24467 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24468 bool result;
24469 void *argp1 = 0 ;
24470 int res1 = 0 ;
24471 PyObject *swig_obj[1] ;
24472
24473 if (!args) SWIG_fail;
24474 swig_obj[0] = args;
24475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24476 if (!SWIG_IsOK(res1)) {
24477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24478 }
24479 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24480 result = (bool) ((arg1)->m_altDown);
24481 {
24482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24483 }
24484 return resultobj;
24485 fail:
24486 return NULL;
24487 }
24488
24489
24490 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24491 PyObject *resultobj = 0;
24492 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24493 bool arg2 ;
24494 void *argp1 = 0 ;
24495 int res1 = 0 ;
24496 bool val2 ;
24497 int ecode2 = 0 ;
24498 PyObject *swig_obj[2] ;
24499
24500 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
24501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24502 if (!SWIG_IsOK(res1)) {
24503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24504 }
24505 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24506 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24507 if (!SWIG_IsOK(ecode2)) {
24508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
24509 }
24510 arg2 = static_cast< bool >(val2);
24511 if (arg1) (arg1)->m_metaDown = arg2;
24512
24513 resultobj = SWIG_Py_Void();
24514 return resultobj;
24515 fail:
24516 return NULL;
24517 }
24518
24519
24520 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24521 PyObject *resultobj = 0;
24522 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24523 bool result;
24524 void *argp1 = 0 ;
24525 int res1 = 0 ;
24526 PyObject *swig_obj[1] ;
24527
24528 if (!args) SWIG_fail;
24529 swig_obj[0] = args;
24530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24531 if (!SWIG_IsOK(res1)) {
24532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24533 }
24534 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24535 result = (bool) ((arg1)->m_metaDown);
24536 {
24537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24538 }
24539 return resultobj;
24540 fail:
24541 return NULL;
24542 }
24543
24544
24545 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24546 PyObject *resultobj = 0;
24547 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24548 int arg2 ;
24549 void *argp1 = 0 ;
24550 int res1 = 0 ;
24551 int val2 ;
24552 int ecode2 = 0 ;
24553 PyObject *swig_obj[2] ;
24554
24555 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
24556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24557 if (!SWIG_IsOK(res1)) {
24558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24559 }
24560 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24561 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24562 if (!SWIG_IsOK(ecode2)) {
24563 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
24564 }
24565 arg2 = static_cast< int >(val2);
24566 if (arg1) (arg1)->m_wheelRotation = arg2;
24567
24568 resultobj = SWIG_Py_Void();
24569 return resultobj;
24570 fail:
24571 return NULL;
24572 }
24573
24574
24575 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24576 PyObject *resultobj = 0;
24577 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24578 int result;
24579 void *argp1 = 0 ;
24580 int res1 = 0 ;
24581 PyObject *swig_obj[1] ;
24582
24583 if (!args) SWIG_fail;
24584 swig_obj[0] = args;
24585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24586 if (!SWIG_IsOK(res1)) {
24587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24588 }
24589 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24590 result = (int) ((arg1)->m_wheelRotation);
24591 resultobj = SWIG_From_int(static_cast< int >(result));
24592 return resultobj;
24593 fail:
24594 return NULL;
24595 }
24596
24597
24598 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24599 PyObject *resultobj = 0;
24600 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24601 int arg2 ;
24602 void *argp1 = 0 ;
24603 int res1 = 0 ;
24604 int val2 ;
24605 int ecode2 = 0 ;
24606 PyObject *swig_obj[2] ;
24607
24608 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
24609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24610 if (!SWIG_IsOK(res1)) {
24611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24612 }
24613 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24614 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24615 if (!SWIG_IsOK(ecode2)) {
24616 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
24617 }
24618 arg2 = static_cast< int >(val2);
24619 if (arg1) (arg1)->m_wheelDelta = arg2;
24620
24621 resultobj = SWIG_Py_Void();
24622 return resultobj;
24623 fail:
24624 return NULL;
24625 }
24626
24627
24628 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24629 PyObject *resultobj = 0;
24630 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24631 int result;
24632 void *argp1 = 0 ;
24633 int res1 = 0 ;
24634 PyObject *swig_obj[1] ;
24635
24636 if (!args) SWIG_fail;
24637 swig_obj[0] = args;
24638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24639 if (!SWIG_IsOK(res1)) {
24640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24641 }
24642 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24643 result = (int) ((arg1)->m_wheelDelta);
24644 resultobj = SWIG_From_int(static_cast< int >(result));
24645 return resultobj;
24646 fail:
24647 return NULL;
24648 }
24649
24650
24651 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24652 PyObject *resultobj = 0;
24653 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24654 int arg2 ;
24655 void *argp1 = 0 ;
24656 int res1 = 0 ;
24657 int val2 ;
24658 int ecode2 = 0 ;
24659 PyObject *swig_obj[2] ;
24660
24661 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
24662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24663 if (!SWIG_IsOK(res1)) {
24664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24665 }
24666 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24667 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24668 if (!SWIG_IsOK(ecode2)) {
24669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
24670 }
24671 arg2 = static_cast< int >(val2);
24672 if (arg1) (arg1)->m_linesPerAction = arg2;
24673
24674 resultobj = SWIG_Py_Void();
24675 return resultobj;
24676 fail:
24677 return NULL;
24678 }
24679
24680
24681 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24682 PyObject *resultobj = 0;
24683 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24684 int result;
24685 void *argp1 = 0 ;
24686 int res1 = 0 ;
24687 PyObject *swig_obj[1] ;
24688
24689 if (!args) SWIG_fail;
24690 swig_obj[0] = args;
24691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24692 if (!SWIG_IsOK(res1)) {
24693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24694 }
24695 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24696 result = (int) ((arg1)->m_linesPerAction);
24697 resultobj = SWIG_From_int(static_cast< int >(result));
24698 return resultobj;
24699 fail:
24700 return NULL;
24701 }
24702
24703
24704 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24705 PyObject *obj;
24706 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24707 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
24708 return SWIG_Py_Void();
24709 }
24710
24711 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24712 return SWIG_Python_InitShadowInstance(args);
24713 }
24714
24715 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24716 PyObject *resultobj = 0;
24717 int arg1 = (int) 0 ;
24718 int arg2 = (int) 0 ;
24719 wxSetCursorEvent *result = 0 ;
24720 int val1 ;
24721 int ecode1 = 0 ;
24722 int val2 ;
24723 int ecode2 = 0 ;
24724 PyObject * obj0 = 0 ;
24725 PyObject * obj1 = 0 ;
24726 char * kwnames[] = {
24727 (char *) "x",(char *) "y", NULL
24728 };
24729
24730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24731 if (obj0) {
24732 ecode1 = SWIG_AsVal_int(obj0, &val1);
24733 if (!SWIG_IsOK(ecode1)) {
24734 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
24735 }
24736 arg1 = static_cast< int >(val1);
24737 }
24738 if (obj1) {
24739 ecode2 = SWIG_AsVal_int(obj1, &val2);
24740 if (!SWIG_IsOK(ecode2)) {
24741 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
24742 }
24743 arg2 = static_cast< int >(val2);
24744 }
24745 {
24746 PyThreadState* __tstate = wxPyBeginAllowThreads();
24747 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
24748 wxPyEndAllowThreads(__tstate);
24749 if (PyErr_Occurred()) SWIG_fail;
24750 }
24751 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
24752 return resultobj;
24753 fail:
24754 return NULL;
24755 }
24756
24757
24758 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24759 PyObject *resultobj = 0;
24760 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24761 int result;
24762 void *argp1 = 0 ;
24763 int res1 = 0 ;
24764 PyObject *swig_obj[1] ;
24765
24766 if (!args) SWIG_fail;
24767 swig_obj[0] = args;
24768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24769 if (!SWIG_IsOK(res1)) {
24770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24771 }
24772 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24773 {
24774 PyThreadState* __tstate = wxPyBeginAllowThreads();
24775 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
24776 wxPyEndAllowThreads(__tstate);
24777 if (PyErr_Occurred()) SWIG_fail;
24778 }
24779 resultobj = SWIG_From_int(static_cast< int >(result));
24780 return resultobj;
24781 fail:
24782 return NULL;
24783 }
24784
24785
24786 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24787 PyObject *resultobj = 0;
24788 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24789 int result;
24790 void *argp1 = 0 ;
24791 int res1 = 0 ;
24792 PyObject *swig_obj[1] ;
24793
24794 if (!args) SWIG_fail;
24795 swig_obj[0] = args;
24796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24797 if (!SWIG_IsOK(res1)) {
24798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24799 }
24800 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24801 {
24802 PyThreadState* __tstate = wxPyBeginAllowThreads();
24803 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
24804 wxPyEndAllowThreads(__tstate);
24805 if (PyErr_Occurred()) SWIG_fail;
24806 }
24807 resultobj = SWIG_From_int(static_cast< int >(result));
24808 return resultobj;
24809 fail:
24810 return NULL;
24811 }
24812
24813
24814 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24815 PyObject *resultobj = 0;
24816 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24817 wxCursor *arg2 = 0 ;
24818 void *argp1 = 0 ;
24819 int res1 = 0 ;
24820 void *argp2 = 0 ;
24821 int res2 = 0 ;
24822 PyObject * obj0 = 0 ;
24823 PyObject * obj1 = 0 ;
24824 char * kwnames[] = {
24825 (char *) "self",(char *) "cursor", NULL
24826 };
24827
24828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
24829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24830 if (!SWIG_IsOK(res1)) {
24831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
24832 }
24833 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24834 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
24835 if (!SWIG_IsOK(res2)) {
24836 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24837 }
24838 if (!argp2) {
24839 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24840 }
24841 arg2 = reinterpret_cast< wxCursor * >(argp2);
24842 {
24843 PyThreadState* __tstate = wxPyBeginAllowThreads();
24844 (arg1)->SetCursor((wxCursor const &)*arg2);
24845 wxPyEndAllowThreads(__tstate);
24846 if (PyErr_Occurred()) SWIG_fail;
24847 }
24848 resultobj = SWIG_Py_Void();
24849 return resultobj;
24850 fail:
24851 return NULL;
24852 }
24853
24854
24855 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24856 PyObject *resultobj = 0;
24857 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24858 wxCursor *result = 0 ;
24859 void *argp1 = 0 ;
24860 int res1 = 0 ;
24861 PyObject *swig_obj[1] ;
24862
24863 if (!args) SWIG_fail;
24864 swig_obj[0] = args;
24865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24866 if (!SWIG_IsOK(res1)) {
24867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24868 }
24869 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24870 {
24871 PyThreadState* __tstate = wxPyBeginAllowThreads();
24872 {
24873 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
24874 result = (wxCursor *) &_result_ref;
24875 }
24876 wxPyEndAllowThreads(__tstate);
24877 if (PyErr_Occurred()) SWIG_fail;
24878 }
24879 {
24880 wxCursor* resultptr = new wxCursor(*result);
24881 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
24882 }
24883 return resultobj;
24884 fail:
24885 return NULL;
24886 }
24887
24888
24889 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24890 PyObject *resultobj = 0;
24891 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24892 bool result;
24893 void *argp1 = 0 ;
24894 int res1 = 0 ;
24895 PyObject *swig_obj[1] ;
24896
24897 if (!args) SWIG_fail;
24898 swig_obj[0] = args;
24899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24900 if (!SWIG_IsOK(res1)) {
24901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24902 }
24903 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24904 {
24905 PyThreadState* __tstate = wxPyBeginAllowThreads();
24906 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
24907 wxPyEndAllowThreads(__tstate);
24908 if (PyErr_Occurred()) SWIG_fail;
24909 }
24910 {
24911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24912 }
24913 return resultobj;
24914 fail:
24915 return NULL;
24916 }
24917
24918
24919 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24920 PyObject *obj;
24921 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24922 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
24923 return SWIG_Py_Void();
24924 }
24925
24926 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24927 return SWIG_Python_InitShadowInstance(args);
24928 }
24929
24930 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24931 PyObject *resultobj = 0;
24932 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24933 wxKeyEvent *result = 0 ;
24934 int val1 ;
24935 int ecode1 = 0 ;
24936 PyObject * obj0 = 0 ;
24937 char * kwnames[] = {
24938 (char *) "eventType", NULL
24939 };
24940
24941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
24942 if (obj0) {
24943 ecode1 = SWIG_AsVal_int(obj0, &val1);
24944 if (!SWIG_IsOK(ecode1)) {
24945 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24946 }
24947 arg1 = static_cast< wxEventType >(val1);
24948 }
24949 {
24950 PyThreadState* __tstate = wxPyBeginAllowThreads();
24951 result = (wxKeyEvent *)new wxKeyEvent(arg1);
24952 wxPyEndAllowThreads(__tstate);
24953 if (PyErr_Occurred()) SWIG_fail;
24954 }
24955 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
24956 return resultobj;
24957 fail:
24958 return NULL;
24959 }
24960
24961
24962 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24963 PyObject *resultobj = 0;
24964 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24965 int result;
24966 void *argp1 = 0 ;
24967 int res1 = 0 ;
24968 PyObject *swig_obj[1] ;
24969
24970 if (!args) SWIG_fail;
24971 swig_obj[0] = args;
24972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24973 if (!SWIG_IsOK(res1)) {
24974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24975 }
24976 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24977 {
24978 PyThreadState* __tstate = wxPyBeginAllowThreads();
24979 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
24980 wxPyEndAllowThreads(__tstate);
24981 if (PyErr_Occurred()) SWIG_fail;
24982 }
24983 resultobj = SWIG_From_int(static_cast< int >(result));
24984 return resultobj;
24985 fail:
24986 return NULL;
24987 }
24988
24989
24990 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24991 PyObject *resultobj = 0;
24992 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24993 bool result;
24994 void *argp1 = 0 ;
24995 int res1 = 0 ;
24996 PyObject *swig_obj[1] ;
24997
24998 if (!args) SWIG_fail;
24999 swig_obj[0] = args;
25000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25001 if (!SWIG_IsOK(res1)) {
25002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25003 }
25004 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25005 {
25006 PyThreadState* __tstate = wxPyBeginAllowThreads();
25007 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
25008 wxPyEndAllowThreads(__tstate);
25009 if (PyErr_Occurred()) SWIG_fail;
25010 }
25011 {
25012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25013 }
25014 return resultobj;
25015 fail:
25016 return NULL;
25017 }
25018
25019
25020 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25021 PyObject *resultobj = 0;
25022 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25023 bool result;
25024 void *argp1 = 0 ;
25025 int res1 = 0 ;
25026 PyObject *swig_obj[1] ;
25027
25028 if (!args) SWIG_fail;
25029 swig_obj[0] = args;
25030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25031 if (!SWIG_IsOK(res1)) {
25032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25033 }
25034 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25035 {
25036 PyThreadState* __tstate = wxPyBeginAllowThreads();
25037 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
25038 wxPyEndAllowThreads(__tstate);
25039 if (PyErr_Occurred()) SWIG_fail;
25040 }
25041 {
25042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25043 }
25044 return resultobj;
25045 fail:
25046 return NULL;
25047 }
25048
25049
25050 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25051 PyObject *resultobj = 0;
25052 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25053 bool result;
25054 void *argp1 = 0 ;
25055 int res1 = 0 ;
25056 PyObject *swig_obj[1] ;
25057
25058 if (!args) SWIG_fail;
25059 swig_obj[0] = args;
25060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25061 if (!SWIG_IsOK(res1)) {
25062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25063 }
25064 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25065 {
25066 PyThreadState* __tstate = wxPyBeginAllowThreads();
25067 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
25068 wxPyEndAllowThreads(__tstate);
25069 if (PyErr_Occurred()) SWIG_fail;
25070 }
25071 {
25072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25073 }
25074 return resultobj;
25075 fail:
25076 return NULL;
25077 }
25078
25079
25080 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25081 PyObject *resultobj = 0;
25082 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25083 bool result;
25084 void *argp1 = 0 ;
25085 int res1 = 0 ;
25086 PyObject *swig_obj[1] ;
25087
25088 if (!args) SWIG_fail;
25089 swig_obj[0] = args;
25090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25091 if (!SWIG_IsOK(res1)) {
25092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25093 }
25094 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25095 {
25096 PyThreadState* __tstate = wxPyBeginAllowThreads();
25097 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
25098 wxPyEndAllowThreads(__tstate);
25099 if (PyErr_Occurred()) SWIG_fail;
25100 }
25101 {
25102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25103 }
25104 return resultobj;
25105 fail:
25106 return NULL;
25107 }
25108
25109
25110 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25111 PyObject *resultobj = 0;
25112 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25113 bool result;
25114 void *argp1 = 0 ;
25115 int res1 = 0 ;
25116 PyObject *swig_obj[1] ;
25117
25118 if (!args) SWIG_fail;
25119 swig_obj[0] = args;
25120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25121 if (!SWIG_IsOK(res1)) {
25122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25123 }
25124 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25125 {
25126 PyThreadState* __tstate = wxPyBeginAllowThreads();
25127 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
25128 wxPyEndAllowThreads(__tstate);
25129 if (PyErr_Occurred()) SWIG_fail;
25130 }
25131 {
25132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25133 }
25134 return resultobj;
25135 fail:
25136 return NULL;
25137 }
25138
25139
25140 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25141 PyObject *resultobj = 0;
25142 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25143 bool result;
25144 void *argp1 = 0 ;
25145 int res1 = 0 ;
25146 PyObject *swig_obj[1] ;
25147
25148 if (!args) SWIG_fail;
25149 swig_obj[0] = args;
25150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25151 if (!SWIG_IsOK(res1)) {
25152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25153 }
25154 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25155 {
25156 PyThreadState* __tstate = wxPyBeginAllowThreads();
25157 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
25158 wxPyEndAllowThreads(__tstate);
25159 if (PyErr_Occurred()) SWIG_fail;
25160 }
25161 {
25162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25163 }
25164 return resultobj;
25165 fail:
25166 return NULL;
25167 }
25168
25169
25170 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25171 PyObject *resultobj = 0;
25172 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25173 int result;
25174 void *argp1 = 0 ;
25175 int res1 = 0 ;
25176 PyObject *swig_obj[1] ;
25177
25178 if (!args) SWIG_fail;
25179 swig_obj[0] = args;
25180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25181 if (!SWIG_IsOK(res1)) {
25182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25183 }
25184 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25185 {
25186 PyThreadState* __tstate = wxPyBeginAllowThreads();
25187 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
25188 wxPyEndAllowThreads(__tstate);
25189 if (PyErr_Occurred()) SWIG_fail;
25190 }
25191 resultobj = SWIG_From_int(static_cast< int >(result));
25192 return resultobj;
25193 fail:
25194 return NULL;
25195 }
25196
25197
25198 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25199 PyObject *resultobj = 0;
25200 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25201 int result;
25202 void *argp1 = 0 ;
25203 int res1 = 0 ;
25204 PyObject *swig_obj[1] ;
25205
25206 if (!args) SWIG_fail;
25207 swig_obj[0] = args;
25208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25209 if (!SWIG_IsOK(res1)) {
25210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25211 }
25212 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25213 {
25214 PyThreadState* __tstate = wxPyBeginAllowThreads();
25215 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
25216 wxPyEndAllowThreads(__tstate);
25217 if (PyErr_Occurred()) SWIG_fail;
25218 }
25219 resultobj = SWIG_From_int(static_cast< int >(result));
25220 return resultobj;
25221 fail:
25222 return NULL;
25223 }
25224
25225
25226 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25227 PyObject *resultobj = 0;
25228 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25229 int arg2 ;
25230 void *argp1 = 0 ;
25231 int res1 = 0 ;
25232 int val2 ;
25233 int ecode2 = 0 ;
25234 PyObject * obj0 = 0 ;
25235 PyObject * obj1 = 0 ;
25236 char * kwnames[] = {
25237 (char *) "self",(char *) "uniChar", NULL
25238 };
25239
25240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
25241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25242 if (!SWIG_IsOK(res1)) {
25243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25244 }
25245 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25246 ecode2 = SWIG_AsVal_int(obj1, &val2);
25247 if (!SWIG_IsOK(ecode2)) {
25248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
25249 }
25250 arg2 = static_cast< int >(val2);
25251 {
25252 PyThreadState* __tstate = wxPyBeginAllowThreads();
25253 wxKeyEvent_SetUnicodeKey(arg1,arg2);
25254 wxPyEndAllowThreads(__tstate);
25255 if (PyErr_Occurred()) SWIG_fail;
25256 }
25257 resultobj = SWIG_Py_Void();
25258 return resultobj;
25259 fail:
25260 return NULL;
25261 }
25262
25263
25264 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25265 PyObject *resultobj = 0;
25266 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25267 unsigned int result;
25268 void *argp1 = 0 ;
25269 int res1 = 0 ;
25270 PyObject *swig_obj[1] ;
25271
25272 if (!args) SWIG_fail;
25273 swig_obj[0] = args;
25274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25275 if (!SWIG_IsOK(res1)) {
25276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25277 }
25278 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25279 {
25280 PyThreadState* __tstate = wxPyBeginAllowThreads();
25281 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
25282 wxPyEndAllowThreads(__tstate);
25283 if (PyErr_Occurred()) SWIG_fail;
25284 }
25285 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25286 return resultobj;
25287 fail:
25288 return NULL;
25289 }
25290
25291
25292 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25293 PyObject *resultobj = 0;
25294 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25295 unsigned int result;
25296 void *argp1 = 0 ;
25297 int res1 = 0 ;
25298 PyObject *swig_obj[1] ;
25299
25300 if (!args) SWIG_fail;
25301 swig_obj[0] = args;
25302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25303 if (!SWIG_IsOK(res1)) {
25304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25305 }
25306 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25307 {
25308 PyThreadState* __tstate = wxPyBeginAllowThreads();
25309 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
25310 wxPyEndAllowThreads(__tstate);
25311 if (PyErr_Occurred()) SWIG_fail;
25312 }
25313 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25314 return resultobj;
25315 fail:
25316 return NULL;
25317 }
25318
25319
25320 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25321 PyObject *resultobj = 0;
25322 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25323 wxPoint result;
25324 void *argp1 = 0 ;
25325 int res1 = 0 ;
25326 PyObject *swig_obj[1] ;
25327
25328 if (!args) SWIG_fail;
25329 swig_obj[0] = args;
25330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25331 if (!SWIG_IsOK(res1)) {
25332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25333 }
25334 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25335 {
25336 PyThreadState* __tstate = wxPyBeginAllowThreads();
25337 result = (arg1)->GetPosition();
25338 wxPyEndAllowThreads(__tstate);
25339 if (PyErr_Occurred()) SWIG_fail;
25340 }
25341 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25342 return resultobj;
25343 fail:
25344 return NULL;
25345 }
25346
25347
25348 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25349 PyObject *resultobj = 0;
25350 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25351 long *arg2 = (long *) 0 ;
25352 long *arg3 = (long *) 0 ;
25353 void *argp1 = 0 ;
25354 int res1 = 0 ;
25355 long temp2 ;
25356 int res2 = SWIG_TMPOBJ ;
25357 long temp3 ;
25358 int res3 = SWIG_TMPOBJ ;
25359 PyObject *swig_obj[1] ;
25360
25361 arg2 = &temp2;
25362 arg3 = &temp3;
25363 if (!args) SWIG_fail;
25364 swig_obj[0] = args;
25365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25366 if (!SWIG_IsOK(res1)) {
25367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25368 }
25369 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25370 {
25371 PyThreadState* __tstate = wxPyBeginAllowThreads();
25372 (arg1)->GetPosition(arg2,arg3);
25373 wxPyEndAllowThreads(__tstate);
25374 if (PyErr_Occurred()) SWIG_fail;
25375 }
25376 resultobj = SWIG_Py_Void();
25377 if (SWIG_IsTmpObj(res2)) {
25378 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
25379 } else {
25380 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25381 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
25382 }
25383 if (SWIG_IsTmpObj(res3)) {
25384 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
25385 } else {
25386 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25387 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
25388 }
25389 return resultobj;
25390 fail:
25391 return NULL;
25392 }
25393
25394
25395 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25396 PyObject *resultobj = 0;
25397 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25398 int result;
25399 void *argp1 = 0 ;
25400 int res1 = 0 ;
25401 PyObject *swig_obj[1] ;
25402
25403 if (!args) SWIG_fail;
25404 swig_obj[0] = args;
25405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25406 if (!SWIG_IsOK(res1)) {
25407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25408 }
25409 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25410 {
25411 PyThreadState* __tstate = wxPyBeginAllowThreads();
25412 result = (int)((wxKeyEvent const *)arg1)->GetX();
25413 wxPyEndAllowThreads(__tstate);
25414 if (PyErr_Occurred()) SWIG_fail;
25415 }
25416 resultobj = SWIG_From_int(static_cast< int >(result));
25417 return resultobj;
25418 fail:
25419 return NULL;
25420 }
25421
25422
25423 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25424 PyObject *resultobj = 0;
25425 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25426 int result;
25427 void *argp1 = 0 ;
25428 int res1 = 0 ;
25429 PyObject *swig_obj[1] ;
25430
25431 if (!args) SWIG_fail;
25432 swig_obj[0] = args;
25433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25434 if (!SWIG_IsOK(res1)) {
25435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25436 }
25437 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25438 {
25439 PyThreadState* __tstate = wxPyBeginAllowThreads();
25440 result = (int)((wxKeyEvent const *)arg1)->GetY();
25441 wxPyEndAllowThreads(__tstate);
25442 if (PyErr_Occurred()) SWIG_fail;
25443 }
25444 resultobj = SWIG_From_int(static_cast< int >(result));
25445 return resultobj;
25446 fail:
25447 return NULL;
25448 }
25449
25450
25451 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25452 PyObject *resultobj = 0;
25453 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25454 int arg2 ;
25455 void *argp1 = 0 ;
25456 int res1 = 0 ;
25457 int val2 ;
25458 int ecode2 = 0 ;
25459 PyObject *swig_obj[2] ;
25460
25461 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
25462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25463 if (!SWIG_IsOK(res1)) {
25464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25465 }
25466 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25467 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25468 if (!SWIG_IsOK(ecode2)) {
25469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
25470 }
25471 arg2 = static_cast< int >(val2);
25472 if (arg1) (arg1)->m_x = arg2;
25473
25474 resultobj = SWIG_Py_Void();
25475 return resultobj;
25476 fail:
25477 return NULL;
25478 }
25479
25480
25481 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25482 PyObject *resultobj = 0;
25483 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25484 int result;
25485 void *argp1 = 0 ;
25486 int res1 = 0 ;
25487 PyObject *swig_obj[1] ;
25488
25489 if (!args) SWIG_fail;
25490 swig_obj[0] = args;
25491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25492 if (!SWIG_IsOK(res1)) {
25493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25494 }
25495 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25496 result = (int) ((arg1)->m_x);
25497 resultobj = SWIG_From_int(static_cast< int >(result));
25498 return resultobj;
25499 fail:
25500 return NULL;
25501 }
25502
25503
25504 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25505 PyObject *resultobj = 0;
25506 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25507 int arg2 ;
25508 void *argp1 = 0 ;
25509 int res1 = 0 ;
25510 int val2 ;
25511 int ecode2 = 0 ;
25512 PyObject *swig_obj[2] ;
25513
25514 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
25515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25516 if (!SWIG_IsOK(res1)) {
25517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25518 }
25519 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25520 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25521 if (!SWIG_IsOK(ecode2)) {
25522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
25523 }
25524 arg2 = static_cast< int >(val2);
25525 if (arg1) (arg1)->m_y = arg2;
25526
25527 resultobj = SWIG_Py_Void();
25528 return resultobj;
25529 fail:
25530 return NULL;
25531 }
25532
25533
25534 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25535 PyObject *resultobj = 0;
25536 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25537 int result;
25538 void *argp1 = 0 ;
25539 int res1 = 0 ;
25540 PyObject *swig_obj[1] ;
25541
25542 if (!args) SWIG_fail;
25543 swig_obj[0] = args;
25544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25545 if (!SWIG_IsOK(res1)) {
25546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25547 }
25548 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25549 result = (int) ((arg1)->m_y);
25550 resultobj = SWIG_From_int(static_cast< int >(result));
25551 return resultobj;
25552 fail:
25553 return NULL;
25554 }
25555
25556
25557 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25558 PyObject *resultobj = 0;
25559 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25560 long arg2 ;
25561 void *argp1 = 0 ;
25562 int res1 = 0 ;
25563 long val2 ;
25564 int ecode2 = 0 ;
25565 PyObject *swig_obj[2] ;
25566
25567 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
25568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25569 if (!SWIG_IsOK(res1)) {
25570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25571 }
25572 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25573 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
25574 if (!SWIG_IsOK(ecode2)) {
25575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
25576 }
25577 arg2 = static_cast< long >(val2);
25578 if (arg1) (arg1)->m_keyCode = arg2;
25579
25580 resultobj = SWIG_Py_Void();
25581 return resultobj;
25582 fail:
25583 return NULL;
25584 }
25585
25586
25587 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25588 PyObject *resultobj = 0;
25589 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25590 long result;
25591 void *argp1 = 0 ;
25592 int res1 = 0 ;
25593 PyObject *swig_obj[1] ;
25594
25595 if (!args) SWIG_fail;
25596 swig_obj[0] = args;
25597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25598 if (!SWIG_IsOK(res1)) {
25599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25600 }
25601 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25602 result = (long) ((arg1)->m_keyCode);
25603 resultobj = SWIG_From_long(static_cast< long >(result));
25604 return resultobj;
25605 fail:
25606 return NULL;
25607 }
25608
25609
25610 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25611 PyObject *resultobj = 0;
25612 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25613 bool arg2 ;
25614 void *argp1 = 0 ;
25615 int res1 = 0 ;
25616 bool val2 ;
25617 int ecode2 = 0 ;
25618 PyObject *swig_obj[2] ;
25619
25620 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
25621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25622 if (!SWIG_IsOK(res1)) {
25623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25624 }
25625 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25626 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25627 if (!SWIG_IsOK(ecode2)) {
25628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
25629 }
25630 arg2 = static_cast< bool >(val2);
25631 if (arg1) (arg1)->m_controlDown = arg2;
25632
25633 resultobj = SWIG_Py_Void();
25634 return resultobj;
25635 fail:
25636 return NULL;
25637 }
25638
25639
25640 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25641 PyObject *resultobj = 0;
25642 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25643 bool result;
25644 void *argp1 = 0 ;
25645 int res1 = 0 ;
25646 PyObject *swig_obj[1] ;
25647
25648 if (!args) SWIG_fail;
25649 swig_obj[0] = args;
25650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25651 if (!SWIG_IsOK(res1)) {
25652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25653 }
25654 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25655 result = (bool) ((arg1)->m_controlDown);
25656 {
25657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25658 }
25659 return resultobj;
25660 fail:
25661 return NULL;
25662 }
25663
25664
25665 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25666 PyObject *resultobj = 0;
25667 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25668 bool arg2 ;
25669 void *argp1 = 0 ;
25670 int res1 = 0 ;
25671 bool val2 ;
25672 int ecode2 = 0 ;
25673 PyObject *swig_obj[2] ;
25674
25675 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
25676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25677 if (!SWIG_IsOK(res1)) {
25678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25679 }
25680 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25681 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25682 if (!SWIG_IsOK(ecode2)) {
25683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
25684 }
25685 arg2 = static_cast< bool >(val2);
25686 if (arg1) (arg1)->m_shiftDown = arg2;
25687
25688 resultobj = SWIG_Py_Void();
25689 return resultobj;
25690 fail:
25691 return NULL;
25692 }
25693
25694
25695 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25696 PyObject *resultobj = 0;
25697 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25698 bool result;
25699 void *argp1 = 0 ;
25700 int res1 = 0 ;
25701 PyObject *swig_obj[1] ;
25702
25703 if (!args) SWIG_fail;
25704 swig_obj[0] = args;
25705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25706 if (!SWIG_IsOK(res1)) {
25707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25708 }
25709 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25710 result = (bool) ((arg1)->m_shiftDown);
25711 {
25712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25713 }
25714 return resultobj;
25715 fail:
25716 return NULL;
25717 }
25718
25719
25720 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25721 PyObject *resultobj = 0;
25722 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25723 bool arg2 ;
25724 void *argp1 = 0 ;
25725 int res1 = 0 ;
25726 bool val2 ;
25727 int ecode2 = 0 ;
25728 PyObject *swig_obj[2] ;
25729
25730 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
25731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25732 if (!SWIG_IsOK(res1)) {
25733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25734 }
25735 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25736 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25737 if (!SWIG_IsOK(ecode2)) {
25738 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
25739 }
25740 arg2 = static_cast< bool >(val2);
25741 if (arg1) (arg1)->m_altDown = arg2;
25742
25743 resultobj = SWIG_Py_Void();
25744 return resultobj;
25745 fail:
25746 return NULL;
25747 }
25748
25749
25750 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25751 PyObject *resultobj = 0;
25752 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25753 bool result;
25754 void *argp1 = 0 ;
25755 int res1 = 0 ;
25756 PyObject *swig_obj[1] ;
25757
25758 if (!args) SWIG_fail;
25759 swig_obj[0] = args;
25760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25761 if (!SWIG_IsOK(res1)) {
25762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25763 }
25764 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25765 result = (bool) ((arg1)->m_altDown);
25766 {
25767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25768 }
25769 return resultobj;
25770 fail:
25771 return NULL;
25772 }
25773
25774
25775 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25776 PyObject *resultobj = 0;
25777 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25778 bool arg2 ;
25779 void *argp1 = 0 ;
25780 int res1 = 0 ;
25781 bool val2 ;
25782 int ecode2 = 0 ;
25783 PyObject *swig_obj[2] ;
25784
25785 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
25786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25787 if (!SWIG_IsOK(res1)) {
25788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25789 }
25790 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25791 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25792 if (!SWIG_IsOK(ecode2)) {
25793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
25794 }
25795 arg2 = static_cast< bool >(val2);
25796 if (arg1) (arg1)->m_metaDown = arg2;
25797
25798 resultobj = SWIG_Py_Void();
25799 return resultobj;
25800 fail:
25801 return NULL;
25802 }
25803
25804
25805 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25806 PyObject *resultobj = 0;
25807 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25808 bool result;
25809 void *argp1 = 0 ;
25810 int res1 = 0 ;
25811 PyObject *swig_obj[1] ;
25812
25813 if (!args) SWIG_fail;
25814 swig_obj[0] = args;
25815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25816 if (!SWIG_IsOK(res1)) {
25817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25818 }
25819 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25820 result = (bool) ((arg1)->m_metaDown);
25821 {
25822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25823 }
25824 return resultobj;
25825 fail:
25826 return NULL;
25827 }
25828
25829
25830 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25831 PyObject *resultobj = 0;
25832 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25833 bool arg2 ;
25834 void *argp1 = 0 ;
25835 int res1 = 0 ;
25836 bool val2 ;
25837 int ecode2 = 0 ;
25838 PyObject *swig_obj[2] ;
25839
25840 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
25841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25842 if (!SWIG_IsOK(res1)) {
25843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25844 }
25845 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25846 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25847 if (!SWIG_IsOK(ecode2)) {
25848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
25849 }
25850 arg2 = static_cast< bool >(val2);
25851 if (arg1) (arg1)->m_scanCode = arg2;
25852
25853 resultobj = SWIG_Py_Void();
25854 return resultobj;
25855 fail:
25856 return NULL;
25857 }
25858
25859
25860 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25861 PyObject *resultobj = 0;
25862 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25863 bool result;
25864 void *argp1 = 0 ;
25865 int res1 = 0 ;
25866 PyObject *swig_obj[1] ;
25867
25868 if (!args) SWIG_fail;
25869 swig_obj[0] = args;
25870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25871 if (!SWIG_IsOK(res1)) {
25872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25873 }
25874 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25875 result = (bool) ((arg1)->m_scanCode);
25876 {
25877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25878 }
25879 return resultobj;
25880 fail:
25881 return NULL;
25882 }
25883
25884
25885 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25886 PyObject *resultobj = 0;
25887 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25888 unsigned int arg2 ;
25889 void *argp1 = 0 ;
25890 int res1 = 0 ;
25891 unsigned int val2 ;
25892 int ecode2 = 0 ;
25893 PyObject *swig_obj[2] ;
25894
25895 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
25896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25897 if (!SWIG_IsOK(res1)) {
25898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25899 }
25900 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25901 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25902 if (!SWIG_IsOK(ecode2)) {
25903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
25904 }
25905 arg2 = static_cast< unsigned int >(val2);
25906 if (arg1) (arg1)->m_rawCode = arg2;
25907
25908 resultobj = SWIG_Py_Void();
25909 return resultobj;
25910 fail:
25911 return NULL;
25912 }
25913
25914
25915 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25916 PyObject *resultobj = 0;
25917 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25918 unsigned int result;
25919 void *argp1 = 0 ;
25920 int res1 = 0 ;
25921 PyObject *swig_obj[1] ;
25922
25923 if (!args) SWIG_fail;
25924 swig_obj[0] = args;
25925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25926 if (!SWIG_IsOK(res1)) {
25927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25928 }
25929 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25930 result = (unsigned int) ((arg1)->m_rawCode);
25931 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25932 return resultobj;
25933 fail:
25934 return NULL;
25935 }
25936
25937
25938 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25939 PyObject *resultobj = 0;
25940 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25941 unsigned int arg2 ;
25942 void *argp1 = 0 ;
25943 int res1 = 0 ;
25944 unsigned int val2 ;
25945 int ecode2 = 0 ;
25946 PyObject *swig_obj[2] ;
25947
25948 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
25949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25950 if (!SWIG_IsOK(res1)) {
25951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25952 }
25953 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25954 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25955 if (!SWIG_IsOK(ecode2)) {
25956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
25957 }
25958 arg2 = static_cast< unsigned int >(val2);
25959 if (arg1) (arg1)->m_rawFlags = arg2;
25960
25961 resultobj = SWIG_Py_Void();
25962 return resultobj;
25963 fail:
25964 return NULL;
25965 }
25966
25967
25968 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25969 PyObject *resultobj = 0;
25970 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25971 unsigned int result;
25972 void *argp1 = 0 ;
25973 int res1 = 0 ;
25974 PyObject *swig_obj[1] ;
25975
25976 if (!args) SWIG_fail;
25977 swig_obj[0] = args;
25978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25979 if (!SWIG_IsOK(res1)) {
25980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25981 }
25982 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25983 result = (unsigned int) ((arg1)->m_rawFlags);
25984 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25985 return resultobj;
25986 fail:
25987 return NULL;
25988 }
25989
25990
25991 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25992 PyObject *obj;
25993 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25994 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
25995 return SWIG_Py_Void();
25996 }
25997
25998 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25999 return SWIG_Python_InitShadowInstance(args);
26000 }
26001
26002 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26003 PyObject *resultobj = 0;
26004 wxSize const &arg1_defvalue = wxDefaultSize ;
26005 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
26006 int arg2 = (int) 0 ;
26007 wxSizeEvent *result = 0 ;
26008 wxSize temp1 ;
26009 int val2 ;
26010 int ecode2 = 0 ;
26011 PyObject * obj0 = 0 ;
26012 PyObject * obj1 = 0 ;
26013 char * kwnames[] = {
26014 (char *) "sz",(char *) "winid", NULL
26015 };
26016
26017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26018 if (obj0) {
26019 {
26020 arg1 = &temp1;
26021 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
26022 }
26023 }
26024 if (obj1) {
26025 ecode2 = SWIG_AsVal_int(obj1, &val2);
26026 if (!SWIG_IsOK(ecode2)) {
26027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
26028 }
26029 arg2 = static_cast< int >(val2);
26030 }
26031 {
26032 PyThreadState* __tstate = wxPyBeginAllowThreads();
26033 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
26034 wxPyEndAllowThreads(__tstate);
26035 if (PyErr_Occurred()) SWIG_fail;
26036 }
26037 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
26038 return resultobj;
26039 fail:
26040 return NULL;
26041 }
26042
26043
26044 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26045 PyObject *resultobj = 0;
26046 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26047 wxSize result;
26048 void *argp1 = 0 ;
26049 int res1 = 0 ;
26050 PyObject *swig_obj[1] ;
26051
26052 if (!args) SWIG_fail;
26053 swig_obj[0] = args;
26054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26055 if (!SWIG_IsOK(res1)) {
26056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
26057 }
26058 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26059 {
26060 PyThreadState* __tstate = wxPyBeginAllowThreads();
26061 result = ((wxSizeEvent const *)arg1)->GetSize();
26062 wxPyEndAllowThreads(__tstate);
26063 if (PyErr_Occurred()) SWIG_fail;
26064 }
26065 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
26066 return resultobj;
26067 fail:
26068 return NULL;
26069 }
26070
26071
26072 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26073 PyObject *resultobj = 0;
26074 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26075 wxRect result;
26076 void *argp1 = 0 ;
26077 int res1 = 0 ;
26078 PyObject *swig_obj[1] ;
26079
26080 if (!args) SWIG_fail;
26081 swig_obj[0] = args;
26082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26083 if (!SWIG_IsOK(res1)) {
26084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
26085 }
26086 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26087 {
26088 PyThreadState* __tstate = wxPyBeginAllowThreads();
26089 result = ((wxSizeEvent const *)arg1)->GetRect();
26090 wxPyEndAllowThreads(__tstate);
26091 if (PyErr_Occurred()) SWIG_fail;
26092 }
26093 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26094 return resultobj;
26095 fail:
26096 return NULL;
26097 }
26098
26099
26100 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26101 PyObject *resultobj = 0;
26102 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26103 wxRect arg2 ;
26104 void *argp1 = 0 ;
26105 int res1 = 0 ;
26106 void *argp2 ;
26107 int res2 = 0 ;
26108 PyObject * obj0 = 0 ;
26109 PyObject * obj1 = 0 ;
26110 char * kwnames[] = {
26111 (char *) "self",(char *) "rect", NULL
26112 };
26113
26114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26116 if (!SWIG_IsOK(res1)) {
26117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26118 }
26119 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26120 {
26121 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
26122 if (!SWIG_IsOK(res2)) {
26123 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26124 }
26125 if (!argp2) {
26126 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26127 } else {
26128 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
26129 arg2 = *temp;
26130 if (SWIG_IsNewObj(res2)) delete temp;
26131 }
26132 }
26133 {
26134 PyThreadState* __tstate = wxPyBeginAllowThreads();
26135 (arg1)->SetRect(arg2);
26136 wxPyEndAllowThreads(__tstate);
26137 if (PyErr_Occurred()) SWIG_fail;
26138 }
26139 resultobj = SWIG_Py_Void();
26140 return resultobj;
26141 fail:
26142 return NULL;
26143 }
26144
26145
26146 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26147 PyObject *resultobj = 0;
26148 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26149 wxSize arg2 ;
26150 void *argp1 = 0 ;
26151 int res1 = 0 ;
26152 void *argp2 ;
26153 int res2 = 0 ;
26154 PyObject * obj0 = 0 ;
26155 PyObject * obj1 = 0 ;
26156 char * kwnames[] = {
26157 (char *) "self",(char *) "size", NULL
26158 };
26159
26160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
26161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26162 if (!SWIG_IsOK(res1)) {
26163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26164 }
26165 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26166 {
26167 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
26168 if (!SWIG_IsOK(res2)) {
26169 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26170 }
26171 if (!argp2) {
26172 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26173 } else {
26174 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
26175 arg2 = *temp;
26176 if (SWIG_IsNewObj(res2)) delete temp;
26177 }
26178 }
26179 {
26180 PyThreadState* __tstate = wxPyBeginAllowThreads();
26181 wxSizeEvent_SetSize(arg1,arg2);
26182 wxPyEndAllowThreads(__tstate);
26183 if (PyErr_Occurred()) SWIG_fail;
26184 }
26185 resultobj = SWIG_Py_Void();
26186 return resultobj;
26187 fail:
26188 return NULL;
26189 }
26190
26191
26192 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26193 PyObject *resultobj = 0;
26194 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26195 wxSize *arg2 = (wxSize *) 0 ;
26196 void *argp1 = 0 ;
26197 int res1 = 0 ;
26198 void *argp2 = 0 ;
26199 int res2 = 0 ;
26200 PyObject *swig_obj[2] ;
26201
26202 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
26203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26204 if (!SWIG_IsOK(res1)) {
26205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26206 }
26207 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26208 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
26209 if (!SWIG_IsOK(res2)) {
26210 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
26211 }
26212 arg2 = reinterpret_cast< wxSize * >(argp2);
26213 if (arg1) (arg1)->m_size = *arg2;
26214
26215 resultobj = SWIG_Py_Void();
26216 return resultobj;
26217 fail:
26218 return NULL;
26219 }
26220
26221
26222 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26223 PyObject *resultobj = 0;
26224 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26225 wxSize *result = 0 ;
26226 void *argp1 = 0 ;
26227 int res1 = 0 ;
26228 PyObject *swig_obj[1] ;
26229
26230 if (!args) SWIG_fail;
26231 swig_obj[0] = args;
26232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26233 if (!SWIG_IsOK(res1)) {
26234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26235 }
26236 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26237 result = (wxSize *)& ((arg1)->m_size);
26238 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
26239 return resultobj;
26240 fail:
26241 return NULL;
26242 }
26243
26244
26245 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26246 PyObject *resultobj = 0;
26247 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26248 wxRect *arg2 = (wxRect *) 0 ;
26249 void *argp1 = 0 ;
26250 int res1 = 0 ;
26251 void *argp2 = 0 ;
26252 int res2 = 0 ;
26253 PyObject *swig_obj[2] ;
26254
26255 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
26256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26257 if (!SWIG_IsOK(res1)) {
26258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26259 }
26260 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26261 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
26262 if (!SWIG_IsOK(res2)) {
26263 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
26264 }
26265 arg2 = reinterpret_cast< wxRect * >(argp2);
26266 if (arg1) (arg1)->m_rect = *arg2;
26267
26268 resultobj = SWIG_Py_Void();
26269 return resultobj;
26270 fail:
26271 return NULL;
26272 }
26273
26274
26275 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26276 PyObject *resultobj = 0;
26277 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26278 wxRect *result = 0 ;
26279 void *argp1 = 0 ;
26280 int res1 = 0 ;
26281 PyObject *swig_obj[1] ;
26282
26283 if (!args) SWIG_fail;
26284 swig_obj[0] = args;
26285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26286 if (!SWIG_IsOK(res1)) {
26287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26288 }
26289 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26290 result = (wxRect *)& ((arg1)->m_rect);
26291 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
26292 return resultobj;
26293 fail:
26294 return NULL;
26295 }
26296
26297
26298 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26299 PyObject *obj;
26300 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26301 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
26302 return SWIG_Py_Void();
26303 }
26304
26305 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26306 return SWIG_Python_InitShadowInstance(args);
26307 }
26308
26309 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26310 PyObject *resultobj = 0;
26311 wxPoint const &arg1_defvalue = wxDefaultPosition ;
26312 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
26313 int arg2 = (int) 0 ;
26314 wxMoveEvent *result = 0 ;
26315 wxPoint temp1 ;
26316 int val2 ;
26317 int ecode2 = 0 ;
26318 PyObject * obj0 = 0 ;
26319 PyObject * obj1 = 0 ;
26320 char * kwnames[] = {
26321 (char *) "pos",(char *) "winid", NULL
26322 };
26323
26324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26325 if (obj0) {
26326 {
26327 arg1 = &temp1;
26328 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
26329 }
26330 }
26331 if (obj1) {
26332 ecode2 = SWIG_AsVal_int(obj1, &val2);
26333 if (!SWIG_IsOK(ecode2)) {
26334 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
26335 }
26336 arg2 = static_cast< int >(val2);
26337 }
26338 {
26339 PyThreadState* __tstate = wxPyBeginAllowThreads();
26340 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
26341 wxPyEndAllowThreads(__tstate);
26342 if (PyErr_Occurred()) SWIG_fail;
26343 }
26344 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
26345 return resultobj;
26346 fail:
26347 return NULL;
26348 }
26349
26350
26351 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26352 PyObject *resultobj = 0;
26353 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26354 wxPoint result;
26355 void *argp1 = 0 ;
26356 int res1 = 0 ;
26357 PyObject *swig_obj[1] ;
26358
26359 if (!args) SWIG_fail;
26360 swig_obj[0] = args;
26361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26362 if (!SWIG_IsOK(res1)) {
26363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26364 }
26365 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26366 {
26367 PyThreadState* __tstate = wxPyBeginAllowThreads();
26368 result = ((wxMoveEvent const *)arg1)->GetPosition();
26369 wxPyEndAllowThreads(__tstate);
26370 if (PyErr_Occurred()) SWIG_fail;
26371 }
26372 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
26373 return resultobj;
26374 fail:
26375 return NULL;
26376 }
26377
26378
26379 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26380 PyObject *resultobj = 0;
26381 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26382 wxRect result;
26383 void *argp1 = 0 ;
26384 int res1 = 0 ;
26385 PyObject *swig_obj[1] ;
26386
26387 if (!args) SWIG_fail;
26388 swig_obj[0] = args;
26389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26390 if (!SWIG_IsOK(res1)) {
26391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26392 }
26393 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26394 {
26395 PyThreadState* __tstate = wxPyBeginAllowThreads();
26396 result = ((wxMoveEvent const *)arg1)->GetRect();
26397 wxPyEndAllowThreads(__tstate);
26398 if (PyErr_Occurred()) SWIG_fail;
26399 }
26400 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26401 return resultobj;
26402 fail:
26403 return NULL;
26404 }
26405
26406
26407 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26408 PyObject *resultobj = 0;
26409 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26410 wxRect *arg2 = 0 ;
26411 void *argp1 = 0 ;
26412 int res1 = 0 ;
26413 wxRect temp2 ;
26414 PyObject * obj0 = 0 ;
26415 PyObject * obj1 = 0 ;
26416 char * kwnames[] = {
26417 (char *) "self",(char *) "rect", NULL
26418 };
26419
26420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26422 if (!SWIG_IsOK(res1)) {
26423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26424 }
26425 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26426 {
26427 arg2 = &temp2;
26428 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26429 }
26430 {
26431 PyThreadState* __tstate = wxPyBeginAllowThreads();
26432 (arg1)->SetRect((wxRect const &)*arg2);
26433 wxPyEndAllowThreads(__tstate);
26434 if (PyErr_Occurred()) SWIG_fail;
26435 }
26436 resultobj = SWIG_Py_Void();
26437 return resultobj;
26438 fail:
26439 return NULL;
26440 }
26441
26442
26443 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26444 PyObject *resultobj = 0;
26445 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26446 wxPoint *arg2 = 0 ;
26447 void *argp1 = 0 ;
26448 int res1 = 0 ;
26449 wxPoint temp2 ;
26450 PyObject * obj0 = 0 ;
26451 PyObject * obj1 = 0 ;
26452 char * kwnames[] = {
26453 (char *) "self",(char *) "pos", NULL
26454 };
26455
26456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26458 if (!SWIG_IsOK(res1)) {
26459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26460 }
26461 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26462 {
26463 arg2 = &temp2;
26464 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26465 }
26466 {
26467 PyThreadState* __tstate = wxPyBeginAllowThreads();
26468 (arg1)->SetPosition((wxPoint const &)*arg2);
26469 wxPyEndAllowThreads(__tstate);
26470 if (PyErr_Occurred()) SWIG_fail;
26471 }
26472 resultobj = SWIG_Py_Void();
26473 return resultobj;
26474 fail:
26475 return NULL;
26476 }
26477
26478
26479 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26480 PyObject *obj;
26481 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26482 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
26483 return SWIG_Py_Void();
26484 }
26485
26486 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26487 return SWIG_Python_InitShadowInstance(args);
26488 }
26489
26490 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26491 PyObject *resultobj = 0;
26492 int arg1 = (int) 0 ;
26493 wxPaintEvent *result = 0 ;
26494 int val1 ;
26495 int ecode1 = 0 ;
26496 PyObject * obj0 = 0 ;
26497 char * kwnames[] = {
26498 (char *) "Id", NULL
26499 };
26500
26501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
26502 if (obj0) {
26503 ecode1 = SWIG_AsVal_int(obj0, &val1);
26504 if (!SWIG_IsOK(ecode1)) {
26505 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
26506 }
26507 arg1 = static_cast< int >(val1);
26508 }
26509 {
26510 PyThreadState* __tstate = wxPyBeginAllowThreads();
26511 result = (wxPaintEvent *)new wxPaintEvent(arg1);
26512 wxPyEndAllowThreads(__tstate);
26513 if (PyErr_Occurred()) SWIG_fail;
26514 }
26515 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
26516 return resultobj;
26517 fail:
26518 return NULL;
26519 }
26520
26521
26522 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26523 PyObject *obj;
26524 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26525 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
26526 return SWIG_Py_Void();
26527 }
26528
26529 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26530 return SWIG_Python_InitShadowInstance(args);
26531 }
26532
26533 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26534 PyObject *resultobj = 0;
26535 int arg1 = (int) 0 ;
26536 wxNcPaintEvent *result = 0 ;
26537 int val1 ;
26538 int ecode1 = 0 ;
26539 PyObject * obj0 = 0 ;
26540 char * kwnames[] = {
26541 (char *) "winid", NULL
26542 };
26543
26544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
26545 if (obj0) {
26546 ecode1 = SWIG_AsVal_int(obj0, &val1);
26547 if (!SWIG_IsOK(ecode1)) {
26548 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
26549 }
26550 arg1 = static_cast< int >(val1);
26551 }
26552 {
26553 PyThreadState* __tstate = wxPyBeginAllowThreads();
26554 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
26555 wxPyEndAllowThreads(__tstate);
26556 if (PyErr_Occurred()) SWIG_fail;
26557 }
26558 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
26559 return resultobj;
26560 fail:
26561 return NULL;
26562 }
26563
26564
26565 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26566 PyObject *obj;
26567 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26568 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
26569 return SWIG_Py_Void();
26570 }
26571
26572 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26573 return SWIG_Python_InitShadowInstance(args);
26574 }
26575
26576 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26577 PyObject *resultobj = 0;
26578 int arg1 = (int) 0 ;
26579 wxDC *arg2 = (wxDC *) NULL ;
26580 wxEraseEvent *result = 0 ;
26581 int val1 ;
26582 int ecode1 = 0 ;
26583 void *argp2 = 0 ;
26584 int res2 = 0 ;
26585 PyObject * obj0 = 0 ;
26586 PyObject * obj1 = 0 ;
26587 char * kwnames[] = {
26588 (char *) "Id",(char *) "dc", NULL
26589 };
26590
26591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26592 if (obj0) {
26593 ecode1 = SWIG_AsVal_int(obj0, &val1);
26594 if (!SWIG_IsOK(ecode1)) {
26595 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
26596 }
26597 arg1 = static_cast< int >(val1);
26598 }
26599 if (obj1) {
26600 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
26601 if (!SWIG_IsOK(res2)) {
26602 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
26603 }
26604 arg2 = reinterpret_cast< wxDC * >(argp2);
26605 }
26606 {
26607 PyThreadState* __tstate = wxPyBeginAllowThreads();
26608 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
26609 wxPyEndAllowThreads(__tstate);
26610 if (PyErr_Occurred()) SWIG_fail;
26611 }
26612 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
26613 return resultobj;
26614 fail:
26615 return NULL;
26616 }
26617
26618
26619 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26620 PyObject *resultobj = 0;
26621 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
26622 wxDC *result = 0 ;
26623 void *argp1 = 0 ;
26624 int res1 = 0 ;
26625 PyObject *swig_obj[1] ;
26626
26627 if (!args) SWIG_fail;
26628 swig_obj[0] = args;
26629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
26630 if (!SWIG_IsOK(res1)) {
26631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
26632 }
26633 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
26634 {
26635 PyThreadState* __tstate = wxPyBeginAllowThreads();
26636 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
26637 wxPyEndAllowThreads(__tstate);
26638 if (PyErr_Occurred()) SWIG_fail;
26639 }
26640 {
26641 resultobj = wxPyMake_wxObject(result, (bool)0);
26642 }
26643 return resultobj;
26644 fail:
26645 return NULL;
26646 }
26647
26648
26649 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26650 PyObject *obj;
26651 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26652 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
26653 return SWIG_Py_Void();
26654 }
26655
26656 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26657 return SWIG_Python_InitShadowInstance(args);
26658 }
26659
26660 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26661 PyObject *resultobj = 0;
26662 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26663 int arg2 = (int) 0 ;
26664 wxFocusEvent *result = 0 ;
26665 int val1 ;
26666 int ecode1 = 0 ;
26667 int val2 ;
26668 int ecode2 = 0 ;
26669 PyObject * obj0 = 0 ;
26670 PyObject * obj1 = 0 ;
26671 char * kwnames[] = {
26672 (char *) "type",(char *) "winid", NULL
26673 };
26674
26675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26676 if (obj0) {
26677 ecode1 = SWIG_AsVal_int(obj0, &val1);
26678 if (!SWIG_IsOK(ecode1)) {
26679 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26680 }
26681 arg1 = static_cast< wxEventType >(val1);
26682 }
26683 if (obj1) {
26684 ecode2 = SWIG_AsVal_int(obj1, &val2);
26685 if (!SWIG_IsOK(ecode2)) {
26686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
26687 }
26688 arg2 = static_cast< int >(val2);
26689 }
26690 {
26691 PyThreadState* __tstate = wxPyBeginAllowThreads();
26692 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
26693 wxPyEndAllowThreads(__tstate);
26694 if (PyErr_Occurred()) SWIG_fail;
26695 }
26696 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
26697 return resultobj;
26698 fail:
26699 return NULL;
26700 }
26701
26702
26703 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26704 PyObject *resultobj = 0;
26705 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26706 wxWindow *result = 0 ;
26707 void *argp1 = 0 ;
26708 int res1 = 0 ;
26709 PyObject *swig_obj[1] ;
26710
26711 if (!args) SWIG_fail;
26712 swig_obj[0] = args;
26713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26714 if (!SWIG_IsOK(res1)) {
26715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
26716 }
26717 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26718 {
26719 PyThreadState* __tstate = wxPyBeginAllowThreads();
26720 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
26721 wxPyEndAllowThreads(__tstate);
26722 if (PyErr_Occurred()) SWIG_fail;
26723 }
26724 {
26725 resultobj = wxPyMake_wxObject(result, (bool)0);
26726 }
26727 return resultobj;
26728 fail:
26729 return NULL;
26730 }
26731
26732
26733 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26734 PyObject *resultobj = 0;
26735 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26736 wxWindow *arg2 = (wxWindow *) 0 ;
26737 void *argp1 = 0 ;
26738 int res1 = 0 ;
26739 void *argp2 = 0 ;
26740 int res2 = 0 ;
26741 PyObject * obj0 = 0 ;
26742 PyObject * obj1 = 0 ;
26743 char * kwnames[] = {
26744 (char *) "self",(char *) "win", NULL
26745 };
26746
26747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
26748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26749 if (!SWIG_IsOK(res1)) {
26750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
26751 }
26752 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26753 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26754 if (!SWIG_IsOK(res2)) {
26755 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
26756 }
26757 arg2 = reinterpret_cast< wxWindow * >(argp2);
26758 {
26759 PyThreadState* __tstate = wxPyBeginAllowThreads();
26760 (arg1)->SetWindow(arg2);
26761 wxPyEndAllowThreads(__tstate);
26762 if (PyErr_Occurred()) SWIG_fail;
26763 }
26764 resultobj = SWIG_Py_Void();
26765 return resultobj;
26766 fail:
26767 return NULL;
26768 }
26769
26770
26771 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26772 PyObject *obj;
26773 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26774 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
26775 return SWIG_Py_Void();
26776 }
26777
26778 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26779 return SWIG_Python_InitShadowInstance(args);
26780 }
26781
26782 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26783 PyObject *resultobj = 0;
26784 wxWindow *arg1 = (wxWindow *) NULL ;
26785 wxChildFocusEvent *result = 0 ;
26786 void *argp1 = 0 ;
26787 int res1 = 0 ;
26788 PyObject * obj0 = 0 ;
26789 char * kwnames[] = {
26790 (char *) "win", NULL
26791 };
26792
26793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
26794 if (obj0) {
26795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26796 if (!SWIG_IsOK(res1)) {
26797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26798 }
26799 arg1 = reinterpret_cast< wxWindow * >(argp1);
26800 }
26801 {
26802 PyThreadState* __tstate = wxPyBeginAllowThreads();
26803 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
26804 wxPyEndAllowThreads(__tstate);
26805 if (PyErr_Occurred()) SWIG_fail;
26806 }
26807 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
26808 return resultobj;
26809 fail:
26810 return NULL;
26811 }
26812
26813
26814 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26815 PyObject *resultobj = 0;
26816 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
26817 wxWindow *result = 0 ;
26818 void *argp1 = 0 ;
26819 int res1 = 0 ;
26820 PyObject *swig_obj[1] ;
26821
26822 if (!args) SWIG_fail;
26823 swig_obj[0] = args;
26824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
26825 if (!SWIG_IsOK(res1)) {
26826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
26827 }
26828 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
26829 {
26830 PyThreadState* __tstate = wxPyBeginAllowThreads();
26831 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
26832 wxPyEndAllowThreads(__tstate);
26833 if (PyErr_Occurred()) SWIG_fail;
26834 }
26835 {
26836 resultobj = wxPyMake_wxObject(result, (bool)0);
26837 }
26838 return resultobj;
26839 fail:
26840 return NULL;
26841 }
26842
26843
26844 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26845 PyObject *obj;
26846 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26847 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
26848 return SWIG_Py_Void();
26849 }
26850
26851 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26852 return SWIG_Python_InitShadowInstance(args);
26853 }
26854
26855 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26856 PyObject *resultobj = 0;
26857 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26858 bool arg2 = (bool) true ;
26859 int arg3 = (int) 0 ;
26860 wxActivateEvent *result = 0 ;
26861 int val1 ;
26862 int ecode1 = 0 ;
26863 bool val2 ;
26864 int ecode2 = 0 ;
26865 int val3 ;
26866 int ecode3 = 0 ;
26867 PyObject * obj0 = 0 ;
26868 PyObject * obj1 = 0 ;
26869 PyObject * obj2 = 0 ;
26870 char * kwnames[] = {
26871 (char *) "type",(char *) "active",(char *) "Id", NULL
26872 };
26873
26874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26875 if (obj0) {
26876 ecode1 = SWIG_AsVal_int(obj0, &val1);
26877 if (!SWIG_IsOK(ecode1)) {
26878 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26879 }
26880 arg1 = static_cast< wxEventType >(val1);
26881 }
26882 if (obj1) {
26883 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26884 if (!SWIG_IsOK(ecode2)) {
26885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
26886 }
26887 arg2 = static_cast< bool >(val2);
26888 }
26889 if (obj2) {
26890 ecode3 = SWIG_AsVal_int(obj2, &val3);
26891 if (!SWIG_IsOK(ecode3)) {
26892 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
26893 }
26894 arg3 = static_cast< int >(val3);
26895 }
26896 {
26897 PyThreadState* __tstate = wxPyBeginAllowThreads();
26898 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
26899 wxPyEndAllowThreads(__tstate);
26900 if (PyErr_Occurred()) SWIG_fail;
26901 }
26902 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
26903 return resultobj;
26904 fail:
26905 return NULL;
26906 }
26907
26908
26909 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26910 PyObject *resultobj = 0;
26911 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
26912 bool result;
26913 void *argp1 = 0 ;
26914 int res1 = 0 ;
26915 PyObject *swig_obj[1] ;
26916
26917 if (!args) SWIG_fail;
26918 swig_obj[0] = args;
26919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
26920 if (!SWIG_IsOK(res1)) {
26921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
26922 }
26923 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
26924 {
26925 PyThreadState* __tstate = wxPyBeginAllowThreads();
26926 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
26927 wxPyEndAllowThreads(__tstate);
26928 if (PyErr_Occurred()) SWIG_fail;
26929 }
26930 {
26931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26932 }
26933 return resultobj;
26934 fail:
26935 return NULL;
26936 }
26937
26938
26939 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26940 PyObject *obj;
26941 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26942 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
26943 return SWIG_Py_Void();
26944 }
26945
26946 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26947 return SWIG_Python_InitShadowInstance(args);
26948 }
26949
26950 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26951 PyObject *resultobj = 0;
26952 int arg1 = (int) 0 ;
26953 wxInitDialogEvent *result = 0 ;
26954 int val1 ;
26955 int ecode1 = 0 ;
26956 PyObject * obj0 = 0 ;
26957 char * kwnames[] = {
26958 (char *) "Id", NULL
26959 };
26960
26961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
26962 if (obj0) {
26963 ecode1 = SWIG_AsVal_int(obj0, &val1);
26964 if (!SWIG_IsOK(ecode1)) {
26965 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
26966 }
26967 arg1 = static_cast< int >(val1);
26968 }
26969 {
26970 PyThreadState* __tstate = wxPyBeginAllowThreads();
26971 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
26972 wxPyEndAllowThreads(__tstate);
26973 if (PyErr_Occurred()) SWIG_fail;
26974 }
26975 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
26976 return resultobj;
26977 fail:
26978 return NULL;
26979 }
26980
26981
26982 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26983 PyObject *obj;
26984 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26985 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
26986 return SWIG_Py_Void();
26987 }
26988
26989 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26990 return SWIG_Python_InitShadowInstance(args);
26991 }
26992
26993 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26994 PyObject *resultobj = 0;
26995 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26996 int arg2 = (int) 0 ;
26997 wxMenu *arg3 = (wxMenu *) NULL ;
26998 wxMenuEvent *result = 0 ;
26999 int val1 ;
27000 int ecode1 = 0 ;
27001 int val2 ;
27002 int ecode2 = 0 ;
27003 void *argp3 = 0 ;
27004 int res3 = 0 ;
27005 PyObject * obj0 = 0 ;
27006 PyObject * obj1 = 0 ;
27007 PyObject * obj2 = 0 ;
27008 char * kwnames[] = {
27009 (char *) "type",(char *) "winid",(char *) "menu", NULL
27010 };
27011
27012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27013 if (obj0) {
27014 ecode1 = SWIG_AsVal_int(obj0, &val1);
27015 if (!SWIG_IsOK(ecode1)) {
27016 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27017 }
27018 arg1 = static_cast< wxEventType >(val1);
27019 }
27020 if (obj1) {
27021 ecode2 = SWIG_AsVal_int(obj1, &val2);
27022 if (!SWIG_IsOK(ecode2)) {
27023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
27024 }
27025 arg2 = static_cast< int >(val2);
27026 }
27027 if (obj2) {
27028 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
27029 if (!SWIG_IsOK(res3)) {
27030 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
27031 }
27032 arg3 = reinterpret_cast< wxMenu * >(argp3);
27033 }
27034 {
27035 PyThreadState* __tstate = wxPyBeginAllowThreads();
27036 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
27037 wxPyEndAllowThreads(__tstate);
27038 if (PyErr_Occurred()) SWIG_fail;
27039 }
27040 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
27041 return resultobj;
27042 fail:
27043 return NULL;
27044 }
27045
27046
27047 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27048 PyObject *resultobj = 0;
27049 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27050 int result;
27051 void *argp1 = 0 ;
27052 int res1 = 0 ;
27053 PyObject *swig_obj[1] ;
27054
27055 if (!args) SWIG_fail;
27056 swig_obj[0] = args;
27057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27058 if (!SWIG_IsOK(res1)) {
27059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27060 }
27061 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27062 {
27063 PyThreadState* __tstate = wxPyBeginAllowThreads();
27064 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
27065 wxPyEndAllowThreads(__tstate);
27066 if (PyErr_Occurred()) SWIG_fail;
27067 }
27068 resultobj = SWIG_From_int(static_cast< int >(result));
27069 return resultobj;
27070 fail:
27071 return NULL;
27072 }
27073
27074
27075 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27076 PyObject *resultobj = 0;
27077 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27078 bool result;
27079 void *argp1 = 0 ;
27080 int res1 = 0 ;
27081 PyObject *swig_obj[1] ;
27082
27083 if (!args) SWIG_fail;
27084 swig_obj[0] = args;
27085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27086 if (!SWIG_IsOK(res1)) {
27087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27088 }
27089 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27090 {
27091 PyThreadState* __tstate = wxPyBeginAllowThreads();
27092 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
27093 wxPyEndAllowThreads(__tstate);
27094 if (PyErr_Occurred()) SWIG_fail;
27095 }
27096 {
27097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27098 }
27099 return resultobj;
27100 fail:
27101 return NULL;
27102 }
27103
27104
27105 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27106 PyObject *resultobj = 0;
27107 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27108 wxMenu *result = 0 ;
27109 void *argp1 = 0 ;
27110 int res1 = 0 ;
27111 PyObject *swig_obj[1] ;
27112
27113 if (!args) SWIG_fail;
27114 swig_obj[0] = args;
27115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27116 if (!SWIG_IsOK(res1)) {
27117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27118 }
27119 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27120 {
27121 PyThreadState* __tstate = wxPyBeginAllowThreads();
27122 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
27123 wxPyEndAllowThreads(__tstate);
27124 if (PyErr_Occurred()) SWIG_fail;
27125 }
27126 {
27127 resultobj = wxPyMake_wxObject(result, (bool)0);
27128 }
27129 return resultobj;
27130 fail:
27131 return NULL;
27132 }
27133
27134
27135 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27136 PyObject *obj;
27137 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27138 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
27139 return SWIG_Py_Void();
27140 }
27141
27142 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27143 return SWIG_Python_InitShadowInstance(args);
27144 }
27145
27146 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27147 PyObject *resultobj = 0;
27148 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27149 int arg2 = (int) 0 ;
27150 wxCloseEvent *result = 0 ;
27151 int val1 ;
27152 int ecode1 = 0 ;
27153 int val2 ;
27154 int ecode2 = 0 ;
27155 PyObject * obj0 = 0 ;
27156 PyObject * obj1 = 0 ;
27157 char * kwnames[] = {
27158 (char *) "type",(char *) "winid", NULL
27159 };
27160
27161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27162 if (obj0) {
27163 ecode1 = SWIG_AsVal_int(obj0, &val1);
27164 if (!SWIG_IsOK(ecode1)) {
27165 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27166 }
27167 arg1 = static_cast< wxEventType >(val1);
27168 }
27169 if (obj1) {
27170 ecode2 = SWIG_AsVal_int(obj1, &val2);
27171 if (!SWIG_IsOK(ecode2)) {
27172 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
27173 }
27174 arg2 = static_cast< int >(val2);
27175 }
27176 {
27177 PyThreadState* __tstate = wxPyBeginAllowThreads();
27178 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
27179 wxPyEndAllowThreads(__tstate);
27180 if (PyErr_Occurred()) SWIG_fail;
27181 }
27182 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
27183 return resultobj;
27184 fail:
27185 return NULL;
27186 }
27187
27188
27189 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27190 PyObject *resultobj = 0;
27191 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27192 bool arg2 ;
27193 void *argp1 = 0 ;
27194 int res1 = 0 ;
27195 bool val2 ;
27196 int ecode2 = 0 ;
27197 PyObject * obj0 = 0 ;
27198 PyObject * obj1 = 0 ;
27199 char * kwnames[] = {
27200 (char *) "self",(char *) "logOff", NULL
27201 };
27202
27203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
27204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27205 if (!SWIG_IsOK(res1)) {
27206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27207 }
27208 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27209 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27210 if (!SWIG_IsOK(ecode2)) {
27211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
27212 }
27213 arg2 = static_cast< bool >(val2);
27214 {
27215 PyThreadState* __tstate = wxPyBeginAllowThreads();
27216 (arg1)->SetLoggingOff(arg2);
27217 wxPyEndAllowThreads(__tstate);
27218 if (PyErr_Occurred()) SWIG_fail;
27219 }
27220 resultobj = SWIG_Py_Void();
27221 return resultobj;
27222 fail:
27223 return NULL;
27224 }
27225
27226
27227 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27228 PyObject *resultobj = 0;
27229 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27230 bool result;
27231 void *argp1 = 0 ;
27232 int res1 = 0 ;
27233 PyObject *swig_obj[1] ;
27234
27235 if (!args) SWIG_fail;
27236 swig_obj[0] = args;
27237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27238 if (!SWIG_IsOK(res1)) {
27239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27240 }
27241 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27242 {
27243 PyThreadState* __tstate = wxPyBeginAllowThreads();
27244 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
27245 wxPyEndAllowThreads(__tstate);
27246 if (PyErr_Occurred()) SWIG_fail;
27247 }
27248 {
27249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27250 }
27251 return resultobj;
27252 fail:
27253 return NULL;
27254 }
27255
27256
27257 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27258 PyObject *resultobj = 0;
27259 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27260 bool arg2 = (bool) true ;
27261 void *argp1 = 0 ;
27262 int res1 = 0 ;
27263 bool val2 ;
27264 int ecode2 = 0 ;
27265 PyObject * obj0 = 0 ;
27266 PyObject * obj1 = 0 ;
27267 char * kwnames[] = {
27268 (char *) "self",(char *) "veto", NULL
27269 };
27270
27271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
27272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27273 if (!SWIG_IsOK(res1)) {
27274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27275 }
27276 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27277 if (obj1) {
27278 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27279 if (!SWIG_IsOK(ecode2)) {
27280 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
27281 }
27282 arg2 = static_cast< bool >(val2);
27283 }
27284 {
27285 PyThreadState* __tstate = wxPyBeginAllowThreads();
27286 (arg1)->Veto(arg2);
27287 wxPyEndAllowThreads(__tstate);
27288 if (PyErr_Occurred()) SWIG_fail;
27289 }
27290 resultobj = SWIG_Py_Void();
27291 return resultobj;
27292 fail:
27293 return NULL;
27294 }
27295
27296
27297 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27298 PyObject *resultobj = 0;
27299 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27300 bool result;
27301 void *argp1 = 0 ;
27302 int res1 = 0 ;
27303 PyObject *swig_obj[1] ;
27304
27305 if (!args) SWIG_fail;
27306 swig_obj[0] = args;
27307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27308 if (!SWIG_IsOK(res1)) {
27309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27310 }
27311 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27312 {
27313 PyThreadState* __tstate = wxPyBeginAllowThreads();
27314 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
27315 wxPyEndAllowThreads(__tstate);
27316 if (PyErr_Occurred()) SWIG_fail;
27317 }
27318 {
27319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27320 }
27321 return resultobj;
27322 fail:
27323 return NULL;
27324 }
27325
27326
27327 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27328 PyObject *resultobj = 0;
27329 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27330 bool arg2 ;
27331 void *argp1 = 0 ;
27332 int res1 = 0 ;
27333 bool val2 ;
27334 int ecode2 = 0 ;
27335 PyObject * obj0 = 0 ;
27336 PyObject * obj1 = 0 ;
27337 char * kwnames[] = {
27338 (char *) "self",(char *) "canVeto", NULL
27339 };
27340
27341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
27342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27343 if (!SWIG_IsOK(res1)) {
27344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27345 }
27346 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27347 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27348 if (!SWIG_IsOK(ecode2)) {
27349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
27350 }
27351 arg2 = static_cast< bool >(val2);
27352 {
27353 PyThreadState* __tstate = wxPyBeginAllowThreads();
27354 (arg1)->SetCanVeto(arg2);
27355 wxPyEndAllowThreads(__tstate);
27356 if (PyErr_Occurred()) SWIG_fail;
27357 }
27358 resultobj = SWIG_Py_Void();
27359 return resultobj;
27360 fail:
27361 return NULL;
27362 }
27363
27364
27365 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27366 PyObject *resultobj = 0;
27367 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27368 bool result;
27369 void *argp1 = 0 ;
27370 int res1 = 0 ;
27371 PyObject *swig_obj[1] ;
27372
27373 if (!args) SWIG_fail;
27374 swig_obj[0] = args;
27375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27376 if (!SWIG_IsOK(res1)) {
27377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27378 }
27379 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27380 {
27381 PyThreadState* __tstate = wxPyBeginAllowThreads();
27382 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
27383 wxPyEndAllowThreads(__tstate);
27384 if (PyErr_Occurred()) SWIG_fail;
27385 }
27386 {
27387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27388 }
27389 return resultobj;
27390 fail:
27391 return NULL;
27392 }
27393
27394
27395 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27396 PyObject *obj;
27397 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27398 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
27399 return SWIG_Py_Void();
27400 }
27401
27402 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27403 return SWIG_Python_InitShadowInstance(args);
27404 }
27405
27406 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27407 PyObject *resultobj = 0;
27408 int arg1 = (int) 0 ;
27409 bool arg2 = (bool) false ;
27410 wxShowEvent *result = 0 ;
27411 int val1 ;
27412 int ecode1 = 0 ;
27413 bool val2 ;
27414 int ecode2 = 0 ;
27415 PyObject * obj0 = 0 ;
27416 PyObject * obj1 = 0 ;
27417 char * kwnames[] = {
27418 (char *) "winid",(char *) "show", NULL
27419 };
27420
27421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27422 if (obj0) {
27423 ecode1 = SWIG_AsVal_int(obj0, &val1);
27424 if (!SWIG_IsOK(ecode1)) {
27425 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
27426 }
27427 arg1 = static_cast< int >(val1);
27428 }
27429 if (obj1) {
27430 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27431 if (!SWIG_IsOK(ecode2)) {
27432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
27433 }
27434 arg2 = static_cast< bool >(val2);
27435 }
27436 {
27437 PyThreadState* __tstate = wxPyBeginAllowThreads();
27438 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
27439 wxPyEndAllowThreads(__tstate);
27440 if (PyErr_Occurred()) SWIG_fail;
27441 }
27442 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
27443 return resultobj;
27444 fail:
27445 return NULL;
27446 }
27447
27448
27449 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27450 PyObject *resultobj = 0;
27451 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27452 bool arg2 ;
27453 void *argp1 = 0 ;
27454 int res1 = 0 ;
27455 bool val2 ;
27456 int ecode2 = 0 ;
27457 PyObject * obj0 = 0 ;
27458 PyObject * obj1 = 0 ;
27459 char * kwnames[] = {
27460 (char *) "self",(char *) "show", NULL
27461 };
27462
27463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
27464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27465 if (!SWIG_IsOK(res1)) {
27466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
27467 }
27468 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27469 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27470 if (!SWIG_IsOK(ecode2)) {
27471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
27472 }
27473 arg2 = static_cast< bool >(val2);
27474 {
27475 PyThreadState* __tstate = wxPyBeginAllowThreads();
27476 (arg1)->SetShow(arg2);
27477 wxPyEndAllowThreads(__tstate);
27478 if (PyErr_Occurred()) SWIG_fail;
27479 }
27480 resultobj = SWIG_Py_Void();
27481 return resultobj;
27482 fail:
27483 return NULL;
27484 }
27485
27486
27487 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27488 PyObject *resultobj = 0;
27489 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27490 bool result;
27491 void *argp1 = 0 ;
27492 int res1 = 0 ;
27493 PyObject *swig_obj[1] ;
27494
27495 if (!args) SWIG_fail;
27496 swig_obj[0] = args;
27497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27498 if (!SWIG_IsOK(res1)) {
27499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
27500 }
27501 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27502 {
27503 PyThreadState* __tstate = wxPyBeginAllowThreads();
27504 result = (bool)((wxShowEvent const *)arg1)->GetShow();
27505 wxPyEndAllowThreads(__tstate);
27506 if (PyErr_Occurred()) SWIG_fail;
27507 }
27508 {
27509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27510 }
27511 return resultobj;
27512 fail:
27513 return NULL;
27514 }
27515
27516
27517 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27518 PyObject *obj;
27519 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27520 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
27521 return SWIG_Py_Void();
27522 }
27523
27524 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27525 return SWIG_Python_InitShadowInstance(args);
27526 }
27527
27528 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27529 PyObject *resultobj = 0;
27530 int arg1 = (int) 0 ;
27531 bool arg2 = (bool) true ;
27532 wxIconizeEvent *result = 0 ;
27533 int val1 ;
27534 int ecode1 = 0 ;
27535 bool val2 ;
27536 int ecode2 = 0 ;
27537 PyObject * obj0 = 0 ;
27538 PyObject * obj1 = 0 ;
27539 char * kwnames[] = {
27540 (char *) "id",(char *) "iconized", NULL
27541 };
27542
27543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27544 if (obj0) {
27545 ecode1 = SWIG_AsVal_int(obj0, &val1);
27546 if (!SWIG_IsOK(ecode1)) {
27547 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
27548 }
27549 arg1 = static_cast< int >(val1);
27550 }
27551 if (obj1) {
27552 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27553 if (!SWIG_IsOK(ecode2)) {
27554 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
27555 }
27556 arg2 = static_cast< bool >(val2);
27557 }
27558 {
27559 PyThreadState* __tstate = wxPyBeginAllowThreads();
27560 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
27561 wxPyEndAllowThreads(__tstate);
27562 if (PyErr_Occurred()) SWIG_fail;
27563 }
27564 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
27565 return resultobj;
27566 fail:
27567 return NULL;
27568 }
27569
27570
27571 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27572 PyObject *resultobj = 0;
27573 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
27574 bool result;
27575 void *argp1 = 0 ;
27576 int res1 = 0 ;
27577 PyObject *swig_obj[1] ;
27578
27579 if (!args) SWIG_fail;
27580 swig_obj[0] = args;
27581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
27582 if (!SWIG_IsOK(res1)) {
27583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
27584 }
27585 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
27586 {
27587 PyThreadState* __tstate = wxPyBeginAllowThreads();
27588 result = (bool)(arg1)->Iconized();
27589 wxPyEndAllowThreads(__tstate);
27590 if (PyErr_Occurred()) SWIG_fail;
27591 }
27592 {
27593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27594 }
27595 return resultobj;
27596 fail:
27597 return NULL;
27598 }
27599
27600
27601 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27602 PyObject *obj;
27603 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27604 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
27605 return SWIG_Py_Void();
27606 }
27607
27608 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27609 return SWIG_Python_InitShadowInstance(args);
27610 }
27611
27612 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27613 PyObject *resultobj = 0;
27614 int arg1 = (int) 0 ;
27615 wxMaximizeEvent *result = 0 ;
27616 int val1 ;
27617 int ecode1 = 0 ;
27618 PyObject * obj0 = 0 ;
27619 char * kwnames[] = {
27620 (char *) "id", NULL
27621 };
27622
27623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
27624 if (obj0) {
27625 ecode1 = SWIG_AsVal_int(obj0, &val1);
27626 if (!SWIG_IsOK(ecode1)) {
27627 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
27628 }
27629 arg1 = static_cast< int >(val1);
27630 }
27631 {
27632 PyThreadState* __tstate = wxPyBeginAllowThreads();
27633 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
27634 wxPyEndAllowThreads(__tstate);
27635 if (PyErr_Occurred()) SWIG_fail;
27636 }
27637 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
27638 return resultobj;
27639 fail:
27640 return NULL;
27641 }
27642
27643
27644 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27645 PyObject *obj;
27646 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27647 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
27648 return SWIG_Py_Void();
27649 }
27650
27651 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27652 return SWIG_Python_InitShadowInstance(args);
27653 }
27654
27655 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27656 PyObject *resultobj = 0;
27657 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27658 wxPoint result;
27659 void *argp1 = 0 ;
27660 int res1 = 0 ;
27661 PyObject *swig_obj[1] ;
27662
27663 if (!args) SWIG_fail;
27664 swig_obj[0] = args;
27665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27666 if (!SWIG_IsOK(res1)) {
27667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27668 }
27669 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27670 {
27671 PyThreadState* __tstate = wxPyBeginAllowThreads();
27672 result = (arg1)->GetPosition();
27673 wxPyEndAllowThreads(__tstate);
27674 if (PyErr_Occurred()) SWIG_fail;
27675 }
27676 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
27677 return resultobj;
27678 fail:
27679 return NULL;
27680 }
27681
27682
27683 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27684 PyObject *resultobj = 0;
27685 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27686 int result;
27687 void *argp1 = 0 ;
27688 int res1 = 0 ;
27689 PyObject *swig_obj[1] ;
27690
27691 if (!args) SWIG_fail;
27692 swig_obj[0] = args;
27693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27694 if (!SWIG_IsOK(res1)) {
27695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27696 }
27697 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27698 {
27699 PyThreadState* __tstate = wxPyBeginAllowThreads();
27700 result = (int)(arg1)->GetNumberOfFiles();
27701 wxPyEndAllowThreads(__tstate);
27702 if (PyErr_Occurred()) SWIG_fail;
27703 }
27704 resultobj = SWIG_From_int(static_cast< int >(result));
27705 return resultobj;
27706 fail:
27707 return NULL;
27708 }
27709
27710
27711 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27712 PyObject *resultobj = 0;
27713 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27714 PyObject *result = 0 ;
27715 void *argp1 = 0 ;
27716 int res1 = 0 ;
27717 PyObject *swig_obj[1] ;
27718
27719 if (!args) SWIG_fail;
27720 swig_obj[0] = args;
27721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27722 if (!SWIG_IsOK(res1)) {
27723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27724 }
27725 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27726 {
27727 PyThreadState* __tstate = wxPyBeginAllowThreads();
27728 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
27729 wxPyEndAllowThreads(__tstate);
27730 if (PyErr_Occurred()) SWIG_fail;
27731 }
27732 resultobj = result;
27733 return resultobj;
27734 fail:
27735 return NULL;
27736 }
27737
27738
27739 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27740 PyObject *obj;
27741 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27742 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
27743 return SWIG_Py_Void();
27744 }
27745
27746 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27747 PyObject *resultobj = 0;
27748 int arg1 = (int) 0 ;
27749 wxUpdateUIEvent *result = 0 ;
27750 int val1 ;
27751 int ecode1 = 0 ;
27752 PyObject * obj0 = 0 ;
27753 char * kwnames[] = {
27754 (char *) "commandId", NULL
27755 };
27756
27757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
27758 if (obj0) {
27759 ecode1 = SWIG_AsVal_int(obj0, &val1);
27760 if (!SWIG_IsOK(ecode1)) {
27761 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
27762 }
27763 arg1 = static_cast< int >(val1);
27764 }
27765 {
27766 PyThreadState* __tstate = wxPyBeginAllowThreads();
27767 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
27768 wxPyEndAllowThreads(__tstate);
27769 if (PyErr_Occurred()) SWIG_fail;
27770 }
27771 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
27772 return resultobj;
27773 fail:
27774 return NULL;
27775 }
27776
27777
27778 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27779 PyObject *resultobj = 0;
27780 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27781 bool result;
27782 void *argp1 = 0 ;
27783 int res1 = 0 ;
27784 PyObject *swig_obj[1] ;
27785
27786 if (!args) SWIG_fail;
27787 swig_obj[0] = args;
27788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27789 if (!SWIG_IsOK(res1)) {
27790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27791 }
27792 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27793 {
27794 PyThreadState* __tstate = wxPyBeginAllowThreads();
27795 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
27796 wxPyEndAllowThreads(__tstate);
27797 if (PyErr_Occurred()) SWIG_fail;
27798 }
27799 {
27800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27801 }
27802 return resultobj;
27803 fail:
27804 return NULL;
27805 }
27806
27807
27808 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27809 PyObject *resultobj = 0;
27810 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27811 bool result;
27812 void *argp1 = 0 ;
27813 int res1 = 0 ;
27814 PyObject *swig_obj[1] ;
27815
27816 if (!args) SWIG_fail;
27817 swig_obj[0] = args;
27818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27819 if (!SWIG_IsOK(res1)) {
27820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27821 }
27822 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27823 {
27824 PyThreadState* __tstate = wxPyBeginAllowThreads();
27825 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
27826 wxPyEndAllowThreads(__tstate);
27827 if (PyErr_Occurred()) SWIG_fail;
27828 }
27829 {
27830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27831 }
27832 return resultobj;
27833 fail:
27834 return NULL;
27835 }
27836
27837
27838 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27839 PyObject *resultobj = 0;
27840 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27841 bool result;
27842 void *argp1 = 0 ;
27843 int res1 = 0 ;
27844 PyObject *swig_obj[1] ;
27845
27846 if (!args) SWIG_fail;
27847 swig_obj[0] = args;
27848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27849 if (!SWIG_IsOK(res1)) {
27850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27851 }
27852 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27853 {
27854 PyThreadState* __tstate = wxPyBeginAllowThreads();
27855 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
27856 wxPyEndAllowThreads(__tstate);
27857 if (PyErr_Occurred()) SWIG_fail;
27858 }
27859 {
27860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27861 }
27862 return resultobj;
27863 fail:
27864 return NULL;
27865 }
27866
27867
27868 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27869 PyObject *resultobj = 0;
27870 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27871 wxString result;
27872 void *argp1 = 0 ;
27873 int res1 = 0 ;
27874 PyObject *swig_obj[1] ;
27875
27876 if (!args) SWIG_fail;
27877 swig_obj[0] = args;
27878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27879 if (!SWIG_IsOK(res1)) {
27880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27881 }
27882 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27883 {
27884 PyThreadState* __tstate = wxPyBeginAllowThreads();
27885 result = ((wxUpdateUIEvent const *)arg1)->GetText();
27886 wxPyEndAllowThreads(__tstate);
27887 if (PyErr_Occurred()) SWIG_fail;
27888 }
27889 {
27890 #if wxUSE_UNICODE
27891 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27892 #else
27893 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27894 #endif
27895 }
27896 return resultobj;
27897 fail:
27898 return NULL;
27899 }
27900
27901
27902 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27903 PyObject *resultobj = 0;
27904 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27905 bool result;
27906 void *argp1 = 0 ;
27907 int res1 = 0 ;
27908 PyObject *swig_obj[1] ;
27909
27910 if (!args) SWIG_fail;
27911 swig_obj[0] = args;
27912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27913 if (!SWIG_IsOK(res1)) {
27914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27915 }
27916 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27917 {
27918 PyThreadState* __tstate = wxPyBeginAllowThreads();
27919 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
27920 wxPyEndAllowThreads(__tstate);
27921 if (PyErr_Occurred()) SWIG_fail;
27922 }
27923 {
27924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27925 }
27926 return resultobj;
27927 fail:
27928 return NULL;
27929 }
27930
27931
27932 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27933 PyObject *resultobj = 0;
27934 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27935 bool result;
27936 void *argp1 = 0 ;
27937 int res1 = 0 ;
27938 PyObject *swig_obj[1] ;
27939
27940 if (!args) SWIG_fail;
27941 swig_obj[0] = args;
27942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27943 if (!SWIG_IsOK(res1)) {
27944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27945 }
27946 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27947 {
27948 PyThreadState* __tstate = wxPyBeginAllowThreads();
27949 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
27950 wxPyEndAllowThreads(__tstate);
27951 if (PyErr_Occurred()) SWIG_fail;
27952 }
27953 {
27954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27955 }
27956 return resultobj;
27957 fail:
27958 return NULL;
27959 }
27960
27961
27962 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27963 PyObject *resultobj = 0;
27964 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27965 bool result;
27966 void *argp1 = 0 ;
27967 int res1 = 0 ;
27968 PyObject *swig_obj[1] ;
27969
27970 if (!args) SWIG_fail;
27971 swig_obj[0] = args;
27972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27973 if (!SWIG_IsOK(res1)) {
27974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27975 }
27976 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27977 {
27978 PyThreadState* __tstate = wxPyBeginAllowThreads();
27979 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
27980 wxPyEndAllowThreads(__tstate);
27981 if (PyErr_Occurred()) SWIG_fail;
27982 }
27983 {
27984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27985 }
27986 return resultobj;
27987 fail:
27988 return NULL;
27989 }
27990
27991
27992 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27993 PyObject *resultobj = 0;
27994 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27995 bool result;
27996 void *argp1 = 0 ;
27997 int res1 = 0 ;
27998 PyObject *swig_obj[1] ;
27999
28000 if (!args) SWIG_fail;
28001 swig_obj[0] = args;
28002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28003 if (!SWIG_IsOK(res1)) {
28004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28005 }
28006 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28007 {
28008 PyThreadState* __tstate = wxPyBeginAllowThreads();
28009 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
28010 wxPyEndAllowThreads(__tstate);
28011 if (PyErr_Occurred()) SWIG_fail;
28012 }
28013 {
28014 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28015 }
28016 return resultobj;
28017 fail:
28018 return NULL;
28019 }
28020
28021
28022 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28023 PyObject *resultobj = 0;
28024 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28025 bool arg2 ;
28026 void *argp1 = 0 ;
28027 int res1 = 0 ;
28028 bool val2 ;
28029 int ecode2 = 0 ;
28030 PyObject * obj0 = 0 ;
28031 PyObject * obj1 = 0 ;
28032 char * kwnames[] = {
28033 (char *) "self",(char *) "check", NULL
28034 };
28035
28036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
28037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28038 if (!SWIG_IsOK(res1)) {
28039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28040 }
28041 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28042 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28043 if (!SWIG_IsOK(ecode2)) {
28044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
28045 }
28046 arg2 = static_cast< bool >(val2);
28047 {
28048 PyThreadState* __tstate = wxPyBeginAllowThreads();
28049 (arg1)->Check(arg2);
28050 wxPyEndAllowThreads(__tstate);
28051 if (PyErr_Occurred()) SWIG_fail;
28052 }
28053 resultobj = SWIG_Py_Void();
28054 return resultobj;
28055 fail:
28056 return NULL;
28057 }
28058
28059
28060 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28061 PyObject *resultobj = 0;
28062 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28063 bool arg2 ;
28064 void *argp1 = 0 ;
28065 int res1 = 0 ;
28066 bool val2 ;
28067 int ecode2 = 0 ;
28068 PyObject * obj0 = 0 ;
28069 PyObject * obj1 = 0 ;
28070 char * kwnames[] = {
28071 (char *) "self",(char *) "enable", NULL
28072 };
28073
28074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
28075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28076 if (!SWIG_IsOK(res1)) {
28077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28078 }
28079 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28080 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28081 if (!SWIG_IsOK(ecode2)) {
28082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
28083 }
28084 arg2 = static_cast< bool >(val2);
28085 {
28086 PyThreadState* __tstate = wxPyBeginAllowThreads();
28087 (arg1)->Enable(arg2);
28088 wxPyEndAllowThreads(__tstate);
28089 if (PyErr_Occurred()) SWIG_fail;
28090 }
28091 resultobj = SWIG_Py_Void();
28092 return resultobj;
28093 fail:
28094 return NULL;
28095 }
28096
28097
28098 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28099 PyObject *resultobj = 0;
28100 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28101 bool arg2 ;
28102 void *argp1 = 0 ;
28103 int res1 = 0 ;
28104 bool val2 ;
28105 int ecode2 = 0 ;
28106 PyObject * obj0 = 0 ;
28107 PyObject * obj1 = 0 ;
28108 char * kwnames[] = {
28109 (char *) "self",(char *) "show", NULL
28110 };
28111
28112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
28113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28114 if (!SWIG_IsOK(res1)) {
28115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28116 }
28117 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28118 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28119 if (!SWIG_IsOK(ecode2)) {
28120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
28121 }
28122 arg2 = static_cast< bool >(val2);
28123 {
28124 PyThreadState* __tstate = wxPyBeginAllowThreads();
28125 (arg1)->Show(arg2);
28126 wxPyEndAllowThreads(__tstate);
28127 if (PyErr_Occurred()) SWIG_fail;
28128 }
28129 resultobj = SWIG_Py_Void();
28130 return resultobj;
28131 fail:
28132 return NULL;
28133 }
28134
28135
28136 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28137 PyObject *resultobj = 0;
28138 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28139 wxString *arg2 = 0 ;
28140 void *argp1 = 0 ;
28141 int res1 = 0 ;
28142 bool temp2 = false ;
28143 PyObject * obj0 = 0 ;
28144 PyObject * obj1 = 0 ;
28145 char * kwnames[] = {
28146 (char *) "self",(char *) "text", NULL
28147 };
28148
28149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
28150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28151 if (!SWIG_IsOK(res1)) {
28152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28153 }
28154 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28155 {
28156 arg2 = wxString_in_helper(obj1);
28157 if (arg2 == NULL) SWIG_fail;
28158 temp2 = true;
28159 }
28160 {
28161 PyThreadState* __tstate = wxPyBeginAllowThreads();
28162 (arg1)->SetText((wxString const &)*arg2);
28163 wxPyEndAllowThreads(__tstate);
28164 if (PyErr_Occurred()) SWIG_fail;
28165 }
28166 resultobj = SWIG_Py_Void();
28167 {
28168 if (temp2)
28169 delete arg2;
28170 }
28171 return resultobj;
28172 fail:
28173 {
28174 if (temp2)
28175 delete arg2;
28176 }
28177 return NULL;
28178 }
28179
28180
28181 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28182 PyObject *resultobj = 0;
28183 long arg1 ;
28184 long val1 ;
28185 int ecode1 = 0 ;
28186 PyObject * obj0 = 0 ;
28187 char * kwnames[] = {
28188 (char *) "updateInterval", NULL
28189 };
28190
28191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
28192 ecode1 = SWIG_AsVal_long(obj0, &val1);
28193 if (!SWIG_IsOK(ecode1)) {
28194 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
28195 }
28196 arg1 = static_cast< long >(val1);
28197 {
28198 PyThreadState* __tstate = wxPyBeginAllowThreads();
28199 wxUpdateUIEvent::SetUpdateInterval(arg1);
28200 wxPyEndAllowThreads(__tstate);
28201 if (PyErr_Occurred()) SWIG_fail;
28202 }
28203 resultobj = SWIG_Py_Void();
28204 return resultobj;
28205 fail:
28206 return NULL;
28207 }
28208
28209
28210 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28211 PyObject *resultobj = 0;
28212 long result;
28213
28214 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
28215 {
28216 PyThreadState* __tstate = wxPyBeginAllowThreads();
28217 result = (long)wxUpdateUIEvent::GetUpdateInterval();
28218 wxPyEndAllowThreads(__tstate);
28219 if (PyErr_Occurred()) SWIG_fail;
28220 }
28221 resultobj = SWIG_From_long(static_cast< long >(result));
28222 return resultobj;
28223 fail:
28224 return NULL;
28225 }
28226
28227
28228 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28229 PyObject *resultobj = 0;
28230 wxWindow *arg1 = (wxWindow *) 0 ;
28231 bool result;
28232 void *argp1 = 0 ;
28233 int res1 = 0 ;
28234 PyObject * obj0 = 0 ;
28235 char * kwnames[] = {
28236 (char *) "win", NULL
28237 };
28238
28239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
28240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28241 if (!SWIG_IsOK(res1)) {
28242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
28243 }
28244 arg1 = reinterpret_cast< wxWindow * >(argp1);
28245 {
28246 PyThreadState* __tstate = wxPyBeginAllowThreads();
28247 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
28248 wxPyEndAllowThreads(__tstate);
28249 if (PyErr_Occurred()) SWIG_fail;
28250 }
28251 {
28252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28253 }
28254 return resultobj;
28255 fail:
28256 return NULL;
28257 }
28258
28259
28260 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28261 PyObject *resultobj = 0;
28262
28263 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
28264 {
28265 PyThreadState* __tstate = wxPyBeginAllowThreads();
28266 wxUpdateUIEvent::ResetUpdateTime();
28267 wxPyEndAllowThreads(__tstate);
28268 if (PyErr_Occurred()) SWIG_fail;
28269 }
28270 resultobj = SWIG_Py_Void();
28271 return resultobj;
28272 fail:
28273 return NULL;
28274 }
28275
28276
28277 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28278 PyObject *resultobj = 0;
28279 wxUpdateUIMode arg1 ;
28280 int val1 ;
28281 int ecode1 = 0 ;
28282 PyObject * obj0 = 0 ;
28283 char * kwnames[] = {
28284 (char *) "mode", NULL
28285 };
28286
28287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
28288 ecode1 = SWIG_AsVal_int(obj0, &val1);
28289 if (!SWIG_IsOK(ecode1)) {
28290 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
28291 }
28292 arg1 = static_cast< wxUpdateUIMode >(val1);
28293 {
28294 PyThreadState* __tstate = wxPyBeginAllowThreads();
28295 wxUpdateUIEvent::SetMode(arg1);
28296 wxPyEndAllowThreads(__tstate);
28297 if (PyErr_Occurred()) SWIG_fail;
28298 }
28299 resultobj = SWIG_Py_Void();
28300 return resultobj;
28301 fail:
28302 return NULL;
28303 }
28304
28305
28306 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28307 PyObject *resultobj = 0;
28308 wxUpdateUIMode result;
28309
28310 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
28311 {
28312 PyThreadState* __tstate = wxPyBeginAllowThreads();
28313 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
28314 wxPyEndAllowThreads(__tstate);
28315 if (PyErr_Occurred()) SWIG_fail;
28316 }
28317 resultobj = SWIG_From_int(static_cast< int >(result));
28318 return resultobj;
28319 fail:
28320 return NULL;
28321 }
28322
28323
28324 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28325 PyObject *obj;
28326 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28327 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
28328 return SWIG_Py_Void();
28329 }
28330
28331 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28332 return SWIG_Python_InitShadowInstance(args);
28333 }
28334
28335 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28336 PyObject *resultobj = 0;
28337 wxSysColourChangedEvent *result = 0 ;
28338
28339 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
28340 {
28341 PyThreadState* __tstate = wxPyBeginAllowThreads();
28342 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
28343 wxPyEndAllowThreads(__tstate);
28344 if (PyErr_Occurred()) SWIG_fail;
28345 }
28346 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
28347 return resultobj;
28348 fail:
28349 return NULL;
28350 }
28351
28352
28353 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28354 PyObject *obj;
28355 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28356 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
28357 return SWIG_Py_Void();
28358 }
28359
28360 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28361 return SWIG_Python_InitShadowInstance(args);
28362 }
28363
28364 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28365 PyObject *resultobj = 0;
28366 int arg1 = (int) 0 ;
28367 wxWindow *arg2 = (wxWindow *) NULL ;
28368 wxMouseCaptureChangedEvent *result = 0 ;
28369 int val1 ;
28370 int ecode1 = 0 ;
28371 void *argp2 = 0 ;
28372 int res2 = 0 ;
28373 PyObject * obj0 = 0 ;
28374 PyObject * obj1 = 0 ;
28375 char * kwnames[] = {
28376 (char *) "winid",(char *) "gainedCapture", NULL
28377 };
28378
28379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28380 if (obj0) {
28381 ecode1 = SWIG_AsVal_int(obj0, &val1);
28382 if (!SWIG_IsOK(ecode1)) {
28383 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
28384 }
28385 arg1 = static_cast< int >(val1);
28386 }
28387 if (obj1) {
28388 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28389 if (!SWIG_IsOK(res2)) {
28390 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
28391 }
28392 arg2 = reinterpret_cast< wxWindow * >(argp2);
28393 }
28394 {
28395 PyThreadState* __tstate = wxPyBeginAllowThreads();
28396 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
28397 wxPyEndAllowThreads(__tstate);
28398 if (PyErr_Occurred()) SWIG_fail;
28399 }
28400 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
28401 return resultobj;
28402 fail:
28403 return NULL;
28404 }
28405
28406
28407 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28408 PyObject *resultobj = 0;
28409 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
28410 wxWindow *result = 0 ;
28411 void *argp1 = 0 ;
28412 int res1 = 0 ;
28413 PyObject *swig_obj[1] ;
28414
28415 if (!args) SWIG_fail;
28416 swig_obj[0] = args;
28417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
28418 if (!SWIG_IsOK(res1)) {
28419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
28420 }
28421 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
28422 {
28423 PyThreadState* __tstate = wxPyBeginAllowThreads();
28424 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
28425 wxPyEndAllowThreads(__tstate);
28426 if (PyErr_Occurred()) SWIG_fail;
28427 }
28428 {
28429 resultobj = wxPyMake_wxObject(result, (bool)0);
28430 }
28431 return resultobj;
28432 fail:
28433 return NULL;
28434 }
28435
28436
28437 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28438 PyObject *obj;
28439 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28440 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
28441 return SWIG_Py_Void();
28442 }
28443
28444 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28445 return SWIG_Python_InitShadowInstance(args);
28446 }
28447
28448 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28449 PyObject *resultobj = 0;
28450 int arg1 = (int) 0 ;
28451 wxMouseCaptureLostEvent *result = 0 ;
28452 int val1 ;
28453 int ecode1 = 0 ;
28454 PyObject * obj0 = 0 ;
28455 char * kwnames[] = {
28456 (char *) "winid", NULL
28457 };
28458
28459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
28460 if (obj0) {
28461 ecode1 = SWIG_AsVal_int(obj0, &val1);
28462 if (!SWIG_IsOK(ecode1)) {
28463 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
28464 }
28465 arg1 = static_cast< int >(val1);
28466 }
28467 {
28468 PyThreadState* __tstate = wxPyBeginAllowThreads();
28469 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
28470 wxPyEndAllowThreads(__tstate);
28471 if (PyErr_Occurred()) SWIG_fail;
28472 }
28473 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
28474 return resultobj;
28475 fail:
28476 return NULL;
28477 }
28478
28479
28480 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28481 PyObject *obj;
28482 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28483 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
28484 return SWIG_Py_Void();
28485 }
28486
28487 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28488 return SWIG_Python_InitShadowInstance(args);
28489 }
28490
28491 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28492 PyObject *resultobj = 0;
28493 wxDisplayChangedEvent *result = 0 ;
28494
28495 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
28496 {
28497 PyThreadState* __tstate = wxPyBeginAllowThreads();
28498 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
28499 wxPyEndAllowThreads(__tstate);
28500 if (PyErr_Occurred()) SWIG_fail;
28501 }
28502 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
28503 return resultobj;
28504 fail:
28505 return NULL;
28506 }
28507
28508
28509 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28510 PyObject *obj;
28511 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28512 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
28513 return SWIG_Py_Void();
28514 }
28515
28516 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28517 return SWIG_Python_InitShadowInstance(args);
28518 }
28519
28520 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28521 PyObject *resultobj = 0;
28522 int arg1 = (int) 0 ;
28523 wxPaletteChangedEvent *result = 0 ;
28524 int val1 ;
28525 int ecode1 = 0 ;
28526 PyObject * obj0 = 0 ;
28527 char * kwnames[] = {
28528 (char *) "id", NULL
28529 };
28530
28531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
28532 if (obj0) {
28533 ecode1 = SWIG_AsVal_int(obj0, &val1);
28534 if (!SWIG_IsOK(ecode1)) {
28535 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
28536 }
28537 arg1 = static_cast< int >(val1);
28538 }
28539 {
28540 PyThreadState* __tstate = wxPyBeginAllowThreads();
28541 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
28542 wxPyEndAllowThreads(__tstate);
28543 if (PyErr_Occurred()) SWIG_fail;
28544 }
28545 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
28546 return resultobj;
28547 fail:
28548 return NULL;
28549 }
28550
28551
28552 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28553 PyObject *resultobj = 0;
28554 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28555 wxWindow *arg2 = (wxWindow *) 0 ;
28556 void *argp1 = 0 ;
28557 int res1 = 0 ;
28558 void *argp2 = 0 ;
28559 int res2 = 0 ;
28560 PyObject * obj0 = 0 ;
28561 PyObject * obj1 = 0 ;
28562 char * kwnames[] = {
28563 (char *) "self",(char *) "win", NULL
28564 };
28565
28566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28568 if (!SWIG_IsOK(res1)) {
28569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28570 }
28571 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28572 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28573 if (!SWIG_IsOK(res2)) {
28574 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28575 }
28576 arg2 = reinterpret_cast< wxWindow * >(argp2);
28577 {
28578 PyThreadState* __tstate = wxPyBeginAllowThreads();
28579 (arg1)->SetChangedWindow(arg2);
28580 wxPyEndAllowThreads(__tstate);
28581 if (PyErr_Occurred()) SWIG_fail;
28582 }
28583 resultobj = SWIG_Py_Void();
28584 return resultobj;
28585 fail:
28586 return NULL;
28587 }
28588
28589
28590 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28591 PyObject *resultobj = 0;
28592 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28593 wxWindow *result = 0 ;
28594 void *argp1 = 0 ;
28595 int res1 = 0 ;
28596 PyObject *swig_obj[1] ;
28597
28598 if (!args) SWIG_fail;
28599 swig_obj[0] = args;
28600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28601 if (!SWIG_IsOK(res1)) {
28602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28603 }
28604 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28605 {
28606 PyThreadState* __tstate = wxPyBeginAllowThreads();
28607 result = (wxWindow *)(arg1)->GetChangedWindow();
28608 wxPyEndAllowThreads(__tstate);
28609 if (PyErr_Occurred()) SWIG_fail;
28610 }
28611 {
28612 resultobj = wxPyMake_wxObject(result, (bool)0);
28613 }
28614 return resultobj;
28615 fail:
28616 return NULL;
28617 }
28618
28619
28620 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28621 PyObject *obj;
28622 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28623 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
28624 return SWIG_Py_Void();
28625 }
28626
28627 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28628 return SWIG_Python_InitShadowInstance(args);
28629 }
28630
28631 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28632 PyObject *resultobj = 0;
28633 int arg1 = (int) 0 ;
28634 wxQueryNewPaletteEvent *result = 0 ;
28635 int val1 ;
28636 int ecode1 = 0 ;
28637 PyObject * obj0 = 0 ;
28638 char * kwnames[] = {
28639 (char *) "winid", NULL
28640 };
28641
28642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
28643 if (obj0) {
28644 ecode1 = SWIG_AsVal_int(obj0, &val1);
28645 if (!SWIG_IsOK(ecode1)) {
28646 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
28647 }
28648 arg1 = static_cast< int >(val1);
28649 }
28650 {
28651 PyThreadState* __tstate = wxPyBeginAllowThreads();
28652 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
28653 wxPyEndAllowThreads(__tstate);
28654 if (PyErr_Occurred()) SWIG_fail;
28655 }
28656 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
28657 return resultobj;
28658 fail:
28659 return NULL;
28660 }
28661
28662
28663 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28664 PyObject *resultobj = 0;
28665 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28666 bool arg2 ;
28667 void *argp1 = 0 ;
28668 int res1 = 0 ;
28669 bool val2 ;
28670 int ecode2 = 0 ;
28671 PyObject * obj0 = 0 ;
28672 PyObject * obj1 = 0 ;
28673 char * kwnames[] = {
28674 (char *) "self",(char *) "realized", NULL
28675 };
28676
28677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
28678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28679 if (!SWIG_IsOK(res1)) {
28680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
28681 }
28682 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28683 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28684 if (!SWIG_IsOK(ecode2)) {
28685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
28686 }
28687 arg2 = static_cast< bool >(val2);
28688 {
28689 PyThreadState* __tstate = wxPyBeginAllowThreads();
28690 (arg1)->SetPaletteRealized(arg2);
28691 wxPyEndAllowThreads(__tstate);
28692 if (PyErr_Occurred()) SWIG_fail;
28693 }
28694 resultobj = SWIG_Py_Void();
28695 return resultobj;
28696 fail:
28697 return NULL;
28698 }
28699
28700
28701 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28702 PyObject *resultobj = 0;
28703 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28704 bool result;
28705 void *argp1 = 0 ;
28706 int res1 = 0 ;
28707 PyObject *swig_obj[1] ;
28708
28709 if (!args) SWIG_fail;
28710 swig_obj[0] = args;
28711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28712 if (!SWIG_IsOK(res1)) {
28713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
28714 }
28715 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28716 {
28717 PyThreadState* __tstate = wxPyBeginAllowThreads();
28718 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
28719 wxPyEndAllowThreads(__tstate);
28720 if (PyErr_Occurred()) SWIG_fail;
28721 }
28722 {
28723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28724 }
28725 return resultobj;
28726 fail:
28727 return NULL;
28728 }
28729
28730
28731 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28732 PyObject *obj;
28733 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28734 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
28735 return SWIG_Py_Void();
28736 }
28737
28738 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28739 return SWIG_Python_InitShadowInstance(args);
28740 }
28741
28742 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28743 PyObject *resultobj = 0;
28744 wxNavigationKeyEvent *result = 0 ;
28745
28746 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
28747 {
28748 PyThreadState* __tstate = wxPyBeginAllowThreads();
28749 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
28750 wxPyEndAllowThreads(__tstate);
28751 if (PyErr_Occurred()) SWIG_fail;
28752 }
28753 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
28754 return resultobj;
28755 fail:
28756 return NULL;
28757 }
28758
28759
28760 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28761 PyObject *resultobj = 0;
28762 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28763 bool result;
28764 void *argp1 = 0 ;
28765 int res1 = 0 ;
28766 PyObject *swig_obj[1] ;
28767
28768 if (!args) SWIG_fail;
28769 swig_obj[0] = args;
28770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28771 if (!SWIG_IsOK(res1)) {
28772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28773 }
28774 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28775 {
28776 PyThreadState* __tstate = wxPyBeginAllowThreads();
28777 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
28778 wxPyEndAllowThreads(__tstate);
28779 if (PyErr_Occurred()) SWIG_fail;
28780 }
28781 {
28782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28783 }
28784 return resultobj;
28785 fail:
28786 return NULL;
28787 }
28788
28789
28790 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28791 PyObject *resultobj = 0;
28792 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28793 bool arg2 ;
28794 void *argp1 = 0 ;
28795 int res1 = 0 ;
28796 bool val2 ;
28797 int ecode2 = 0 ;
28798 PyObject * obj0 = 0 ;
28799 PyObject * obj1 = 0 ;
28800 char * kwnames[] = {
28801 (char *) "self",(char *) "forward", NULL
28802 };
28803
28804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
28805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28806 if (!SWIG_IsOK(res1)) {
28807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28808 }
28809 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28810 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28811 if (!SWIG_IsOK(ecode2)) {
28812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
28813 }
28814 arg2 = static_cast< bool >(val2);
28815 {
28816 PyThreadState* __tstate = wxPyBeginAllowThreads();
28817 (arg1)->SetDirection(arg2);
28818 wxPyEndAllowThreads(__tstate);
28819 if (PyErr_Occurred()) SWIG_fail;
28820 }
28821 resultobj = SWIG_Py_Void();
28822 return resultobj;
28823 fail:
28824 return NULL;
28825 }
28826
28827
28828 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28829 PyObject *resultobj = 0;
28830 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28831 bool result;
28832 void *argp1 = 0 ;
28833 int res1 = 0 ;
28834 PyObject *swig_obj[1] ;
28835
28836 if (!args) SWIG_fail;
28837 swig_obj[0] = args;
28838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28839 if (!SWIG_IsOK(res1)) {
28840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28841 }
28842 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28843 {
28844 PyThreadState* __tstate = wxPyBeginAllowThreads();
28845 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
28846 wxPyEndAllowThreads(__tstate);
28847 if (PyErr_Occurred()) SWIG_fail;
28848 }
28849 {
28850 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28851 }
28852 return resultobj;
28853 fail:
28854 return NULL;
28855 }
28856
28857
28858 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28859 PyObject *resultobj = 0;
28860 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28861 bool arg2 ;
28862 void *argp1 = 0 ;
28863 int res1 = 0 ;
28864 bool val2 ;
28865 int ecode2 = 0 ;
28866 PyObject * obj0 = 0 ;
28867 PyObject * obj1 = 0 ;
28868 char * kwnames[] = {
28869 (char *) "self",(char *) "ischange", NULL
28870 };
28871
28872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
28873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28874 if (!SWIG_IsOK(res1)) {
28875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28876 }
28877 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28878 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28879 if (!SWIG_IsOK(ecode2)) {
28880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
28881 }
28882 arg2 = static_cast< bool >(val2);
28883 {
28884 PyThreadState* __tstate = wxPyBeginAllowThreads();
28885 (arg1)->SetWindowChange(arg2);
28886 wxPyEndAllowThreads(__tstate);
28887 if (PyErr_Occurred()) SWIG_fail;
28888 }
28889 resultobj = SWIG_Py_Void();
28890 return resultobj;
28891 fail:
28892 return NULL;
28893 }
28894
28895
28896 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28897 PyObject *resultobj = 0;
28898 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28899 bool result;
28900 void *argp1 = 0 ;
28901 int res1 = 0 ;
28902 PyObject *swig_obj[1] ;
28903
28904 if (!args) SWIG_fail;
28905 swig_obj[0] = args;
28906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28907 if (!SWIG_IsOK(res1)) {
28908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28909 }
28910 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28911 {
28912 PyThreadState* __tstate = wxPyBeginAllowThreads();
28913 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
28914 wxPyEndAllowThreads(__tstate);
28915 if (PyErr_Occurred()) SWIG_fail;
28916 }
28917 {
28918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28919 }
28920 return resultobj;
28921 fail:
28922 return NULL;
28923 }
28924
28925
28926 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28927 PyObject *resultobj = 0;
28928 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28929 bool arg2 ;
28930 void *argp1 = 0 ;
28931 int res1 = 0 ;
28932 bool val2 ;
28933 int ecode2 = 0 ;
28934 PyObject * obj0 = 0 ;
28935 PyObject * obj1 = 0 ;
28936 char * kwnames[] = {
28937 (char *) "self",(char *) "bIs", NULL
28938 };
28939
28940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
28941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28942 if (!SWIG_IsOK(res1)) {
28943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28944 }
28945 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28946 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28947 if (!SWIG_IsOK(ecode2)) {
28948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
28949 }
28950 arg2 = static_cast< bool >(val2);
28951 {
28952 PyThreadState* __tstate = wxPyBeginAllowThreads();
28953 (arg1)->SetFromTab(arg2);
28954 wxPyEndAllowThreads(__tstate);
28955 if (PyErr_Occurred()) SWIG_fail;
28956 }
28957 resultobj = SWIG_Py_Void();
28958 return resultobj;
28959 fail:
28960 return NULL;
28961 }
28962
28963
28964 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28965 PyObject *resultobj = 0;
28966 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28967 long arg2 ;
28968 void *argp1 = 0 ;
28969 int res1 = 0 ;
28970 long val2 ;
28971 int ecode2 = 0 ;
28972 PyObject * obj0 = 0 ;
28973 PyObject * obj1 = 0 ;
28974 char * kwnames[] = {
28975 (char *) "self",(char *) "flags", NULL
28976 };
28977
28978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
28979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28980 if (!SWIG_IsOK(res1)) {
28981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28982 }
28983 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28984 ecode2 = SWIG_AsVal_long(obj1, &val2);
28985 if (!SWIG_IsOK(ecode2)) {
28986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
28987 }
28988 arg2 = static_cast< long >(val2);
28989 {
28990 PyThreadState* __tstate = wxPyBeginAllowThreads();
28991 (arg1)->SetFlags(arg2);
28992 wxPyEndAllowThreads(__tstate);
28993 if (PyErr_Occurred()) SWIG_fail;
28994 }
28995 resultobj = SWIG_Py_Void();
28996 return resultobj;
28997 fail:
28998 return NULL;
28999 }
29000
29001
29002 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29003 PyObject *resultobj = 0;
29004 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29005 wxWindow *result = 0 ;
29006 void *argp1 = 0 ;
29007 int res1 = 0 ;
29008 PyObject *swig_obj[1] ;
29009
29010 if (!args) SWIG_fail;
29011 swig_obj[0] = args;
29012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29013 if (!SWIG_IsOK(res1)) {
29014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
29015 }
29016 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29017 {
29018 PyThreadState* __tstate = wxPyBeginAllowThreads();
29019 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
29020 wxPyEndAllowThreads(__tstate);
29021 if (PyErr_Occurred()) SWIG_fail;
29022 }
29023 {
29024 resultobj = wxPyMake_wxObject(result, (bool)0);
29025 }
29026 return resultobj;
29027 fail:
29028 return NULL;
29029 }
29030
29031
29032 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29033 PyObject *resultobj = 0;
29034 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29035 wxWindow *arg2 = (wxWindow *) 0 ;
29036 void *argp1 = 0 ;
29037 int res1 = 0 ;
29038 void *argp2 = 0 ;
29039 int res2 = 0 ;
29040 PyObject * obj0 = 0 ;
29041 PyObject * obj1 = 0 ;
29042 char * kwnames[] = {
29043 (char *) "self",(char *) "win", NULL
29044 };
29045
29046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
29047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29048 if (!SWIG_IsOK(res1)) {
29049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
29050 }
29051 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29052 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29053 if (!SWIG_IsOK(res2)) {
29054 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
29055 }
29056 arg2 = reinterpret_cast< wxWindow * >(argp2);
29057 {
29058 PyThreadState* __tstate = wxPyBeginAllowThreads();
29059 (arg1)->SetCurrentFocus(arg2);
29060 wxPyEndAllowThreads(__tstate);
29061 if (PyErr_Occurred()) SWIG_fail;
29062 }
29063 resultobj = SWIG_Py_Void();
29064 return resultobj;
29065 fail:
29066 return NULL;
29067 }
29068
29069
29070 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29071 PyObject *obj;
29072 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29073 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
29074 return SWIG_Py_Void();
29075 }
29076
29077 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29078 return SWIG_Python_InitShadowInstance(args);
29079 }
29080
29081 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29082 PyObject *resultobj = 0;
29083 wxWindow *arg1 = (wxWindow *) NULL ;
29084 wxWindowCreateEvent *result = 0 ;
29085 void *argp1 = 0 ;
29086 int res1 = 0 ;
29087 PyObject * obj0 = 0 ;
29088 char * kwnames[] = {
29089 (char *) "win", NULL
29090 };
29091
29092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
29093 if (obj0) {
29094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29095 if (!SWIG_IsOK(res1)) {
29096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29097 }
29098 arg1 = reinterpret_cast< wxWindow * >(argp1);
29099 }
29100 {
29101 PyThreadState* __tstate = wxPyBeginAllowThreads();
29102 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
29103 wxPyEndAllowThreads(__tstate);
29104 if (PyErr_Occurred()) SWIG_fail;
29105 }
29106 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
29107 return resultobj;
29108 fail:
29109 return NULL;
29110 }
29111
29112
29113 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29114 PyObject *resultobj = 0;
29115 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
29116 wxWindow *result = 0 ;
29117 void *argp1 = 0 ;
29118 int res1 = 0 ;
29119 PyObject *swig_obj[1] ;
29120
29121 if (!args) SWIG_fail;
29122 swig_obj[0] = args;
29123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
29124 if (!SWIG_IsOK(res1)) {
29125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
29126 }
29127 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
29128 {
29129 PyThreadState* __tstate = wxPyBeginAllowThreads();
29130 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
29131 wxPyEndAllowThreads(__tstate);
29132 if (PyErr_Occurred()) SWIG_fail;
29133 }
29134 {
29135 resultobj = wxPyMake_wxObject(result, (bool)0);
29136 }
29137 return resultobj;
29138 fail:
29139 return NULL;
29140 }
29141
29142
29143 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29144 PyObject *obj;
29145 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29146 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
29147 return SWIG_Py_Void();
29148 }
29149
29150 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29151 return SWIG_Python_InitShadowInstance(args);
29152 }
29153
29154 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29155 PyObject *resultobj = 0;
29156 wxWindow *arg1 = (wxWindow *) NULL ;
29157 wxWindowDestroyEvent *result = 0 ;
29158 void *argp1 = 0 ;
29159 int res1 = 0 ;
29160 PyObject * obj0 = 0 ;
29161 char * kwnames[] = {
29162 (char *) "win", NULL
29163 };
29164
29165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
29166 if (obj0) {
29167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29168 if (!SWIG_IsOK(res1)) {
29169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29170 }
29171 arg1 = reinterpret_cast< wxWindow * >(argp1);
29172 }
29173 {
29174 PyThreadState* __tstate = wxPyBeginAllowThreads();
29175 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
29176 wxPyEndAllowThreads(__tstate);
29177 if (PyErr_Occurred()) SWIG_fail;
29178 }
29179 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
29180 return resultobj;
29181 fail:
29182 return NULL;
29183 }
29184
29185
29186 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29187 PyObject *resultobj = 0;
29188 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
29189 wxWindow *result = 0 ;
29190 void *argp1 = 0 ;
29191 int res1 = 0 ;
29192 PyObject *swig_obj[1] ;
29193
29194 if (!args) SWIG_fail;
29195 swig_obj[0] = args;
29196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
29197 if (!SWIG_IsOK(res1)) {
29198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
29199 }
29200 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
29201 {
29202 PyThreadState* __tstate = wxPyBeginAllowThreads();
29203 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
29204 wxPyEndAllowThreads(__tstate);
29205 if (PyErr_Occurred()) SWIG_fail;
29206 }
29207 {
29208 resultobj = wxPyMake_wxObject(result, (bool)0);
29209 }
29210 return resultobj;
29211 fail:
29212 return NULL;
29213 }
29214
29215
29216 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29217 PyObject *obj;
29218 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29219 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
29220 return SWIG_Py_Void();
29221 }
29222
29223 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29224 return SWIG_Python_InitShadowInstance(args);
29225 }
29226
29227 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29228 PyObject *resultobj = 0;
29229 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29230 int arg2 = (int) 0 ;
29231 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29232 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29233 wxContextMenuEvent *result = 0 ;
29234 int val1 ;
29235 int ecode1 = 0 ;
29236 int val2 ;
29237 int ecode2 = 0 ;
29238 wxPoint temp3 ;
29239 PyObject * obj0 = 0 ;
29240 PyObject * obj1 = 0 ;
29241 PyObject * obj2 = 0 ;
29242 char * kwnames[] = {
29243 (char *) "type",(char *) "winid",(char *) "pt", NULL
29244 };
29245
29246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29247 if (obj0) {
29248 ecode1 = SWIG_AsVal_int(obj0, &val1);
29249 if (!SWIG_IsOK(ecode1)) {
29250 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29251 }
29252 arg1 = static_cast< wxEventType >(val1);
29253 }
29254 if (obj1) {
29255 ecode2 = SWIG_AsVal_int(obj1, &val2);
29256 if (!SWIG_IsOK(ecode2)) {
29257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
29258 }
29259 arg2 = static_cast< int >(val2);
29260 }
29261 if (obj2) {
29262 {
29263 arg3 = &temp3;
29264 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29265 }
29266 }
29267 {
29268 PyThreadState* __tstate = wxPyBeginAllowThreads();
29269 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
29270 wxPyEndAllowThreads(__tstate);
29271 if (PyErr_Occurred()) SWIG_fail;
29272 }
29273 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
29274 return resultobj;
29275 fail:
29276 return NULL;
29277 }
29278
29279
29280 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29281 PyObject *resultobj = 0;
29282 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29283 wxPoint *result = 0 ;
29284 void *argp1 = 0 ;
29285 int res1 = 0 ;
29286 PyObject *swig_obj[1] ;
29287
29288 if (!args) SWIG_fail;
29289 swig_obj[0] = args;
29290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29291 if (!SWIG_IsOK(res1)) {
29292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
29293 }
29294 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29295 {
29296 PyThreadState* __tstate = wxPyBeginAllowThreads();
29297 {
29298 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
29299 result = (wxPoint *) &_result_ref;
29300 }
29301 wxPyEndAllowThreads(__tstate);
29302 if (PyErr_Occurred()) SWIG_fail;
29303 }
29304 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
29305 return resultobj;
29306 fail:
29307 return NULL;
29308 }
29309
29310
29311 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29312 PyObject *resultobj = 0;
29313 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29314 wxPoint *arg2 = 0 ;
29315 void *argp1 = 0 ;
29316 int res1 = 0 ;
29317 wxPoint temp2 ;
29318 PyObject * obj0 = 0 ;
29319 PyObject * obj1 = 0 ;
29320 char * kwnames[] = {
29321 (char *) "self",(char *) "pos", NULL
29322 };
29323
29324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
29325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29326 if (!SWIG_IsOK(res1)) {
29327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
29328 }
29329 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29330 {
29331 arg2 = &temp2;
29332 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29333 }
29334 {
29335 PyThreadState* __tstate = wxPyBeginAllowThreads();
29336 (arg1)->SetPosition((wxPoint const &)*arg2);
29337 wxPyEndAllowThreads(__tstate);
29338 if (PyErr_Occurred()) SWIG_fail;
29339 }
29340 resultobj = SWIG_Py_Void();
29341 return resultobj;
29342 fail:
29343 return NULL;
29344 }
29345
29346
29347 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29348 PyObject *obj;
29349 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29350 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
29351 return SWIG_Py_Void();
29352 }
29353
29354 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29355 return SWIG_Python_InitShadowInstance(args);
29356 }
29357
29358 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29359 PyObject *resultobj = 0;
29360 wxIdleEvent *result = 0 ;
29361
29362 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
29363 {
29364 PyThreadState* __tstate = wxPyBeginAllowThreads();
29365 result = (wxIdleEvent *)new wxIdleEvent();
29366 wxPyEndAllowThreads(__tstate);
29367 if (PyErr_Occurred()) SWIG_fail;
29368 }
29369 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
29370 return resultobj;
29371 fail:
29372 return NULL;
29373 }
29374
29375
29376 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29377 PyObject *resultobj = 0;
29378 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29379 bool arg2 = (bool) true ;
29380 void *argp1 = 0 ;
29381 int res1 = 0 ;
29382 bool val2 ;
29383 int ecode2 = 0 ;
29384 PyObject * obj0 = 0 ;
29385 PyObject * obj1 = 0 ;
29386 char * kwnames[] = {
29387 (char *) "self",(char *) "needMore", NULL
29388 };
29389
29390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
29391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29392 if (!SWIG_IsOK(res1)) {
29393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
29394 }
29395 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29396 if (obj1) {
29397 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29398 if (!SWIG_IsOK(ecode2)) {
29399 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
29400 }
29401 arg2 = static_cast< bool >(val2);
29402 }
29403 {
29404 PyThreadState* __tstate = wxPyBeginAllowThreads();
29405 (arg1)->RequestMore(arg2);
29406 wxPyEndAllowThreads(__tstate);
29407 if (PyErr_Occurred()) SWIG_fail;
29408 }
29409 resultobj = SWIG_Py_Void();
29410 return resultobj;
29411 fail:
29412 return NULL;
29413 }
29414
29415
29416 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29417 PyObject *resultobj = 0;
29418 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29419 bool result;
29420 void *argp1 = 0 ;
29421 int res1 = 0 ;
29422 PyObject *swig_obj[1] ;
29423
29424 if (!args) SWIG_fail;
29425 swig_obj[0] = args;
29426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29427 if (!SWIG_IsOK(res1)) {
29428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
29429 }
29430 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29431 {
29432 PyThreadState* __tstate = wxPyBeginAllowThreads();
29433 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
29434 wxPyEndAllowThreads(__tstate);
29435 if (PyErr_Occurred()) SWIG_fail;
29436 }
29437 {
29438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29439 }
29440 return resultobj;
29441 fail:
29442 return NULL;
29443 }
29444
29445
29446 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29447 PyObject *resultobj = 0;
29448 wxIdleMode arg1 ;
29449 int val1 ;
29450 int ecode1 = 0 ;
29451 PyObject * obj0 = 0 ;
29452 char * kwnames[] = {
29453 (char *) "mode", NULL
29454 };
29455
29456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
29457 ecode1 = SWIG_AsVal_int(obj0, &val1);
29458 if (!SWIG_IsOK(ecode1)) {
29459 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
29460 }
29461 arg1 = static_cast< wxIdleMode >(val1);
29462 {
29463 PyThreadState* __tstate = wxPyBeginAllowThreads();
29464 wxIdleEvent::SetMode(arg1);
29465 wxPyEndAllowThreads(__tstate);
29466 if (PyErr_Occurred()) SWIG_fail;
29467 }
29468 resultobj = SWIG_Py_Void();
29469 return resultobj;
29470 fail:
29471 return NULL;
29472 }
29473
29474
29475 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29476 PyObject *resultobj = 0;
29477 wxIdleMode result;
29478
29479 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
29480 {
29481 PyThreadState* __tstate = wxPyBeginAllowThreads();
29482 result = (wxIdleMode)wxIdleEvent::GetMode();
29483 wxPyEndAllowThreads(__tstate);
29484 if (PyErr_Occurred()) SWIG_fail;
29485 }
29486 resultobj = SWIG_From_int(static_cast< int >(result));
29487 return resultobj;
29488 fail:
29489 return NULL;
29490 }
29491
29492
29493 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29494 PyObject *resultobj = 0;
29495 wxWindow *arg1 = (wxWindow *) 0 ;
29496 bool result;
29497 void *argp1 = 0 ;
29498 int res1 = 0 ;
29499 PyObject * obj0 = 0 ;
29500 char * kwnames[] = {
29501 (char *) "win", NULL
29502 };
29503
29504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
29505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29506 if (!SWIG_IsOK(res1)) {
29507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
29508 }
29509 arg1 = reinterpret_cast< wxWindow * >(argp1);
29510 {
29511 PyThreadState* __tstate = wxPyBeginAllowThreads();
29512 result = (bool)wxIdleEvent::CanSend(arg1);
29513 wxPyEndAllowThreads(__tstate);
29514 if (PyErr_Occurred()) SWIG_fail;
29515 }
29516 {
29517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29518 }
29519 return resultobj;
29520 fail:
29521 return NULL;
29522 }
29523
29524
29525 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29526 PyObject *obj;
29527 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29528 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
29529 return SWIG_Py_Void();
29530 }
29531
29532 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29533 return SWIG_Python_InitShadowInstance(args);
29534 }
29535
29536 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29537 PyObject *resultobj = 0;
29538 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29539 int arg2 = (int) 0 ;
29540 wxClipboardTextEvent *result = 0 ;
29541 int val1 ;
29542 int ecode1 = 0 ;
29543 int val2 ;
29544 int ecode2 = 0 ;
29545 PyObject * obj0 = 0 ;
29546 PyObject * obj1 = 0 ;
29547 char * kwnames[] = {
29548 (char *) "type",(char *) "winid", NULL
29549 };
29550
29551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29552 if (obj0) {
29553 ecode1 = SWIG_AsVal_int(obj0, &val1);
29554 if (!SWIG_IsOK(ecode1)) {
29555 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29556 }
29557 arg1 = static_cast< wxEventType >(val1);
29558 }
29559 if (obj1) {
29560 ecode2 = SWIG_AsVal_int(obj1, &val2);
29561 if (!SWIG_IsOK(ecode2)) {
29562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
29563 }
29564 arg2 = static_cast< int >(val2);
29565 }
29566 {
29567 PyThreadState* __tstate = wxPyBeginAllowThreads();
29568 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
29569 wxPyEndAllowThreads(__tstate);
29570 if (PyErr_Occurred()) SWIG_fail;
29571 }
29572 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
29573 return resultobj;
29574 fail:
29575 return NULL;
29576 }
29577
29578
29579 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29580 PyObject *obj;
29581 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29582 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
29583 return SWIG_Py_Void();
29584 }
29585
29586 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29587 return SWIG_Python_InitShadowInstance(args);
29588 }
29589
29590 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29591 PyObject *resultobj = 0;
29592 int arg1 = (int) 0 ;
29593 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
29594 wxPyEvent *result = 0 ;
29595 int val1 ;
29596 int ecode1 = 0 ;
29597 int val2 ;
29598 int ecode2 = 0 ;
29599 PyObject * obj0 = 0 ;
29600 PyObject * obj1 = 0 ;
29601 char * kwnames[] = {
29602 (char *) "winid",(char *) "eventType", NULL
29603 };
29604
29605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29606 if (obj0) {
29607 ecode1 = SWIG_AsVal_int(obj0, &val1);
29608 if (!SWIG_IsOK(ecode1)) {
29609 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
29610 }
29611 arg1 = static_cast< int >(val1);
29612 }
29613 if (obj1) {
29614 ecode2 = SWIG_AsVal_int(obj1, &val2);
29615 if (!SWIG_IsOK(ecode2)) {
29616 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
29617 }
29618 arg2 = static_cast< wxEventType >(val2);
29619 }
29620 {
29621 PyThreadState* __tstate = wxPyBeginAllowThreads();
29622 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
29623 wxPyEndAllowThreads(__tstate);
29624 if (PyErr_Occurred()) SWIG_fail;
29625 }
29626 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
29627 return resultobj;
29628 fail:
29629 return NULL;
29630 }
29631
29632
29633 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29634 PyObject *resultobj = 0;
29635 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29636 void *argp1 = 0 ;
29637 int res1 = 0 ;
29638 PyObject *swig_obj[1] ;
29639
29640 if (!args) SWIG_fail;
29641 swig_obj[0] = args;
29642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
29643 if (!SWIG_IsOK(res1)) {
29644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29645 }
29646 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29647 {
29648 PyThreadState* __tstate = wxPyBeginAllowThreads();
29649 delete arg1;
29650
29651 wxPyEndAllowThreads(__tstate);
29652 if (PyErr_Occurred()) SWIG_fail;
29653 }
29654 resultobj = SWIG_Py_Void();
29655 return resultobj;
29656 fail:
29657 return NULL;
29658 }
29659
29660
29661 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29662 PyObject *resultobj = 0;
29663 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29664 PyObject *arg2 = (PyObject *) 0 ;
29665 void *argp1 = 0 ;
29666 int res1 = 0 ;
29667 PyObject * obj0 = 0 ;
29668 PyObject * obj1 = 0 ;
29669 char * kwnames[] = {
29670 (char *) "self",(char *) "self", NULL
29671 };
29672
29673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29675 if (!SWIG_IsOK(res1)) {
29676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29677 }
29678 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29679 arg2 = obj1;
29680 {
29681 PyThreadState* __tstate = wxPyBeginAllowThreads();
29682 (arg1)->SetSelf(arg2);
29683 wxPyEndAllowThreads(__tstate);
29684 if (PyErr_Occurred()) SWIG_fail;
29685 }
29686 resultobj = SWIG_Py_Void();
29687 return resultobj;
29688 fail:
29689 return NULL;
29690 }
29691
29692
29693 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29694 PyObject *resultobj = 0;
29695 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29696 PyObject *result = 0 ;
29697 void *argp1 = 0 ;
29698 int res1 = 0 ;
29699 PyObject *swig_obj[1] ;
29700
29701 if (!args) SWIG_fail;
29702 swig_obj[0] = args;
29703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29704 if (!SWIG_IsOK(res1)) {
29705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29706 }
29707 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29708 {
29709 PyThreadState* __tstate = wxPyBeginAllowThreads();
29710 result = (PyObject *)(arg1)->GetSelf();
29711 wxPyEndAllowThreads(__tstate);
29712 if (PyErr_Occurred()) SWIG_fail;
29713 }
29714 resultobj = result;
29715 return resultobj;
29716 fail:
29717 return NULL;
29718 }
29719
29720
29721 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29722 PyObject *obj;
29723 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29724 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
29725 return SWIG_Py_Void();
29726 }
29727
29728 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29729 return SWIG_Python_InitShadowInstance(args);
29730 }
29731
29732 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29733 PyObject *resultobj = 0;
29734 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29735 int arg2 = (int) 0 ;
29736 wxPyCommandEvent *result = 0 ;
29737 int val1 ;
29738 int ecode1 = 0 ;
29739 int val2 ;
29740 int ecode2 = 0 ;
29741 PyObject * obj0 = 0 ;
29742 PyObject * obj1 = 0 ;
29743 char * kwnames[] = {
29744 (char *) "eventType",(char *) "id", NULL
29745 };
29746
29747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29748 if (obj0) {
29749 ecode1 = SWIG_AsVal_int(obj0, &val1);
29750 if (!SWIG_IsOK(ecode1)) {
29751 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29752 }
29753 arg1 = static_cast< wxEventType >(val1);
29754 }
29755 if (obj1) {
29756 ecode2 = SWIG_AsVal_int(obj1, &val2);
29757 if (!SWIG_IsOK(ecode2)) {
29758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
29759 }
29760 arg2 = static_cast< int >(val2);
29761 }
29762 {
29763 PyThreadState* __tstate = wxPyBeginAllowThreads();
29764 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
29765 wxPyEndAllowThreads(__tstate);
29766 if (PyErr_Occurred()) SWIG_fail;
29767 }
29768 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
29769 return resultobj;
29770 fail:
29771 return NULL;
29772 }
29773
29774
29775 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29776 PyObject *resultobj = 0;
29777 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29778 void *argp1 = 0 ;
29779 int res1 = 0 ;
29780 PyObject *swig_obj[1] ;
29781
29782 if (!args) SWIG_fail;
29783 swig_obj[0] = args;
29784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
29785 if (!SWIG_IsOK(res1)) {
29786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29787 }
29788 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29789 {
29790 PyThreadState* __tstate = wxPyBeginAllowThreads();
29791 delete arg1;
29792
29793 wxPyEndAllowThreads(__tstate);
29794 if (PyErr_Occurred()) SWIG_fail;
29795 }
29796 resultobj = SWIG_Py_Void();
29797 return resultobj;
29798 fail:
29799 return NULL;
29800 }
29801
29802
29803 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29804 PyObject *resultobj = 0;
29805 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29806 PyObject *arg2 = (PyObject *) 0 ;
29807 void *argp1 = 0 ;
29808 int res1 = 0 ;
29809 PyObject * obj0 = 0 ;
29810 PyObject * obj1 = 0 ;
29811 char * kwnames[] = {
29812 (char *) "self",(char *) "self", NULL
29813 };
29814
29815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29817 if (!SWIG_IsOK(res1)) {
29818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29819 }
29820 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29821 arg2 = obj1;
29822 {
29823 PyThreadState* __tstate = wxPyBeginAllowThreads();
29824 (arg1)->SetSelf(arg2);
29825 wxPyEndAllowThreads(__tstate);
29826 if (PyErr_Occurred()) SWIG_fail;
29827 }
29828 resultobj = SWIG_Py_Void();
29829 return resultobj;
29830 fail:
29831 return NULL;
29832 }
29833
29834
29835 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29836 PyObject *resultobj = 0;
29837 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29838 PyObject *result = 0 ;
29839 void *argp1 = 0 ;
29840 int res1 = 0 ;
29841 PyObject *swig_obj[1] ;
29842
29843 if (!args) SWIG_fail;
29844 swig_obj[0] = args;
29845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29846 if (!SWIG_IsOK(res1)) {
29847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29848 }
29849 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29850 {
29851 PyThreadState* __tstate = wxPyBeginAllowThreads();
29852 result = (PyObject *)(arg1)->GetSelf();
29853 wxPyEndAllowThreads(__tstate);
29854 if (PyErr_Occurred()) SWIG_fail;
29855 }
29856 resultobj = result;
29857 return resultobj;
29858 fail:
29859 return NULL;
29860 }
29861
29862
29863 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29864 PyObject *obj;
29865 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29866 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
29867 return SWIG_Py_Void();
29868 }
29869
29870 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29871 return SWIG_Python_InitShadowInstance(args);
29872 }
29873
29874 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29875 PyObject *resultobj = 0;
29876 wxWindow *arg1 = (wxWindow *) 0 ;
29877 wxDateTime *arg2 = 0 ;
29878 wxEventType arg3 ;
29879 wxDateEvent *result = 0 ;
29880 void *argp1 = 0 ;
29881 int res1 = 0 ;
29882 void *argp2 = 0 ;
29883 int res2 = 0 ;
29884 int val3 ;
29885 int ecode3 = 0 ;
29886 PyObject * obj0 = 0 ;
29887 PyObject * obj1 = 0 ;
29888 PyObject * obj2 = 0 ;
29889 char * kwnames[] = {
29890 (char *) "win",(char *) "dt",(char *) "type", NULL
29891 };
29892
29893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29895 if (!SWIG_IsOK(res1)) {
29896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29897 }
29898 arg1 = reinterpret_cast< wxWindow * >(argp1);
29899 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29900 if (!SWIG_IsOK(res2)) {
29901 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29902 }
29903 if (!argp2) {
29904 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29905 }
29906 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29907 ecode3 = SWIG_AsVal_int(obj2, &val3);
29908 if (!SWIG_IsOK(ecode3)) {
29909 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
29910 }
29911 arg3 = static_cast< wxEventType >(val3);
29912 {
29913 PyThreadState* __tstate = wxPyBeginAllowThreads();
29914 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
29915 wxPyEndAllowThreads(__tstate);
29916 if (PyErr_Occurred()) SWIG_fail;
29917 }
29918 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
29919 return resultobj;
29920 fail:
29921 return NULL;
29922 }
29923
29924
29925 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29926 PyObject *resultobj = 0;
29927 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29928 wxDateTime *result = 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_wxDateEvent, 0 | 0 );
29936 if (!SWIG_IsOK(res1)) {
29937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
29938 }
29939 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29940 {
29941 PyThreadState* __tstate = wxPyBeginAllowThreads();
29942 {
29943 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
29944 result = (wxDateTime *) &_result_ref;
29945 }
29946 wxPyEndAllowThreads(__tstate);
29947 if (PyErr_Occurred()) SWIG_fail;
29948 }
29949 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
29950 return resultobj;
29951 fail:
29952 return NULL;
29953 }
29954
29955
29956 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29957 PyObject *resultobj = 0;
29958 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29959 wxDateTime *arg2 = 0 ;
29960 void *argp1 = 0 ;
29961 int res1 = 0 ;
29962 void *argp2 = 0 ;
29963 int res2 = 0 ;
29964 PyObject * obj0 = 0 ;
29965 PyObject * obj1 = 0 ;
29966 char * kwnames[] = {
29967 (char *) "self",(char *) "date", NULL
29968 };
29969
29970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
29971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29972 if (!SWIG_IsOK(res1)) {
29973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
29974 }
29975 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29976 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29977 if (!SWIG_IsOK(res2)) {
29978 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29979 }
29980 if (!argp2) {
29981 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29982 }
29983 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29984 {
29985 PyThreadState* __tstate = wxPyBeginAllowThreads();
29986 (arg1)->SetDate((wxDateTime const &)*arg2);
29987 wxPyEndAllowThreads(__tstate);
29988 if (PyErr_Occurred()) SWIG_fail;
29989 }
29990 resultobj = SWIG_Py_Void();
29991 return resultobj;
29992 fail:
29993 return NULL;
29994 }
29995
29996
29997 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29998 PyObject *obj;
29999 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30000 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
30001 return SWIG_Py_Void();
30002 }
30003
30004 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30005 return SWIG_Python_InitShadowInstance(args);
30006 }
30007
30008 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30009 PyObject *resultobj = 0;
30010 wxPyApp *result = 0 ;
30011
30012 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
30013 {
30014 PyThreadState* __tstate = wxPyBeginAllowThreads();
30015 result = (wxPyApp *)new_wxPyApp();
30016 wxPyEndAllowThreads(__tstate);
30017 if (PyErr_Occurred()) SWIG_fail;
30018 }
30019 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
30020 return resultobj;
30021 fail:
30022 return NULL;
30023 }
30024
30025
30026 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30027 PyObject *resultobj = 0;
30028 wxPyApp *arg1 = (wxPyApp *) 0 ;
30029 void *argp1 = 0 ;
30030 int res1 = 0 ;
30031 PyObject *swig_obj[1] ;
30032
30033 if (!args) SWIG_fail;
30034 swig_obj[0] = args;
30035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
30036 if (!SWIG_IsOK(res1)) {
30037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
30038 }
30039 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30040 {
30041 PyThreadState* __tstate = wxPyBeginAllowThreads();
30042 delete arg1;
30043
30044 wxPyEndAllowThreads(__tstate);
30045 if (PyErr_Occurred()) SWIG_fail;
30046 }
30047 resultobj = SWIG_Py_Void();
30048 return resultobj;
30049 fail:
30050 return NULL;
30051 }
30052
30053
30054 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30055 PyObject *resultobj = 0;
30056 wxPyApp *arg1 = (wxPyApp *) 0 ;
30057 PyObject *arg2 = (PyObject *) 0 ;
30058 PyObject *arg3 = (PyObject *) 0 ;
30059 bool arg4 ;
30060 void *argp1 = 0 ;
30061 int res1 = 0 ;
30062 bool val4 ;
30063 int ecode4 = 0 ;
30064 PyObject * obj0 = 0 ;
30065 PyObject * obj1 = 0 ;
30066 PyObject * obj2 = 0 ;
30067 PyObject * obj3 = 0 ;
30068 char * kwnames[] = {
30069 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
30070 };
30071
30072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30074 if (!SWIG_IsOK(res1)) {
30075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
30076 }
30077 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30078 arg2 = obj1;
30079 arg3 = obj2;
30080 ecode4 = SWIG_AsVal_bool(obj3, &val4);
30081 if (!SWIG_IsOK(ecode4)) {
30082 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
30083 }
30084 arg4 = static_cast< bool >(val4);
30085 {
30086 PyThreadState* __tstate = wxPyBeginAllowThreads();
30087 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
30088 wxPyEndAllowThreads(__tstate);
30089 if (PyErr_Occurred()) SWIG_fail;
30090 }
30091 resultobj = SWIG_Py_Void();
30092 return resultobj;
30093 fail:
30094 return NULL;
30095 }
30096
30097
30098 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30099 PyObject *resultobj = 0;
30100 wxPyApp *arg1 = (wxPyApp *) 0 ;
30101 wxString result;
30102 void *argp1 = 0 ;
30103 int res1 = 0 ;
30104 PyObject *swig_obj[1] ;
30105
30106 if (!args) SWIG_fail;
30107 swig_obj[0] = args;
30108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30109 if (!SWIG_IsOK(res1)) {
30110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30111 }
30112 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30113 {
30114 PyThreadState* __tstate = wxPyBeginAllowThreads();
30115 result = ((wxPyApp const *)arg1)->GetAppName();
30116 wxPyEndAllowThreads(__tstate);
30117 if (PyErr_Occurred()) SWIG_fail;
30118 }
30119 {
30120 #if wxUSE_UNICODE
30121 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30122 #else
30123 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30124 #endif
30125 }
30126 return resultobj;
30127 fail:
30128 return NULL;
30129 }
30130
30131
30132 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30133 PyObject *resultobj = 0;
30134 wxPyApp *arg1 = (wxPyApp *) 0 ;
30135 wxString *arg2 = 0 ;
30136 void *argp1 = 0 ;
30137 int res1 = 0 ;
30138 bool temp2 = false ;
30139 PyObject * obj0 = 0 ;
30140 PyObject * obj1 = 0 ;
30141 char * kwnames[] = {
30142 (char *) "self",(char *) "name", NULL
30143 };
30144
30145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
30146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30147 if (!SWIG_IsOK(res1)) {
30148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30149 }
30150 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30151 {
30152 arg2 = wxString_in_helper(obj1);
30153 if (arg2 == NULL) SWIG_fail;
30154 temp2 = true;
30155 }
30156 {
30157 PyThreadState* __tstate = wxPyBeginAllowThreads();
30158 (arg1)->SetAppName((wxString const &)*arg2);
30159 wxPyEndAllowThreads(__tstate);
30160 if (PyErr_Occurred()) SWIG_fail;
30161 }
30162 resultobj = SWIG_Py_Void();
30163 {
30164 if (temp2)
30165 delete arg2;
30166 }
30167 return resultobj;
30168 fail:
30169 {
30170 if (temp2)
30171 delete arg2;
30172 }
30173 return NULL;
30174 }
30175
30176
30177 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30178 PyObject *resultobj = 0;
30179 wxPyApp *arg1 = (wxPyApp *) 0 ;
30180 wxString result;
30181 void *argp1 = 0 ;
30182 int res1 = 0 ;
30183 PyObject *swig_obj[1] ;
30184
30185 if (!args) SWIG_fail;
30186 swig_obj[0] = args;
30187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30188 if (!SWIG_IsOK(res1)) {
30189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30190 }
30191 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30192 {
30193 PyThreadState* __tstate = wxPyBeginAllowThreads();
30194 result = ((wxPyApp const *)arg1)->GetClassName();
30195 wxPyEndAllowThreads(__tstate);
30196 if (PyErr_Occurred()) SWIG_fail;
30197 }
30198 {
30199 #if wxUSE_UNICODE
30200 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30201 #else
30202 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30203 #endif
30204 }
30205 return resultobj;
30206 fail:
30207 return NULL;
30208 }
30209
30210
30211 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30212 PyObject *resultobj = 0;
30213 wxPyApp *arg1 = (wxPyApp *) 0 ;
30214 wxString *arg2 = 0 ;
30215 void *argp1 = 0 ;
30216 int res1 = 0 ;
30217 bool temp2 = false ;
30218 PyObject * obj0 = 0 ;
30219 PyObject * obj1 = 0 ;
30220 char * kwnames[] = {
30221 (char *) "self",(char *) "name", NULL
30222 };
30223
30224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
30225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30226 if (!SWIG_IsOK(res1)) {
30227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30228 }
30229 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30230 {
30231 arg2 = wxString_in_helper(obj1);
30232 if (arg2 == NULL) SWIG_fail;
30233 temp2 = true;
30234 }
30235 {
30236 PyThreadState* __tstate = wxPyBeginAllowThreads();
30237 (arg1)->SetClassName((wxString const &)*arg2);
30238 wxPyEndAllowThreads(__tstate);
30239 if (PyErr_Occurred()) SWIG_fail;
30240 }
30241 resultobj = SWIG_Py_Void();
30242 {
30243 if (temp2)
30244 delete arg2;
30245 }
30246 return resultobj;
30247 fail:
30248 {
30249 if (temp2)
30250 delete arg2;
30251 }
30252 return NULL;
30253 }
30254
30255
30256 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30257 PyObject *resultobj = 0;
30258 wxPyApp *arg1 = (wxPyApp *) 0 ;
30259 wxString *result = 0 ;
30260 void *argp1 = 0 ;
30261 int res1 = 0 ;
30262 PyObject *swig_obj[1] ;
30263
30264 if (!args) SWIG_fail;
30265 swig_obj[0] = args;
30266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30267 if (!SWIG_IsOK(res1)) {
30268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30269 }
30270 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30271 {
30272 PyThreadState* __tstate = wxPyBeginAllowThreads();
30273 {
30274 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
30275 result = (wxString *) &_result_ref;
30276 }
30277 wxPyEndAllowThreads(__tstate);
30278 if (PyErr_Occurred()) SWIG_fail;
30279 }
30280 {
30281 #if wxUSE_UNICODE
30282 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
30283 #else
30284 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
30285 #endif
30286 }
30287 return resultobj;
30288 fail:
30289 return NULL;
30290 }
30291
30292
30293 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30294 PyObject *resultobj = 0;
30295 wxPyApp *arg1 = (wxPyApp *) 0 ;
30296 wxString *arg2 = 0 ;
30297 void *argp1 = 0 ;
30298 int res1 = 0 ;
30299 bool temp2 = false ;
30300 PyObject * obj0 = 0 ;
30301 PyObject * obj1 = 0 ;
30302 char * kwnames[] = {
30303 (char *) "self",(char *) "name", NULL
30304 };
30305
30306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
30307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30308 if (!SWIG_IsOK(res1)) {
30309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30310 }
30311 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30312 {
30313 arg2 = wxString_in_helper(obj1);
30314 if (arg2 == NULL) SWIG_fail;
30315 temp2 = true;
30316 }
30317 {
30318 PyThreadState* __tstate = wxPyBeginAllowThreads();
30319 (arg1)->SetVendorName((wxString const &)*arg2);
30320 wxPyEndAllowThreads(__tstate);
30321 if (PyErr_Occurred()) SWIG_fail;
30322 }
30323 resultobj = SWIG_Py_Void();
30324 {
30325 if (temp2)
30326 delete arg2;
30327 }
30328 return resultobj;
30329 fail:
30330 {
30331 if (temp2)
30332 delete arg2;
30333 }
30334 return NULL;
30335 }
30336
30337
30338 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30339 PyObject *resultobj = 0;
30340 wxPyApp *arg1 = (wxPyApp *) 0 ;
30341 wxAppTraits *result = 0 ;
30342 void *argp1 = 0 ;
30343 int res1 = 0 ;
30344 PyObject *swig_obj[1] ;
30345
30346 if (!args) SWIG_fail;
30347 swig_obj[0] = args;
30348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30349 if (!SWIG_IsOK(res1)) {
30350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
30351 }
30352 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30353 {
30354 PyThreadState* __tstate = wxPyBeginAllowThreads();
30355 result = (wxAppTraits *)(arg1)->GetTraits();
30356 wxPyEndAllowThreads(__tstate);
30357 if (PyErr_Occurred()) SWIG_fail;
30358 }
30359 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
30360 return resultobj;
30361 fail:
30362 return NULL;
30363 }
30364
30365
30366 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30367 PyObject *resultobj = 0;
30368 wxPyApp *arg1 = (wxPyApp *) 0 ;
30369 void *argp1 = 0 ;
30370 int res1 = 0 ;
30371 PyObject *swig_obj[1] ;
30372
30373 if (!args) SWIG_fail;
30374 swig_obj[0] = args;
30375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30376 if (!SWIG_IsOK(res1)) {
30377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30378 }
30379 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30380 {
30381 PyThreadState* __tstate = wxPyBeginAllowThreads();
30382 (arg1)->ProcessPendingEvents();
30383 wxPyEndAllowThreads(__tstate);
30384 if (PyErr_Occurred()) SWIG_fail;
30385 }
30386 resultobj = SWIG_Py_Void();
30387 return resultobj;
30388 fail:
30389 return NULL;
30390 }
30391
30392
30393 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30394 PyObject *resultobj = 0;
30395 wxPyApp *arg1 = (wxPyApp *) 0 ;
30396 bool arg2 = (bool) false ;
30397 bool result;
30398 void *argp1 = 0 ;
30399 int res1 = 0 ;
30400 bool val2 ;
30401 int ecode2 = 0 ;
30402 PyObject * obj0 = 0 ;
30403 PyObject * obj1 = 0 ;
30404 char * kwnames[] = {
30405 (char *) "self",(char *) "onlyIfNeeded", NULL
30406 };
30407
30408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
30409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30410 if (!SWIG_IsOK(res1)) {
30411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
30412 }
30413 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30414 if (obj1) {
30415 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30416 if (!SWIG_IsOK(ecode2)) {
30417 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
30418 }
30419 arg2 = static_cast< bool >(val2);
30420 }
30421 {
30422 PyThreadState* __tstate = wxPyBeginAllowThreads();
30423 result = (bool)(arg1)->Yield(arg2);
30424 wxPyEndAllowThreads(__tstate);
30425 if (PyErr_Occurred()) SWIG_fail;
30426 }
30427 {
30428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30429 }
30430 return resultobj;
30431 fail:
30432 return NULL;
30433 }
30434
30435
30436 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30437 PyObject *resultobj = 0;
30438 wxPyApp *arg1 = (wxPyApp *) 0 ;
30439 void *argp1 = 0 ;
30440 int res1 = 0 ;
30441 PyObject *swig_obj[1] ;
30442
30443 if (!args) SWIG_fail;
30444 swig_obj[0] = args;
30445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30446 if (!SWIG_IsOK(res1)) {
30447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30448 }
30449 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30450 {
30451 PyThreadState* __tstate = wxPyBeginAllowThreads();
30452 (arg1)->WakeUpIdle();
30453 wxPyEndAllowThreads(__tstate);
30454 if (PyErr_Occurred()) SWIG_fail;
30455 }
30456 resultobj = SWIG_Py_Void();
30457 return resultobj;
30458 fail:
30459 return NULL;
30460 }
30461
30462
30463 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30464 PyObject *resultobj = 0;
30465 bool result;
30466
30467 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
30468 {
30469 PyThreadState* __tstate = wxPyBeginAllowThreads();
30470 result = (bool)wxPyApp::IsMainLoopRunning();
30471 wxPyEndAllowThreads(__tstate);
30472 if (PyErr_Occurred()) SWIG_fail;
30473 }
30474 {
30475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30476 }
30477 return resultobj;
30478 fail:
30479 return NULL;
30480 }
30481
30482
30483 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30484 PyObject *resultobj = 0;
30485 wxPyApp *arg1 = (wxPyApp *) 0 ;
30486 int result;
30487 void *argp1 = 0 ;
30488 int res1 = 0 ;
30489 PyObject *swig_obj[1] ;
30490
30491 if (!args) SWIG_fail;
30492 swig_obj[0] = args;
30493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30494 if (!SWIG_IsOK(res1)) {
30495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30496 }
30497 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30498 {
30499 PyThreadState* __tstate = wxPyBeginAllowThreads();
30500 result = (int)(arg1)->MainLoop();
30501 wxPyEndAllowThreads(__tstate);
30502 if (PyErr_Occurred()) SWIG_fail;
30503 }
30504 resultobj = SWIG_From_int(static_cast< int >(result));
30505 return resultobj;
30506 fail:
30507 return NULL;
30508 }
30509
30510
30511 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30512 PyObject *resultobj = 0;
30513 wxPyApp *arg1 = (wxPyApp *) 0 ;
30514 void *argp1 = 0 ;
30515 int res1 = 0 ;
30516 PyObject *swig_obj[1] ;
30517
30518 if (!args) SWIG_fail;
30519 swig_obj[0] = args;
30520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30521 if (!SWIG_IsOK(res1)) {
30522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
30523 }
30524 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30525 {
30526 PyThreadState* __tstate = wxPyBeginAllowThreads();
30527 (arg1)->Exit();
30528 wxPyEndAllowThreads(__tstate);
30529 if (PyErr_Occurred()) SWIG_fail;
30530 }
30531 resultobj = SWIG_Py_Void();
30532 return resultobj;
30533 fail:
30534 return NULL;
30535 }
30536
30537
30538 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30539 PyObject *resultobj = 0;
30540 wxPyApp *arg1 = (wxPyApp *) 0 ;
30541 wxLayoutDirection result;
30542 void *argp1 = 0 ;
30543 int res1 = 0 ;
30544 PyObject *swig_obj[1] ;
30545
30546 if (!args) SWIG_fail;
30547 swig_obj[0] = args;
30548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30549 if (!SWIG_IsOK(res1)) {
30550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30551 }
30552 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30553 {
30554 PyThreadState* __tstate = wxPyBeginAllowThreads();
30555 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
30556 wxPyEndAllowThreads(__tstate);
30557 if (PyErr_Occurred()) SWIG_fail;
30558 }
30559 resultobj = SWIG_From_int(static_cast< int >(result));
30560 return resultobj;
30561 fail:
30562 return NULL;
30563 }
30564
30565
30566 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30567 PyObject *resultobj = 0;
30568 wxPyApp *arg1 = (wxPyApp *) 0 ;
30569 void *argp1 = 0 ;
30570 int res1 = 0 ;
30571 PyObject *swig_obj[1] ;
30572
30573 if (!args) SWIG_fail;
30574 swig_obj[0] = args;
30575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30576 if (!SWIG_IsOK(res1)) {
30577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30578 }
30579 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30580 {
30581 PyThreadState* __tstate = wxPyBeginAllowThreads();
30582 (arg1)->ExitMainLoop();
30583 wxPyEndAllowThreads(__tstate);
30584 if (PyErr_Occurred()) SWIG_fail;
30585 }
30586 resultobj = SWIG_Py_Void();
30587 return resultobj;
30588 fail:
30589 return NULL;
30590 }
30591
30592
30593 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30594 PyObject *resultobj = 0;
30595 wxPyApp *arg1 = (wxPyApp *) 0 ;
30596 bool result;
30597 void *argp1 = 0 ;
30598 int res1 = 0 ;
30599 PyObject *swig_obj[1] ;
30600
30601 if (!args) SWIG_fail;
30602 swig_obj[0] = args;
30603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30604 if (!SWIG_IsOK(res1)) {
30605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
30606 }
30607 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30608 {
30609 PyThreadState* __tstate = wxPyBeginAllowThreads();
30610 result = (bool)(arg1)->Pending();
30611 wxPyEndAllowThreads(__tstate);
30612 if (PyErr_Occurred()) SWIG_fail;
30613 }
30614 {
30615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30616 }
30617 return resultobj;
30618 fail:
30619 return NULL;
30620 }
30621
30622
30623 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30624 PyObject *resultobj = 0;
30625 wxPyApp *arg1 = (wxPyApp *) 0 ;
30626 bool result;
30627 void *argp1 = 0 ;
30628 int res1 = 0 ;
30629 PyObject *swig_obj[1] ;
30630
30631 if (!args) SWIG_fail;
30632 swig_obj[0] = args;
30633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30634 if (!SWIG_IsOK(res1)) {
30635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
30636 }
30637 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30638 {
30639 PyThreadState* __tstate = wxPyBeginAllowThreads();
30640 result = (bool)(arg1)->Dispatch();
30641 wxPyEndAllowThreads(__tstate);
30642 if (PyErr_Occurred()) SWIG_fail;
30643 }
30644 {
30645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30646 }
30647 return resultobj;
30648 fail:
30649 return NULL;
30650 }
30651
30652
30653 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30654 PyObject *resultobj = 0;
30655 wxPyApp *arg1 = (wxPyApp *) 0 ;
30656 bool result;
30657 void *argp1 = 0 ;
30658 int res1 = 0 ;
30659 PyObject *swig_obj[1] ;
30660
30661 if (!args) SWIG_fail;
30662 swig_obj[0] = args;
30663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30664 if (!SWIG_IsOK(res1)) {
30665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30666 }
30667 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30668 {
30669 PyThreadState* __tstate = wxPyBeginAllowThreads();
30670 result = (bool)(arg1)->ProcessIdle();
30671 wxPyEndAllowThreads(__tstate);
30672 if (PyErr_Occurred()) SWIG_fail;
30673 }
30674 {
30675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30676 }
30677 return resultobj;
30678 fail:
30679 return NULL;
30680 }
30681
30682
30683 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30684 PyObject *resultobj = 0;
30685 wxPyApp *arg1 = (wxPyApp *) 0 ;
30686 wxWindow *arg2 = (wxWindow *) 0 ;
30687 wxIdleEvent *arg3 = 0 ;
30688 bool result;
30689 void *argp1 = 0 ;
30690 int res1 = 0 ;
30691 void *argp2 = 0 ;
30692 int res2 = 0 ;
30693 void *argp3 = 0 ;
30694 int res3 = 0 ;
30695 PyObject * obj0 = 0 ;
30696 PyObject * obj1 = 0 ;
30697 PyObject * obj2 = 0 ;
30698 char * kwnames[] = {
30699 (char *) "self",(char *) "win",(char *) "event", NULL
30700 };
30701
30702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30704 if (!SWIG_IsOK(res1)) {
30705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30706 }
30707 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30708 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30709 if (!SWIG_IsOK(res2)) {
30710 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
30711 }
30712 arg2 = reinterpret_cast< wxWindow * >(argp2);
30713 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
30714 if (!SWIG_IsOK(res3)) {
30715 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30716 }
30717 if (!argp3) {
30718 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30719 }
30720 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
30721 {
30722 PyThreadState* __tstate = wxPyBeginAllowThreads();
30723 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
30724 wxPyEndAllowThreads(__tstate);
30725 if (PyErr_Occurred()) SWIG_fail;
30726 }
30727 {
30728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30729 }
30730 return resultobj;
30731 fail:
30732 return NULL;
30733 }
30734
30735
30736 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30737 PyObject *resultobj = 0;
30738 wxPyApp *arg1 = (wxPyApp *) 0 ;
30739 bool result;
30740 void *argp1 = 0 ;
30741 int res1 = 0 ;
30742 PyObject *swig_obj[1] ;
30743
30744 if (!args) SWIG_fail;
30745 swig_obj[0] = args;
30746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30747 if (!SWIG_IsOK(res1)) {
30748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30749 }
30750 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30751 {
30752 PyThreadState* __tstate = wxPyBeginAllowThreads();
30753 result = (bool)((wxPyApp const *)arg1)->IsActive();
30754 wxPyEndAllowThreads(__tstate);
30755 if (PyErr_Occurred()) SWIG_fail;
30756 }
30757 {
30758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30759 }
30760 return resultobj;
30761 fail:
30762 return NULL;
30763 }
30764
30765
30766 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30767 PyObject *resultobj = 0;
30768 wxPyApp *arg1 = (wxPyApp *) 0 ;
30769 wxWindow *arg2 = (wxWindow *) 0 ;
30770 void *argp1 = 0 ;
30771 int res1 = 0 ;
30772 void *argp2 = 0 ;
30773 int res2 = 0 ;
30774 PyObject * obj0 = 0 ;
30775 PyObject * obj1 = 0 ;
30776 char * kwnames[] = {
30777 (char *) "self",(char *) "win", NULL
30778 };
30779
30780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
30781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30782 if (!SWIG_IsOK(res1)) {
30783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
30784 }
30785 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30786 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30787 if (!SWIG_IsOK(res2)) {
30788 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
30789 }
30790 arg2 = reinterpret_cast< wxWindow * >(argp2);
30791 {
30792 PyThreadState* __tstate = wxPyBeginAllowThreads();
30793 (arg1)->SetTopWindow(arg2);
30794 wxPyEndAllowThreads(__tstate);
30795 if (PyErr_Occurred()) SWIG_fail;
30796 }
30797 resultobj = SWIG_Py_Void();
30798 return resultobj;
30799 fail:
30800 return NULL;
30801 }
30802
30803
30804 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30805 PyObject *resultobj = 0;
30806 wxPyApp *arg1 = (wxPyApp *) 0 ;
30807 wxWindow *result = 0 ;
30808 void *argp1 = 0 ;
30809 int res1 = 0 ;
30810 PyObject *swig_obj[1] ;
30811
30812 if (!args) SWIG_fail;
30813 swig_obj[0] = args;
30814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30815 if (!SWIG_IsOK(res1)) {
30816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30817 }
30818 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30819 {
30820 PyThreadState* __tstate = wxPyBeginAllowThreads();
30821 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
30822 wxPyEndAllowThreads(__tstate);
30823 if (PyErr_Occurred()) SWIG_fail;
30824 }
30825 {
30826 resultobj = wxPyMake_wxObject(result, (bool)0);
30827 }
30828 return resultobj;
30829 fail:
30830 return NULL;
30831 }
30832
30833
30834 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30835 PyObject *resultobj = 0;
30836 wxPyApp *arg1 = (wxPyApp *) 0 ;
30837 bool arg2 ;
30838 void *argp1 = 0 ;
30839 int res1 = 0 ;
30840 bool val2 ;
30841 int ecode2 = 0 ;
30842 PyObject * obj0 = 0 ;
30843 PyObject * obj1 = 0 ;
30844 char * kwnames[] = {
30845 (char *) "self",(char *) "flag", NULL
30846 };
30847
30848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
30849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30850 if (!SWIG_IsOK(res1)) {
30851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
30852 }
30853 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30854 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30855 if (!SWIG_IsOK(ecode2)) {
30856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
30857 }
30858 arg2 = static_cast< bool >(val2);
30859 {
30860 PyThreadState* __tstate = wxPyBeginAllowThreads();
30861 (arg1)->SetExitOnFrameDelete(arg2);
30862 wxPyEndAllowThreads(__tstate);
30863 if (PyErr_Occurred()) SWIG_fail;
30864 }
30865 resultobj = SWIG_Py_Void();
30866 return resultobj;
30867 fail:
30868 return NULL;
30869 }
30870
30871
30872 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30873 PyObject *resultobj = 0;
30874 wxPyApp *arg1 = (wxPyApp *) 0 ;
30875 bool result;
30876 void *argp1 = 0 ;
30877 int res1 = 0 ;
30878 PyObject *swig_obj[1] ;
30879
30880 if (!args) SWIG_fail;
30881 swig_obj[0] = args;
30882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30883 if (!SWIG_IsOK(res1)) {
30884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30885 }
30886 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30887 {
30888 PyThreadState* __tstate = wxPyBeginAllowThreads();
30889 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
30890 wxPyEndAllowThreads(__tstate);
30891 if (PyErr_Occurred()) SWIG_fail;
30892 }
30893 {
30894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30895 }
30896 return resultobj;
30897 fail:
30898 return NULL;
30899 }
30900
30901
30902 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30903 PyObject *resultobj = 0;
30904 wxPyApp *arg1 = (wxPyApp *) 0 ;
30905 bool arg2 ;
30906 void *argp1 = 0 ;
30907 int res1 = 0 ;
30908 bool val2 ;
30909 int ecode2 = 0 ;
30910 PyObject * obj0 = 0 ;
30911 PyObject * obj1 = 0 ;
30912 char * kwnames[] = {
30913 (char *) "self",(char *) "flag", NULL
30914 };
30915
30916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
30917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30918 if (!SWIG_IsOK(res1)) {
30919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
30920 }
30921 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30922 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30923 if (!SWIG_IsOK(ecode2)) {
30924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
30925 }
30926 arg2 = static_cast< bool >(val2);
30927 {
30928 PyThreadState* __tstate = wxPyBeginAllowThreads();
30929 (arg1)->SetUseBestVisual(arg2);
30930 wxPyEndAllowThreads(__tstate);
30931 if (PyErr_Occurred()) SWIG_fail;
30932 }
30933 resultobj = SWIG_Py_Void();
30934 return resultobj;
30935 fail:
30936 return NULL;
30937 }
30938
30939
30940 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30941 PyObject *resultobj = 0;
30942 wxPyApp *arg1 = (wxPyApp *) 0 ;
30943 bool result;
30944 void *argp1 = 0 ;
30945 int res1 = 0 ;
30946 PyObject *swig_obj[1] ;
30947
30948 if (!args) SWIG_fail;
30949 swig_obj[0] = args;
30950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30951 if (!SWIG_IsOK(res1)) {
30952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30953 }
30954 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30955 {
30956 PyThreadState* __tstate = wxPyBeginAllowThreads();
30957 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
30958 wxPyEndAllowThreads(__tstate);
30959 if (PyErr_Occurred()) SWIG_fail;
30960 }
30961 {
30962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30963 }
30964 return resultobj;
30965 fail:
30966 return NULL;
30967 }
30968
30969
30970 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30971 PyObject *resultobj = 0;
30972 wxPyApp *arg1 = (wxPyApp *) 0 ;
30973 int arg2 ;
30974 void *argp1 = 0 ;
30975 int res1 = 0 ;
30976 int val2 ;
30977 int ecode2 = 0 ;
30978 PyObject * obj0 = 0 ;
30979 PyObject * obj1 = 0 ;
30980 char * kwnames[] = {
30981 (char *) "self",(char *) "mode", NULL
30982 };
30983
30984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
30985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30986 if (!SWIG_IsOK(res1)) {
30987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
30988 }
30989 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30990 ecode2 = SWIG_AsVal_int(obj1, &val2);
30991 if (!SWIG_IsOK(ecode2)) {
30992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
30993 }
30994 arg2 = static_cast< int >(val2);
30995 {
30996 PyThreadState* __tstate = wxPyBeginAllowThreads();
30997 (arg1)->SetPrintMode(arg2);
30998 wxPyEndAllowThreads(__tstate);
30999 if (PyErr_Occurred()) SWIG_fail;
31000 }
31001 resultobj = SWIG_Py_Void();
31002 return resultobj;
31003 fail:
31004 return NULL;
31005 }
31006
31007
31008 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31009 PyObject *resultobj = 0;
31010 wxPyApp *arg1 = (wxPyApp *) 0 ;
31011 int result;
31012 void *argp1 = 0 ;
31013 int res1 = 0 ;
31014 PyObject *swig_obj[1] ;
31015
31016 if (!args) SWIG_fail;
31017 swig_obj[0] = args;
31018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31019 if (!SWIG_IsOK(res1)) {
31020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31021 }
31022 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31023 {
31024 PyThreadState* __tstate = wxPyBeginAllowThreads();
31025 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
31026 wxPyEndAllowThreads(__tstate);
31027 if (PyErr_Occurred()) SWIG_fail;
31028 }
31029 resultobj = SWIG_From_int(static_cast< int >(result));
31030 return resultobj;
31031 fail:
31032 return NULL;
31033 }
31034
31035
31036 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31037 PyObject *resultobj = 0;
31038 wxPyApp *arg1 = (wxPyApp *) 0 ;
31039 int arg2 ;
31040 void *argp1 = 0 ;
31041 int res1 = 0 ;
31042 int val2 ;
31043 int ecode2 = 0 ;
31044 PyObject * obj0 = 0 ;
31045 PyObject * obj1 = 0 ;
31046 char * kwnames[] = {
31047 (char *) "self",(char *) "mode", NULL
31048 };
31049
31050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
31051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31052 if (!SWIG_IsOK(res1)) {
31053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31054 }
31055 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31056 ecode2 = SWIG_AsVal_int(obj1, &val2);
31057 if (!SWIG_IsOK(ecode2)) {
31058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
31059 }
31060 arg2 = static_cast< int >(val2);
31061 {
31062 PyThreadState* __tstate = wxPyBeginAllowThreads();
31063 (arg1)->SetAssertMode(arg2);
31064 wxPyEndAllowThreads(__tstate);
31065 if (PyErr_Occurred()) SWIG_fail;
31066 }
31067 resultobj = SWIG_Py_Void();
31068 return resultobj;
31069 fail:
31070 return NULL;
31071 }
31072
31073
31074 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31075 PyObject *resultobj = 0;
31076 wxPyApp *arg1 = (wxPyApp *) 0 ;
31077 int result;
31078 void *argp1 = 0 ;
31079 int res1 = 0 ;
31080 PyObject *swig_obj[1] ;
31081
31082 if (!args) SWIG_fail;
31083 swig_obj[0] = args;
31084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31085 if (!SWIG_IsOK(res1)) {
31086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31087 }
31088 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31089 {
31090 PyThreadState* __tstate = wxPyBeginAllowThreads();
31091 result = (int)(arg1)->GetAssertMode();
31092 wxPyEndAllowThreads(__tstate);
31093 if (PyErr_Occurred()) SWIG_fail;
31094 }
31095 resultobj = SWIG_From_int(static_cast< int >(result));
31096 return resultobj;
31097 fail:
31098 return NULL;
31099 }
31100
31101
31102 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31103 PyObject *resultobj = 0;
31104 bool result;
31105
31106 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
31107 {
31108 PyThreadState* __tstate = wxPyBeginAllowThreads();
31109 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
31110 wxPyEndAllowThreads(__tstate);
31111 if (PyErr_Occurred()) SWIG_fail;
31112 }
31113 {
31114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31115 }
31116 return resultobj;
31117 fail:
31118 return NULL;
31119 }
31120
31121
31122 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31123 PyObject *resultobj = 0;
31124 long result;
31125
31126 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
31127 {
31128 PyThreadState* __tstate = wxPyBeginAllowThreads();
31129 result = (long)wxPyApp::GetMacAboutMenuItemId();
31130 wxPyEndAllowThreads(__tstate);
31131 if (PyErr_Occurred()) SWIG_fail;
31132 }
31133 resultobj = SWIG_From_long(static_cast< long >(result));
31134 return resultobj;
31135 fail:
31136 return NULL;
31137 }
31138
31139
31140 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31141 PyObject *resultobj = 0;
31142 long result;
31143
31144 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
31145 {
31146 PyThreadState* __tstate = wxPyBeginAllowThreads();
31147 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
31148 wxPyEndAllowThreads(__tstate);
31149 if (PyErr_Occurred()) SWIG_fail;
31150 }
31151 resultobj = SWIG_From_long(static_cast< long >(result));
31152 return resultobj;
31153 fail:
31154 return NULL;
31155 }
31156
31157
31158 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31159 PyObject *resultobj = 0;
31160 long result;
31161
31162 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
31163 {
31164 PyThreadState* __tstate = wxPyBeginAllowThreads();
31165 result = (long)wxPyApp::GetMacExitMenuItemId();
31166 wxPyEndAllowThreads(__tstate);
31167 if (PyErr_Occurred()) SWIG_fail;
31168 }
31169 resultobj = SWIG_From_long(static_cast< long >(result));
31170 return resultobj;
31171 fail:
31172 return NULL;
31173 }
31174
31175
31176 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31177 PyObject *resultobj = 0;
31178 wxString result;
31179
31180 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
31181 {
31182 PyThreadState* __tstate = wxPyBeginAllowThreads();
31183 result = wxPyApp::GetMacHelpMenuTitleName();
31184 wxPyEndAllowThreads(__tstate);
31185 if (PyErr_Occurred()) SWIG_fail;
31186 }
31187 {
31188 #if wxUSE_UNICODE
31189 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31190 #else
31191 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31192 #endif
31193 }
31194 return resultobj;
31195 fail:
31196 return NULL;
31197 }
31198
31199
31200 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31201 PyObject *resultobj = 0;
31202 bool arg1 ;
31203 bool 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_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
31211 ecode1 = SWIG_AsVal_bool(obj0, &val1);
31212 if (!SWIG_IsOK(ecode1)) {
31213 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
31214 }
31215 arg1 = static_cast< bool >(val1);
31216 {
31217 PyThreadState* __tstate = wxPyBeginAllowThreads();
31218 wxPyApp::SetMacSupportPCMenuShortcuts(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_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31230 PyObject *resultobj = 0;
31231 long arg1 ;
31232 long val1 ;
31233 int ecode1 = 0 ;
31234 PyObject * obj0 = 0 ;
31235 char * kwnames[] = {
31236 (char *) "val", NULL
31237 };
31238
31239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
31240 ecode1 = SWIG_AsVal_long(obj0, &val1);
31241 if (!SWIG_IsOK(ecode1)) {
31242 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
31243 }
31244 arg1 = static_cast< long >(val1);
31245 {
31246 PyThreadState* __tstate = wxPyBeginAllowThreads();
31247 wxPyApp::SetMacAboutMenuItemId(arg1);
31248 wxPyEndAllowThreads(__tstate);
31249 if (PyErr_Occurred()) SWIG_fail;
31250 }
31251 resultobj = SWIG_Py_Void();
31252 return resultobj;
31253 fail:
31254 return NULL;
31255 }
31256
31257
31258 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31259 PyObject *resultobj = 0;
31260 long arg1 ;
31261 long val1 ;
31262 int ecode1 = 0 ;
31263 PyObject * obj0 = 0 ;
31264 char * kwnames[] = {
31265 (char *) "val", NULL
31266 };
31267
31268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
31269 ecode1 = SWIG_AsVal_long(obj0, &val1);
31270 if (!SWIG_IsOK(ecode1)) {
31271 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
31272 }
31273 arg1 = static_cast< long >(val1);
31274 {
31275 PyThreadState* __tstate = wxPyBeginAllowThreads();
31276 wxPyApp::SetMacPreferencesMenuItemId(arg1);
31277 wxPyEndAllowThreads(__tstate);
31278 if (PyErr_Occurred()) SWIG_fail;
31279 }
31280 resultobj = SWIG_Py_Void();
31281 return resultobj;
31282 fail:
31283 return NULL;
31284 }
31285
31286
31287 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31288 PyObject *resultobj = 0;
31289 long arg1 ;
31290 long val1 ;
31291 int ecode1 = 0 ;
31292 PyObject * obj0 = 0 ;
31293 char * kwnames[] = {
31294 (char *) "val", NULL
31295 };
31296
31297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
31298 ecode1 = SWIG_AsVal_long(obj0, &val1);
31299 if (!SWIG_IsOK(ecode1)) {
31300 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
31301 }
31302 arg1 = static_cast< long >(val1);
31303 {
31304 PyThreadState* __tstate = wxPyBeginAllowThreads();
31305 wxPyApp::SetMacExitMenuItemId(arg1);
31306 wxPyEndAllowThreads(__tstate);
31307 if (PyErr_Occurred()) SWIG_fail;
31308 }
31309 resultobj = SWIG_Py_Void();
31310 return resultobj;
31311 fail:
31312 return NULL;
31313 }
31314
31315
31316 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31317 PyObject *resultobj = 0;
31318 wxString *arg1 = 0 ;
31319 bool temp1 = false ;
31320 PyObject * obj0 = 0 ;
31321 char * kwnames[] = {
31322 (char *) "val", NULL
31323 };
31324
31325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
31326 {
31327 arg1 = wxString_in_helper(obj0);
31328 if (arg1 == NULL) SWIG_fail;
31329 temp1 = true;
31330 }
31331 {
31332 PyThreadState* __tstate = wxPyBeginAllowThreads();
31333 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
31334 wxPyEndAllowThreads(__tstate);
31335 if (PyErr_Occurred()) SWIG_fail;
31336 }
31337 resultobj = SWIG_Py_Void();
31338 {
31339 if (temp1)
31340 delete arg1;
31341 }
31342 return resultobj;
31343 fail:
31344 {
31345 if (temp1)
31346 delete arg1;
31347 }
31348 return NULL;
31349 }
31350
31351
31352 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31353 PyObject *resultobj = 0;
31354 wxPyApp *arg1 = (wxPyApp *) 0 ;
31355 void *argp1 = 0 ;
31356 int res1 = 0 ;
31357 PyObject *swig_obj[1] ;
31358
31359 if (!args) SWIG_fail;
31360 swig_obj[0] = args;
31361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31362 if (!SWIG_IsOK(res1)) {
31363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
31364 }
31365 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31366 {
31367 PyThreadState* __tstate = wxPyBeginAllowThreads();
31368 (arg1)->_BootstrapApp();
31369 wxPyEndAllowThreads(__tstate);
31370 if (PyErr_Occurred()) SWIG_fail;
31371 }
31372 resultobj = SWIG_Py_Void();
31373 return resultobj;
31374 fail:
31375 return NULL;
31376 }
31377
31378
31379 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31380 PyObject *resultobj = 0;
31381 int result;
31382
31383 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
31384 {
31385 PyThreadState* __tstate = wxPyBeginAllowThreads();
31386 result = (int)wxPyApp_GetComCtl32Version();
31387 wxPyEndAllowThreads(__tstate);
31388 if (PyErr_Occurred()) SWIG_fail;
31389 }
31390 resultobj = SWIG_From_int(static_cast< int >(result));
31391 return resultobj;
31392 fail:
31393 return NULL;
31394 }
31395
31396
31397 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31398 PyObject *resultobj = 0;
31399 bool result;
31400
31401 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
31402 {
31403 PyThreadState* __tstate = wxPyBeginAllowThreads();
31404 result = (bool)wxPyApp_IsDisplayAvailable();
31405 wxPyEndAllowThreads(__tstate);
31406 if (PyErr_Occurred()) SWIG_fail;
31407 }
31408 {
31409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31410 }
31411 return resultobj;
31412 fail:
31413 return NULL;
31414 }
31415
31416
31417 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31418 PyObject *obj;
31419 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31420 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
31421 return SWIG_Py_Void();
31422 }
31423
31424 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31425 return SWIG_Python_InitShadowInstance(args);
31426 }
31427
31428 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31429 PyObject *resultobj = 0;
31430
31431 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
31432 {
31433 PyThreadState* __tstate = wxPyBeginAllowThreads();
31434 wxExit();
31435 wxPyEndAllowThreads(__tstate);
31436 if (PyErr_Occurred()) SWIG_fail;
31437 }
31438 resultobj = SWIG_Py_Void();
31439 return resultobj;
31440 fail:
31441 return NULL;
31442 }
31443
31444
31445 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31446 PyObject *resultobj = 0;
31447 bool result;
31448
31449 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
31450 {
31451 PyThreadState* __tstate = wxPyBeginAllowThreads();
31452 result = (bool)wxYield();
31453 wxPyEndAllowThreads(__tstate);
31454 if (PyErr_Occurred()) SWIG_fail;
31455 }
31456 {
31457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31458 }
31459 return resultobj;
31460 fail:
31461 return NULL;
31462 }
31463
31464
31465 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31466 PyObject *resultobj = 0;
31467 bool result;
31468
31469 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
31470 {
31471 PyThreadState* __tstate = wxPyBeginAllowThreads();
31472 result = (bool)wxYieldIfNeeded();
31473 wxPyEndAllowThreads(__tstate);
31474 if (PyErr_Occurred()) SWIG_fail;
31475 }
31476 {
31477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31478 }
31479 return resultobj;
31480 fail:
31481 return NULL;
31482 }
31483
31484
31485 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31486 PyObject *resultobj = 0;
31487 wxWindow *arg1 = (wxWindow *) NULL ;
31488 bool arg2 = (bool) false ;
31489 bool result;
31490 void *argp1 = 0 ;
31491 int res1 = 0 ;
31492 bool val2 ;
31493 int ecode2 = 0 ;
31494 PyObject * obj0 = 0 ;
31495 PyObject * obj1 = 0 ;
31496 char * kwnames[] = {
31497 (char *) "win",(char *) "onlyIfNeeded", NULL
31498 };
31499
31500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
31501 if (obj0) {
31502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31503 if (!SWIG_IsOK(res1)) {
31504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
31505 }
31506 arg1 = reinterpret_cast< wxWindow * >(argp1);
31507 }
31508 if (obj1) {
31509 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31510 if (!SWIG_IsOK(ecode2)) {
31511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
31512 }
31513 arg2 = static_cast< bool >(val2);
31514 }
31515 {
31516 PyThreadState* __tstate = wxPyBeginAllowThreads();
31517 result = (bool)wxSafeYield(arg1,arg2);
31518 wxPyEndAllowThreads(__tstate);
31519 if (PyErr_Occurred()) SWIG_fail;
31520 }
31521 {
31522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31523 }
31524 return resultobj;
31525 fail:
31526 return NULL;
31527 }
31528
31529
31530 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31531 PyObject *resultobj = 0;
31532
31533 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
31534 {
31535 PyThreadState* __tstate = wxPyBeginAllowThreads();
31536 wxWakeUpIdle();
31537 wxPyEndAllowThreads(__tstate);
31538 if (PyErr_Occurred()) SWIG_fail;
31539 }
31540 resultobj = SWIG_Py_Void();
31541 return resultobj;
31542 fail:
31543 return NULL;
31544 }
31545
31546
31547 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31548 PyObject *resultobj = 0;
31549 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
31550 wxEvent *arg2 = 0 ;
31551 void *argp1 = 0 ;
31552 int res1 = 0 ;
31553 void *argp2 = 0 ;
31554 int res2 = 0 ;
31555 PyObject * obj0 = 0 ;
31556 PyObject * obj1 = 0 ;
31557 char * kwnames[] = {
31558 (char *) "dest",(char *) "event", NULL
31559 };
31560
31561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
31562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
31563 if (!SWIG_IsOK(res1)) {
31564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
31565 }
31566 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
31567 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
31568 if (!SWIG_IsOK(res2)) {
31569 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31570 }
31571 if (!argp2) {
31572 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31573 }
31574 arg2 = reinterpret_cast< wxEvent * >(argp2);
31575 {
31576 PyThreadState* __tstate = wxPyBeginAllowThreads();
31577 wxPostEvent(arg1,*arg2);
31578 wxPyEndAllowThreads(__tstate);
31579 if (PyErr_Occurred()) SWIG_fail;
31580 }
31581 resultobj = SWIG_Py_Void();
31582 return resultobj;
31583 fail:
31584 return NULL;
31585 }
31586
31587
31588 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31589 PyObject *resultobj = 0;
31590
31591 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
31592 {
31593 PyThreadState* __tstate = wxPyBeginAllowThreads();
31594 wxApp_CleanUp();
31595 wxPyEndAllowThreads(__tstate);
31596 if (PyErr_Occurred()) SWIG_fail;
31597 }
31598 resultobj = SWIG_Py_Void();
31599 return resultobj;
31600 fail:
31601 return NULL;
31602 }
31603
31604
31605 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31606 PyObject *resultobj = 0;
31607 wxPyApp *result = 0 ;
31608
31609 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
31610 {
31611 PyThreadState* __tstate = wxPyBeginAllowThreads();
31612 result = (wxPyApp *)wxPyGetApp();
31613 wxPyEndAllowThreads(__tstate);
31614 if (PyErr_Occurred()) SWIG_fail;
31615 }
31616 {
31617 resultobj = wxPyMake_wxObject(result, 0);
31618 }
31619 return resultobj;
31620 fail:
31621 return NULL;
31622 }
31623
31624
31625 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31626 PyObject *resultobj = 0;
31627 char *arg1 = (char *) 0 ;
31628 int res1 ;
31629 char *buf1 = 0 ;
31630 int alloc1 = 0 ;
31631 PyObject * obj0 = 0 ;
31632 char * kwnames[] = {
31633 (char *) "encoding", NULL
31634 };
31635
31636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
31637 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
31638 if (!SWIG_IsOK(res1)) {
31639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
31640 }
31641 arg1 = buf1;
31642 {
31643 PyThreadState* __tstate = wxPyBeginAllowThreads();
31644 wxSetDefaultPyEncoding((char const *)arg1);
31645 wxPyEndAllowThreads(__tstate);
31646 if (PyErr_Occurred()) SWIG_fail;
31647 }
31648 resultobj = SWIG_Py_Void();
31649 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31650 return resultobj;
31651 fail:
31652 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31653 return NULL;
31654 }
31655
31656
31657 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31658 PyObject *resultobj = 0;
31659 char *result = 0 ;
31660
31661 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
31662 {
31663 PyThreadState* __tstate = wxPyBeginAllowThreads();
31664 result = (char *)wxGetDefaultPyEncoding();
31665 wxPyEndAllowThreads(__tstate);
31666 if (PyErr_Occurred()) SWIG_fail;
31667 }
31668 resultobj = SWIG_FromCharPtr(result);
31669 return resultobj;
31670 fail:
31671 return NULL;
31672 }
31673
31674
31675 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31676 PyObject *resultobj = 0;
31677 wxEventLoop *result = 0 ;
31678
31679 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
31680 {
31681 PyThreadState* __tstate = wxPyBeginAllowThreads();
31682 result = (wxEventLoop *)new wxEventLoop();
31683 wxPyEndAllowThreads(__tstate);
31684 if (PyErr_Occurred()) SWIG_fail;
31685 }
31686 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
31687 return resultobj;
31688 fail:
31689 return NULL;
31690 }
31691
31692
31693 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31694 PyObject *resultobj = 0;
31695 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31696 void *argp1 = 0 ;
31697 int res1 = 0 ;
31698 PyObject *swig_obj[1] ;
31699
31700 if (!args) SWIG_fail;
31701 swig_obj[0] = args;
31702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
31703 if (!SWIG_IsOK(res1)) {
31704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31705 }
31706 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31707 {
31708 PyThreadState* __tstate = wxPyBeginAllowThreads();
31709 delete arg1;
31710
31711 wxPyEndAllowThreads(__tstate);
31712 if (PyErr_Occurred()) SWIG_fail;
31713 }
31714 resultobj = SWIG_Py_Void();
31715 return resultobj;
31716 fail:
31717 return NULL;
31718 }
31719
31720
31721 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31722 PyObject *resultobj = 0;
31723 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31724 int result;
31725 void *argp1 = 0 ;
31726 int res1 = 0 ;
31727 PyObject *swig_obj[1] ;
31728
31729 if (!args) SWIG_fail;
31730 swig_obj[0] = args;
31731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31732 if (!SWIG_IsOK(res1)) {
31733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31734 }
31735 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31736 {
31737 PyThreadState* __tstate = wxPyBeginAllowThreads();
31738 result = (int)(arg1)->Run();
31739 wxPyEndAllowThreads(__tstate);
31740 if (PyErr_Occurred()) SWIG_fail;
31741 }
31742 resultobj = SWIG_From_int(static_cast< int >(result));
31743 return resultobj;
31744 fail:
31745 return NULL;
31746 }
31747
31748
31749 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31750 PyObject *resultobj = 0;
31751 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31752 int arg2 = (int) 0 ;
31753 void *argp1 = 0 ;
31754 int res1 = 0 ;
31755 int val2 ;
31756 int ecode2 = 0 ;
31757 PyObject * obj0 = 0 ;
31758 PyObject * obj1 = 0 ;
31759 char * kwnames[] = {
31760 (char *) "self",(char *) "rc", NULL
31761 };
31762
31763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
31764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31765 if (!SWIG_IsOK(res1)) {
31766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31767 }
31768 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31769 if (obj1) {
31770 ecode2 = SWIG_AsVal_int(obj1, &val2);
31771 if (!SWIG_IsOK(ecode2)) {
31772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
31773 }
31774 arg2 = static_cast< int >(val2);
31775 }
31776 {
31777 PyThreadState* __tstate = wxPyBeginAllowThreads();
31778 (arg1)->Exit(arg2);
31779 wxPyEndAllowThreads(__tstate);
31780 if (PyErr_Occurred()) SWIG_fail;
31781 }
31782 resultobj = SWIG_Py_Void();
31783 return resultobj;
31784 fail:
31785 return NULL;
31786 }
31787
31788
31789 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31790 PyObject *resultobj = 0;
31791 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31792 bool result;
31793 void *argp1 = 0 ;
31794 int res1 = 0 ;
31795 PyObject *swig_obj[1] ;
31796
31797 if (!args) SWIG_fail;
31798 swig_obj[0] = args;
31799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31800 if (!SWIG_IsOK(res1)) {
31801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31802 }
31803 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31804 {
31805 PyThreadState* __tstate = wxPyBeginAllowThreads();
31806 result = (bool)((wxEventLoop const *)arg1)->Pending();
31807 wxPyEndAllowThreads(__tstate);
31808 if (PyErr_Occurred()) SWIG_fail;
31809 }
31810 {
31811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31812 }
31813 return resultobj;
31814 fail:
31815 return NULL;
31816 }
31817
31818
31819 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31820 PyObject *resultobj = 0;
31821 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31822 bool result;
31823 void *argp1 = 0 ;
31824 int res1 = 0 ;
31825 PyObject *swig_obj[1] ;
31826
31827 if (!args) SWIG_fail;
31828 swig_obj[0] = args;
31829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31830 if (!SWIG_IsOK(res1)) {
31831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31832 }
31833 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31834 {
31835 PyThreadState* __tstate = wxPyBeginAllowThreads();
31836 result = (bool)(arg1)->Dispatch();
31837 wxPyEndAllowThreads(__tstate);
31838 if (PyErr_Occurred()) SWIG_fail;
31839 }
31840 {
31841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31842 }
31843 return resultobj;
31844 fail:
31845 return NULL;
31846 }
31847
31848
31849 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31850 PyObject *resultobj = 0;
31851 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31852 bool result;
31853 void *argp1 = 0 ;
31854 int res1 = 0 ;
31855 PyObject *swig_obj[1] ;
31856
31857 if (!args) SWIG_fail;
31858 swig_obj[0] = args;
31859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31860 if (!SWIG_IsOK(res1)) {
31861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31862 }
31863 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31864 {
31865 PyThreadState* __tstate = wxPyBeginAllowThreads();
31866 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
31867 wxPyEndAllowThreads(__tstate);
31868 if (PyErr_Occurred()) SWIG_fail;
31869 }
31870 {
31871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31872 }
31873 return resultobj;
31874 fail:
31875 return NULL;
31876 }
31877
31878
31879 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31880 PyObject *resultobj = 0;
31881 wxEventLoop *result = 0 ;
31882
31883 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
31884 {
31885 PyThreadState* __tstate = wxPyBeginAllowThreads();
31886 result = (wxEventLoop *)wxEventLoop::GetActive();
31887 wxPyEndAllowThreads(__tstate);
31888 if (PyErr_Occurred()) SWIG_fail;
31889 }
31890 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
31891 return resultobj;
31892 fail:
31893 return NULL;
31894 }
31895
31896
31897 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31898 PyObject *resultobj = 0;
31899 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31900 void *argp1 = 0 ;
31901 int res1 = 0 ;
31902 PyObject * obj0 = 0 ;
31903 char * kwnames[] = {
31904 (char *) "loop", NULL
31905 };
31906
31907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
31908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31909 if (!SWIG_IsOK(res1)) {
31910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31911 }
31912 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31913 {
31914 PyThreadState* __tstate = wxPyBeginAllowThreads();
31915 wxEventLoop::SetActive(arg1);
31916 wxPyEndAllowThreads(__tstate);
31917 if (PyErr_Occurred()) SWIG_fail;
31918 }
31919 resultobj = SWIG_Py_Void();
31920 return resultobj;
31921 fail:
31922 return NULL;
31923 }
31924
31925
31926 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31927 PyObject *obj;
31928 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31929 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
31930 return SWIG_Py_Void();
31931 }
31932
31933 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31934 return SWIG_Python_InitShadowInstance(args);
31935 }
31936
31937 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31938 PyObject *resultobj = 0;
31939 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31940 wxEventLoopActivator *result = 0 ;
31941 void *argp1 = 0 ;
31942 int res1 = 0 ;
31943 PyObject * obj0 = 0 ;
31944 char * kwnames[] = {
31945 (char *) "evtLoop", NULL
31946 };
31947
31948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
31949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31950 if (!SWIG_IsOK(res1)) {
31951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31952 }
31953 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31954 {
31955 PyThreadState* __tstate = wxPyBeginAllowThreads();
31956 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
31957 wxPyEndAllowThreads(__tstate);
31958 if (PyErr_Occurred()) SWIG_fail;
31959 }
31960 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
31961 return resultobj;
31962 fail:
31963 return NULL;
31964 }
31965
31966
31967 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31968 PyObject *resultobj = 0;
31969 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
31970 void *argp1 = 0 ;
31971 int res1 = 0 ;
31972 PyObject *swig_obj[1] ;
31973
31974 if (!args) SWIG_fail;
31975 swig_obj[0] = args;
31976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
31977 if (!SWIG_IsOK(res1)) {
31978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
31979 }
31980 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
31981 {
31982 PyThreadState* __tstate = wxPyBeginAllowThreads();
31983 delete arg1;
31984
31985 wxPyEndAllowThreads(__tstate);
31986 if (PyErr_Occurred()) SWIG_fail;
31987 }
31988 resultobj = SWIG_Py_Void();
31989 return resultobj;
31990 fail:
31991 return NULL;
31992 }
31993
31994
31995 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31996 PyObject *obj;
31997 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31998 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
31999 return SWIG_Py_Void();
32000 }
32001
32002 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32003 return SWIG_Python_InitShadowInstance(args);
32004 }
32005
32006 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32007 PyObject *resultobj = 0;
32008 int arg1 = (int) 0 ;
32009 int arg2 = (int) 0 ;
32010 int arg3 = (int) 0 ;
32011 wxAcceleratorEntry *result = 0 ;
32012 int val1 ;
32013 int ecode1 = 0 ;
32014 int val2 ;
32015 int ecode2 = 0 ;
32016 int val3 ;
32017 int ecode3 = 0 ;
32018 PyObject * obj0 = 0 ;
32019 PyObject * obj1 = 0 ;
32020 PyObject * obj2 = 0 ;
32021 char * kwnames[] = {
32022 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
32023 };
32024
32025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32026 if (obj0) {
32027 ecode1 = SWIG_AsVal_int(obj0, &val1);
32028 if (!SWIG_IsOK(ecode1)) {
32029 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
32030 }
32031 arg1 = static_cast< int >(val1);
32032 }
32033 if (obj1) {
32034 ecode2 = SWIG_AsVal_int(obj1, &val2);
32035 if (!SWIG_IsOK(ecode2)) {
32036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
32037 }
32038 arg2 = static_cast< int >(val2);
32039 }
32040 if (obj2) {
32041 ecode3 = SWIG_AsVal_int(obj2, &val3);
32042 if (!SWIG_IsOK(ecode3)) {
32043 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
32044 }
32045 arg3 = static_cast< int >(val3);
32046 }
32047 {
32048 PyThreadState* __tstate = wxPyBeginAllowThreads();
32049 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
32050 wxPyEndAllowThreads(__tstate);
32051 if (PyErr_Occurred()) SWIG_fail;
32052 }
32053 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
32054 return resultobj;
32055 fail:
32056 return NULL;
32057 }
32058
32059
32060 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32061 PyObject *resultobj = 0;
32062 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32063 void *argp1 = 0 ;
32064 int res1 = 0 ;
32065 PyObject *swig_obj[1] ;
32066
32067 if (!args) SWIG_fail;
32068 swig_obj[0] = args;
32069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
32070 if (!SWIG_IsOK(res1)) {
32071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32072 }
32073 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32074 {
32075 PyThreadState* __tstate = wxPyBeginAllowThreads();
32076 delete arg1;
32077
32078 wxPyEndAllowThreads(__tstate);
32079 if (PyErr_Occurred()) SWIG_fail;
32080 }
32081 resultobj = SWIG_Py_Void();
32082 return resultobj;
32083 fail:
32084 return NULL;
32085 }
32086
32087
32088 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32089 PyObject *resultobj = 0;
32090 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32091 int arg2 ;
32092 int arg3 ;
32093 int arg4 ;
32094 void *argp1 = 0 ;
32095 int res1 = 0 ;
32096 int val2 ;
32097 int ecode2 = 0 ;
32098 int val3 ;
32099 int ecode3 = 0 ;
32100 int val4 ;
32101 int ecode4 = 0 ;
32102 PyObject * obj0 = 0 ;
32103 PyObject * obj1 = 0 ;
32104 PyObject * obj2 = 0 ;
32105 PyObject * obj3 = 0 ;
32106 char * kwnames[] = {
32107 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
32108 };
32109
32110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32112 if (!SWIG_IsOK(res1)) {
32113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32114 }
32115 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32116 ecode2 = SWIG_AsVal_int(obj1, &val2);
32117 if (!SWIG_IsOK(ecode2)) {
32118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
32119 }
32120 arg2 = static_cast< int >(val2);
32121 ecode3 = SWIG_AsVal_int(obj2, &val3);
32122 if (!SWIG_IsOK(ecode3)) {
32123 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
32124 }
32125 arg3 = static_cast< int >(val3);
32126 ecode4 = SWIG_AsVal_int(obj3, &val4);
32127 if (!SWIG_IsOK(ecode4)) {
32128 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
32129 }
32130 arg4 = static_cast< int >(val4);
32131 {
32132 PyThreadState* __tstate = wxPyBeginAllowThreads();
32133 (arg1)->Set(arg2,arg3,arg4);
32134 wxPyEndAllowThreads(__tstate);
32135 if (PyErr_Occurred()) SWIG_fail;
32136 }
32137 resultobj = SWIG_Py_Void();
32138 return resultobj;
32139 fail:
32140 return NULL;
32141 }
32142
32143
32144 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32145 PyObject *resultobj = 0;
32146 wxString *arg1 = 0 ;
32147 wxAcceleratorEntry *result = 0 ;
32148 bool temp1 = false ;
32149 PyObject * obj0 = 0 ;
32150 char * kwnames[] = {
32151 (char *) "str", NULL
32152 };
32153
32154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
32155 {
32156 arg1 = wxString_in_helper(obj0);
32157 if (arg1 == NULL) SWIG_fail;
32158 temp1 = true;
32159 }
32160 {
32161 PyThreadState* __tstate = wxPyBeginAllowThreads();
32162 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
32163 wxPyEndAllowThreads(__tstate);
32164 if (PyErr_Occurred()) SWIG_fail;
32165 }
32166 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
32167 {
32168 if (temp1)
32169 delete arg1;
32170 }
32171 return resultobj;
32172 fail:
32173 {
32174 if (temp1)
32175 delete arg1;
32176 }
32177 return NULL;
32178 }
32179
32180
32181 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32182 PyObject *resultobj = 0;
32183 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32184 int result;
32185 void *argp1 = 0 ;
32186 int res1 = 0 ;
32187 PyObject *swig_obj[1] ;
32188
32189 if (!args) SWIG_fail;
32190 swig_obj[0] = args;
32191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32192 if (!SWIG_IsOK(res1)) {
32193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32194 }
32195 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32196 {
32197 PyThreadState* __tstate = wxPyBeginAllowThreads();
32198 result = (int)(arg1)->GetFlags();
32199 wxPyEndAllowThreads(__tstate);
32200 if (PyErr_Occurred()) SWIG_fail;
32201 }
32202 resultobj = SWIG_From_int(static_cast< int >(result));
32203 return resultobj;
32204 fail:
32205 return NULL;
32206 }
32207
32208
32209 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32210 PyObject *resultobj = 0;
32211 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32212 int result;
32213 void *argp1 = 0 ;
32214 int res1 = 0 ;
32215 PyObject *swig_obj[1] ;
32216
32217 if (!args) SWIG_fail;
32218 swig_obj[0] = args;
32219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32220 if (!SWIG_IsOK(res1)) {
32221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32222 }
32223 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32224 {
32225 PyThreadState* __tstate = wxPyBeginAllowThreads();
32226 result = (int)(arg1)->GetKeyCode();
32227 wxPyEndAllowThreads(__tstate);
32228 if (PyErr_Occurred()) SWIG_fail;
32229 }
32230 resultobj = SWIG_From_int(static_cast< int >(result));
32231 return resultobj;
32232 fail:
32233 return NULL;
32234 }
32235
32236
32237 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32238 PyObject *resultobj = 0;
32239 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32240 int result;
32241 void *argp1 = 0 ;
32242 int res1 = 0 ;
32243 PyObject *swig_obj[1] ;
32244
32245 if (!args) SWIG_fail;
32246 swig_obj[0] = args;
32247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32248 if (!SWIG_IsOK(res1)) {
32249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32250 }
32251 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32252 {
32253 PyThreadState* __tstate = wxPyBeginAllowThreads();
32254 result = (int)(arg1)->GetCommand();
32255 wxPyEndAllowThreads(__tstate);
32256 if (PyErr_Occurred()) SWIG_fail;
32257 }
32258 resultobj = SWIG_From_int(static_cast< int >(result));
32259 return resultobj;
32260 fail:
32261 return NULL;
32262 }
32263
32264
32265 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32266 PyObject *resultobj = 0;
32267 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32268 bool result;
32269 void *argp1 = 0 ;
32270 int res1 = 0 ;
32271 PyObject *swig_obj[1] ;
32272
32273 if (!args) SWIG_fail;
32274 swig_obj[0] = args;
32275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32276 if (!SWIG_IsOK(res1)) {
32277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32278 }
32279 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32280 {
32281 PyThreadState* __tstate = wxPyBeginAllowThreads();
32282 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
32283 wxPyEndAllowThreads(__tstate);
32284 if (PyErr_Occurred()) SWIG_fail;
32285 }
32286 {
32287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32288 }
32289 return resultobj;
32290 fail:
32291 return NULL;
32292 }
32293
32294
32295 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32296 PyObject *resultobj = 0;
32297 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32298 wxString result;
32299 void *argp1 = 0 ;
32300 int res1 = 0 ;
32301 PyObject *swig_obj[1] ;
32302
32303 if (!args) SWIG_fail;
32304 swig_obj[0] = args;
32305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32306 if (!SWIG_IsOK(res1)) {
32307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32308 }
32309 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32310 {
32311 PyThreadState* __tstate = wxPyBeginAllowThreads();
32312 result = ((wxAcceleratorEntry const *)arg1)->ToString();
32313 wxPyEndAllowThreads(__tstate);
32314 if (PyErr_Occurred()) SWIG_fail;
32315 }
32316 {
32317 #if wxUSE_UNICODE
32318 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32319 #else
32320 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32321 #endif
32322 }
32323 return resultobj;
32324 fail:
32325 return NULL;
32326 }
32327
32328
32329 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32330 PyObject *resultobj = 0;
32331 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32332 wxString *arg2 = 0 ;
32333 bool result;
32334 void *argp1 = 0 ;
32335 int res1 = 0 ;
32336 bool temp2 = false ;
32337 PyObject * obj0 = 0 ;
32338 PyObject * obj1 = 0 ;
32339 char * kwnames[] = {
32340 (char *) "self",(char *) "str", NULL
32341 };
32342
32343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
32344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32345 if (!SWIG_IsOK(res1)) {
32346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32347 }
32348 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32349 {
32350 arg2 = wxString_in_helper(obj1);
32351 if (arg2 == NULL) SWIG_fail;
32352 temp2 = true;
32353 }
32354 {
32355 PyThreadState* __tstate = wxPyBeginAllowThreads();
32356 result = (bool)(arg1)->FromString((wxString const &)*arg2);
32357 wxPyEndAllowThreads(__tstate);
32358 if (PyErr_Occurred()) SWIG_fail;
32359 }
32360 {
32361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32362 }
32363 {
32364 if (temp2)
32365 delete arg2;
32366 }
32367 return resultobj;
32368 fail:
32369 {
32370 if (temp2)
32371 delete arg2;
32372 }
32373 return NULL;
32374 }
32375
32376
32377 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32378 PyObject *obj;
32379 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32380 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
32381 return SWIG_Py_Void();
32382 }
32383
32384 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32385 return SWIG_Python_InitShadowInstance(args);
32386 }
32387
32388 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32389 PyObject *resultobj = 0;
32390 int arg1 ;
32391 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
32392 wxAcceleratorTable *result = 0 ;
32393 PyObject * obj0 = 0 ;
32394 char * kwnames[] = {
32395 (char *) "n", NULL
32396 };
32397
32398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
32399 {
32400 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
32401 if (arg2) arg1 = PyList_Size(obj0);
32402 else arg1 = 0;
32403 }
32404 {
32405 PyThreadState* __tstate = wxPyBeginAllowThreads();
32406 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
32407 wxPyEndAllowThreads(__tstate);
32408 if (PyErr_Occurred()) SWIG_fail;
32409 }
32410 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
32411 return resultobj;
32412 fail:
32413 return NULL;
32414 }
32415
32416
32417 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32418 PyObject *resultobj = 0;
32419 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32420 void *argp1 = 0 ;
32421 int res1 = 0 ;
32422 PyObject *swig_obj[1] ;
32423
32424 if (!args) SWIG_fail;
32425 swig_obj[0] = args;
32426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
32427 if (!SWIG_IsOK(res1)) {
32428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
32429 }
32430 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32431 {
32432 PyThreadState* __tstate = wxPyBeginAllowThreads();
32433 delete arg1;
32434
32435 wxPyEndAllowThreads(__tstate);
32436 if (PyErr_Occurred()) SWIG_fail;
32437 }
32438 resultobj = SWIG_Py_Void();
32439 return resultobj;
32440 fail:
32441 return NULL;
32442 }
32443
32444
32445 SWIGINTERN PyObject *_wrap_AcceleratorTable_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32446 PyObject *resultobj = 0;
32447 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32448 bool result;
32449 void *argp1 = 0 ;
32450 int res1 = 0 ;
32451 PyObject *swig_obj[1] ;
32452
32453 if (!args) SWIG_fail;
32454 swig_obj[0] = args;
32455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
32456 if (!SWIG_IsOK(res1)) {
32457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
32458 }
32459 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32460 {
32461 PyThreadState* __tstate = wxPyBeginAllowThreads();
32462 result = (bool)((wxAcceleratorTable const *)arg1)->IsOk();
32463 wxPyEndAllowThreads(__tstate);
32464 if (PyErr_Occurred()) SWIG_fail;
32465 }
32466 {
32467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32468 }
32469 return resultobj;
32470 fail:
32471 return NULL;
32472 }
32473
32474
32475 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32476 PyObject *obj;
32477 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32478 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
32479 return SWIG_Py_Void();
32480 }
32481
32482 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32483 return SWIG_Python_InitShadowInstance(args);
32484 }
32485
32486 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
32487 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
32488 return 1;
32489 }
32490
32491
32492 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
32493 PyObject *pyobj = 0;
32494
32495 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
32496 return pyobj;
32497 }
32498
32499
32500 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32501 PyObject *resultobj = 0;
32502 wxString *arg1 = 0 ;
32503 wxAcceleratorEntry *result = 0 ;
32504 bool temp1 = false ;
32505 PyObject * obj0 = 0 ;
32506 char * kwnames[] = {
32507 (char *) "label", NULL
32508 };
32509
32510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
32511 {
32512 arg1 = wxString_in_helper(obj0);
32513 if (arg1 == NULL) SWIG_fail;
32514 temp1 = true;
32515 }
32516 {
32517 PyThreadState* __tstate = wxPyBeginAllowThreads();
32518 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
32519 wxPyEndAllowThreads(__tstate);
32520 if (PyErr_Occurred()) SWIG_fail;
32521 }
32522 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32523 {
32524 if (temp1)
32525 delete arg1;
32526 }
32527 return resultobj;
32528 fail:
32529 {
32530 if (temp1)
32531 delete arg1;
32532 }
32533 return NULL;
32534 }
32535
32536
32537 SWIGINTERN int PanelNameStr_set(PyObject *) {
32538 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
32539 return 1;
32540 }
32541
32542
32543 SWIGINTERN PyObject *PanelNameStr_get(void) {
32544 PyObject *pyobj = 0;
32545
32546 {
32547 #if wxUSE_UNICODE
32548 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32549 #else
32550 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32551 #endif
32552 }
32553 return pyobj;
32554 }
32555
32556
32557 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32558 PyObject *resultobj = 0;
32559 wxVisualAttributes *result = 0 ;
32560
32561 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
32562 {
32563 PyThreadState* __tstate = wxPyBeginAllowThreads();
32564 result = (wxVisualAttributes *)new_wxVisualAttributes();
32565 wxPyEndAllowThreads(__tstate);
32566 if (PyErr_Occurred()) SWIG_fail;
32567 }
32568 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
32569 return resultobj;
32570 fail:
32571 return NULL;
32572 }
32573
32574
32575 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32576 PyObject *resultobj = 0;
32577 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32578 void *argp1 = 0 ;
32579 int res1 = 0 ;
32580 PyObject *swig_obj[1] ;
32581
32582 if (!args) SWIG_fail;
32583 swig_obj[0] = args;
32584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
32585 if (!SWIG_IsOK(res1)) {
32586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32587 }
32588 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32589 {
32590 PyThreadState* __tstate = wxPyBeginAllowThreads();
32591 delete_wxVisualAttributes(arg1);
32592
32593 wxPyEndAllowThreads(__tstate);
32594 if (PyErr_Occurred()) SWIG_fail;
32595 }
32596 resultobj = SWIG_Py_Void();
32597 return resultobj;
32598 fail:
32599 return NULL;
32600 }
32601
32602
32603 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32604 PyObject *resultobj = 0;
32605 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32606 wxFont *arg2 = (wxFont *) 0 ;
32607 void *argp1 = 0 ;
32608 int res1 = 0 ;
32609 void *argp2 = 0 ;
32610 int res2 = 0 ;
32611 PyObject *swig_obj[2] ;
32612
32613 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
32614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32615 if (!SWIG_IsOK(res1)) {
32616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32617 }
32618 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32619 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
32620 if (!SWIG_IsOK(res2)) {
32621 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
32622 }
32623 arg2 = reinterpret_cast< wxFont * >(argp2);
32624 if (arg1) (arg1)->font = *arg2;
32625
32626 resultobj = SWIG_Py_Void();
32627 return resultobj;
32628 fail:
32629 return NULL;
32630 }
32631
32632
32633 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32634 PyObject *resultobj = 0;
32635 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32636 wxFont *result = 0 ;
32637 void *argp1 = 0 ;
32638 int res1 = 0 ;
32639 PyObject *swig_obj[1] ;
32640
32641 if (!args) SWIG_fail;
32642 swig_obj[0] = args;
32643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32644 if (!SWIG_IsOK(res1)) {
32645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32646 }
32647 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32648 result = (wxFont *)& ((arg1)->font);
32649 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
32650 return resultobj;
32651 fail:
32652 return NULL;
32653 }
32654
32655
32656 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32657 PyObject *resultobj = 0;
32658 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32659 wxColour *arg2 = (wxColour *) 0 ;
32660 void *argp1 = 0 ;
32661 int res1 = 0 ;
32662 void *argp2 = 0 ;
32663 int res2 = 0 ;
32664 PyObject *swig_obj[2] ;
32665
32666 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
32667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32668 if (!SWIG_IsOK(res1)) {
32669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32670 }
32671 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32672 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32673 if (!SWIG_IsOK(res2)) {
32674 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32675 }
32676 arg2 = reinterpret_cast< wxColour * >(argp2);
32677 if (arg1) (arg1)->colFg = *arg2;
32678
32679 resultobj = SWIG_Py_Void();
32680 return resultobj;
32681 fail:
32682 return NULL;
32683 }
32684
32685
32686 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32687 PyObject *resultobj = 0;
32688 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32689 wxColour *result = 0 ;
32690 void *argp1 = 0 ;
32691 int res1 = 0 ;
32692 PyObject *swig_obj[1] ;
32693
32694 if (!args) SWIG_fail;
32695 swig_obj[0] = args;
32696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32697 if (!SWIG_IsOK(res1)) {
32698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32699 }
32700 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32701 result = (wxColour *)& ((arg1)->colFg);
32702 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32703 return resultobj;
32704 fail:
32705 return NULL;
32706 }
32707
32708
32709 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32710 PyObject *resultobj = 0;
32711 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32712 wxColour *arg2 = (wxColour *) 0 ;
32713 void *argp1 = 0 ;
32714 int res1 = 0 ;
32715 void *argp2 = 0 ;
32716 int res2 = 0 ;
32717 PyObject *swig_obj[2] ;
32718
32719 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
32720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32721 if (!SWIG_IsOK(res1)) {
32722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32723 }
32724 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32725 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32726 if (!SWIG_IsOK(res2)) {
32727 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32728 }
32729 arg2 = reinterpret_cast< wxColour * >(argp2);
32730 if (arg1) (arg1)->colBg = *arg2;
32731
32732 resultobj = SWIG_Py_Void();
32733 return resultobj;
32734 fail:
32735 return NULL;
32736 }
32737
32738
32739 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32740 PyObject *resultobj = 0;
32741 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32742 wxColour *result = 0 ;
32743 void *argp1 = 0 ;
32744 int res1 = 0 ;
32745 PyObject *swig_obj[1] ;
32746
32747 if (!args) SWIG_fail;
32748 swig_obj[0] = args;
32749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32750 if (!SWIG_IsOK(res1)) {
32751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32752 }
32753 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32754 result = (wxColour *)& ((arg1)->colBg);
32755 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32756 return resultobj;
32757 fail:
32758 return NULL;
32759 }
32760
32761
32762 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32763 PyObject *obj;
32764 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32765 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
32766 return SWIG_Py_Void();
32767 }
32768
32769 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32770 return SWIG_Python_InitShadowInstance(args);
32771 }
32772
32773 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32774 PyObject *resultobj = 0;
32775 wxWindow *arg1 = (wxWindow *) 0 ;
32776 int arg2 = (int) (int)-1 ;
32777 wxPoint const &arg3_defvalue = wxDefaultPosition ;
32778 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
32779 wxSize const &arg4_defvalue = wxDefaultSize ;
32780 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32781 long arg5 = (long) 0 ;
32782 wxString const &arg6_defvalue = wxPyPanelNameStr ;
32783 wxString *arg6 = (wxString *) &arg6_defvalue ;
32784 wxWindow *result = 0 ;
32785 void *argp1 = 0 ;
32786 int res1 = 0 ;
32787 int val2 ;
32788 int ecode2 = 0 ;
32789 wxPoint temp3 ;
32790 wxSize temp4 ;
32791 long val5 ;
32792 int ecode5 = 0 ;
32793 bool temp6 = false ;
32794 PyObject * obj0 = 0 ;
32795 PyObject * obj1 = 0 ;
32796 PyObject * obj2 = 0 ;
32797 PyObject * obj3 = 0 ;
32798 PyObject * obj4 = 0 ;
32799 PyObject * obj5 = 0 ;
32800 char * kwnames[] = {
32801 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32802 };
32803
32804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
32805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32806 if (!SWIG_IsOK(res1)) {
32807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
32808 }
32809 arg1 = reinterpret_cast< wxWindow * >(argp1);
32810 if (obj1) {
32811 ecode2 = SWIG_AsVal_int(obj1, &val2);
32812 if (!SWIG_IsOK(ecode2)) {
32813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
32814 }
32815 arg2 = static_cast< int >(val2);
32816 }
32817 if (obj2) {
32818 {
32819 arg3 = &temp3;
32820 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
32821 }
32822 }
32823 if (obj3) {
32824 {
32825 arg4 = &temp4;
32826 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32827 }
32828 }
32829 if (obj4) {
32830 ecode5 = SWIG_AsVal_long(obj4, &val5);
32831 if (!SWIG_IsOK(ecode5)) {
32832 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
32833 }
32834 arg5 = static_cast< long >(val5);
32835 }
32836 if (obj5) {
32837 {
32838 arg6 = wxString_in_helper(obj5);
32839 if (arg6 == NULL) SWIG_fail;
32840 temp6 = true;
32841 }
32842 }
32843 {
32844 if (!wxPyCheckForApp()) SWIG_fail;
32845 PyThreadState* __tstate = wxPyBeginAllowThreads();
32846 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
32847 wxPyEndAllowThreads(__tstate);
32848 if (PyErr_Occurred()) SWIG_fail;
32849 }
32850 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
32851 {
32852 if (temp6)
32853 delete arg6;
32854 }
32855 return resultobj;
32856 fail:
32857 {
32858 if (temp6)
32859 delete arg6;
32860 }
32861 return NULL;
32862 }
32863
32864
32865 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32866 PyObject *resultobj = 0;
32867 wxWindow *result = 0 ;
32868
32869 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
32870 {
32871 if (!wxPyCheckForApp()) SWIG_fail;
32872 PyThreadState* __tstate = wxPyBeginAllowThreads();
32873 result = (wxWindow *)new wxWindow();
32874 wxPyEndAllowThreads(__tstate);
32875 if (PyErr_Occurred()) SWIG_fail;
32876 }
32877 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
32878 return resultobj;
32879 fail:
32880 return NULL;
32881 }
32882
32883
32884 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32885 PyObject *resultobj = 0;
32886 wxWindow *arg1 = (wxWindow *) 0 ;
32887 wxWindow *arg2 = (wxWindow *) 0 ;
32888 int arg3 = (int) (int)-1 ;
32889 wxPoint const &arg4_defvalue = wxDefaultPosition ;
32890 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
32891 wxSize const &arg5_defvalue = wxDefaultSize ;
32892 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
32893 long arg6 = (long) 0 ;
32894 wxString const &arg7_defvalue = wxPyPanelNameStr ;
32895 wxString *arg7 = (wxString *) &arg7_defvalue ;
32896 bool result;
32897 void *argp1 = 0 ;
32898 int res1 = 0 ;
32899 void *argp2 = 0 ;
32900 int res2 = 0 ;
32901 int val3 ;
32902 int ecode3 = 0 ;
32903 wxPoint temp4 ;
32904 wxSize temp5 ;
32905 long val6 ;
32906 int ecode6 = 0 ;
32907 bool temp7 = false ;
32908 PyObject * obj0 = 0 ;
32909 PyObject * obj1 = 0 ;
32910 PyObject * obj2 = 0 ;
32911 PyObject * obj3 = 0 ;
32912 PyObject * obj4 = 0 ;
32913 PyObject * obj5 = 0 ;
32914 PyObject * obj6 = 0 ;
32915 char * kwnames[] = {
32916 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32917 };
32918
32919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32921 if (!SWIG_IsOK(res1)) {
32922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
32923 }
32924 arg1 = reinterpret_cast< wxWindow * >(argp1);
32925 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32926 if (!SWIG_IsOK(res2)) {
32927 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
32928 }
32929 arg2 = reinterpret_cast< wxWindow * >(argp2);
32930 if (obj2) {
32931 ecode3 = SWIG_AsVal_int(obj2, &val3);
32932 if (!SWIG_IsOK(ecode3)) {
32933 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
32934 }
32935 arg3 = static_cast< int >(val3);
32936 }
32937 if (obj3) {
32938 {
32939 arg4 = &temp4;
32940 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
32941 }
32942 }
32943 if (obj4) {
32944 {
32945 arg5 = &temp5;
32946 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
32947 }
32948 }
32949 if (obj5) {
32950 ecode6 = SWIG_AsVal_long(obj5, &val6);
32951 if (!SWIG_IsOK(ecode6)) {
32952 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
32953 }
32954 arg6 = static_cast< long >(val6);
32955 }
32956 if (obj6) {
32957 {
32958 arg7 = wxString_in_helper(obj6);
32959 if (arg7 == NULL) SWIG_fail;
32960 temp7 = true;
32961 }
32962 }
32963 {
32964 PyThreadState* __tstate = wxPyBeginAllowThreads();
32965 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
32966 wxPyEndAllowThreads(__tstate);
32967 if (PyErr_Occurred()) SWIG_fail;
32968 }
32969 {
32970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32971 }
32972 {
32973 if (temp7)
32974 delete arg7;
32975 }
32976 return resultobj;
32977 fail:
32978 {
32979 if (temp7)
32980 delete arg7;
32981 }
32982 return NULL;
32983 }
32984
32985
32986 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32987 PyObject *resultobj = 0;
32988 wxWindow *arg1 = (wxWindow *) 0 ;
32989 bool arg2 = (bool) false ;
32990 bool result;
32991 void *argp1 = 0 ;
32992 int res1 = 0 ;
32993 bool val2 ;
32994 int ecode2 = 0 ;
32995 PyObject * obj0 = 0 ;
32996 PyObject * obj1 = 0 ;
32997 char * kwnames[] = {
32998 (char *) "self",(char *) "force", NULL
32999 };
33000
33001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
33002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33003 if (!SWIG_IsOK(res1)) {
33004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
33005 }
33006 arg1 = reinterpret_cast< wxWindow * >(argp1);
33007 if (obj1) {
33008 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33009 if (!SWIG_IsOK(ecode2)) {
33010 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
33011 }
33012 arg2 = static_cast< bool >(val2);
33013 }
33014 {
33015 PyThreadState* __tstate = wxPyBeginAllowThreads();
33016 result = (bool)(arg1)->Close(arg2);
33017 wxPyEndAllowThreads(__tstate);
33018 if (PyErr_Occurred()) SWIG_fail;
33019 }
33020 {
33021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33022 }
33023 return resultobj;
33024 fail:
33025 return NULL;
33026 }
33027
33028
33029 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33030 PyObject *resultobj = 0;
33031 wxWindow *arg1 = (wxWindow *) 0 ;
33032 bool result;
33033 void *argp1 = 0 ;
33034 int res1 = 0 ;
33035 PyObject *swig_obj[1] ;
33036
33037 if (!args) SWIG_fail;
33038 swig_obj[0] = args;
33039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33040 if (!SWIG_IsOK(res1)) {
33041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
33042 }
33043 arg1 = reinterpret_cast< wxWindow * >(argp1);
33044 {
33045 PyThreadState* __tstate = wxPyBeginAllowThreads();
33046 result = (bool)(arg1)->Destroy();
33047 wxPyEndAllowThreads(__tstate);
33048 if (PyErr_Occurred()) SWIG_fail;
33049 }
33050 {
33051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33052 }
33053 return resultobj;
33054 fail:
33055 return NULL;
33056 }
33057
33058
33059 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33060 PyObject *resultobj = 0;
33061 wxWindow *arg1 = (wxWindow *) 0 ;
33062 bool result;
33063 void *argp1 = 0 ;
33064 int res1 = 0 ;
33065 PyObject *swig_obj[1] ;
33066
33067 if (!args) SWIG_fail;
33068 swig_obj[0] = args;
33069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33070 if (!SWIG_IsOK(res1)) {
33071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33072 }
33073 arg1 = reinterpret_cast< wxWindow * >(argp1);
33074 {
33075 PyThreadState* __tstate = wxPyBeginAllowThreads();
33076 result = (bool)(arg1)->DestroyChildren();
33077 wxPyEndAllowThreads(__tstate);
33078 if (PyErr_Occurred()) SWIG_fail;
33079 }
33080 {
33081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33082 }
33083 return resultobj;
33084 fail:
33085 return NULL;
33086 }
33087
33088
33089 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33090 PyObject *resultobj = 0;
33091 wxWindow *arg1 = (wxWindow *) 0 ;
33092 bool result;
33093 void *argp1 = 0 ;
33094 int res1 = 0 ;
33095 PyObject *swig_obj[1] ;
33096
33097 if (!args) SWIG_fail;
33098 swig_obj[0] = args;
33099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33100 if (!SWIG_IsOK(res1)) {
33101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
33102 }
33103 arg1 = reinterpret_cast< wxWindow * >(argp1);
33104 {
33105 PyThreadState* __tstate = wxPyBeginAllowThreads();
33106 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
33107 wxPyEndAllowThreads(__tstate);
33108 if (PyErr_Occurred()) SWIG_fail;
33109 }
33110 {
33111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33112 }
33113 return resultobj;
33114 fail:
33115 return NULL;
33116 }
33117
33118
33119 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33120 PyObject *resultobj = 0;
33121 wxWindow *arg1 = (wxWindow *) 0 ;
33122 wxString *arg2 = 0 ;
33123 void *argp1 = 0 ;
33124 int res1 = 0 ;
33125 bool temp2 = false ;
33126 PyObject * obj0 = 0 ;
33127 PyObject * obj1 = 0 ;
33128 char * kwnames[] = {
33129 (char *) "self",(char *) "label", NULL
33130 };
33131
33132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
33133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33134 if (!SWIG_IsOK(res1)) {
33135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
33136 }
33137 arg1 = reinterpret_cast< wxWindow * >(argp1);
33138 {
33139 arg2 = wxString_in_helper(obj1);
33140 if (arg2 == NULL) SWIG_fail;
33141 temp2 = true;
33142 }
33143 {
33144 PyThreadState* __tstate = wxPyBeginAllowThreads();
33145 (arg1)->SetLabel((wxString const &)*arg2);
33146 wxPyEndAllowThreads(__tstate);
33147 if (PyErr_Occurred()) SWIG_fail;
33148 }
33149 resultobj = SWIG_Py_Void();
33150 {
33151 if (temp2)
33152 delete arg2;
33153 }
33154 return resultobj;
33155 fail:
33156 {
33157 if (temp2)
33158 delete arg2;
33159 }
33160 return NULL;
33161 }
33162
33163
33164 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33165 PyObject *resultobj = 0;
33166 wxWindow *arg1 = (wxWindow *) 0 ;
33167 wxString result;
33168 void *argp1 = 0 ;
33169 int res1 = 0 ;
33170 PyObject *swig_obj[1] ;
33171
33172 if (!args) SWIG_fail;
33173 swig_obj[0] = args;
33174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33175 if (!SWIG_IsOK(res1)) {
33176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33177 }
33178 arg1 = reinterpret_cast< wxWindow * >(argp1);
33179 {
33180 PyThreadState* __tstate = wxPyBeginAllowThreads();
33181 result = ((wxWindow const *)arg1)->GetLabel();
33182 wxPyEndAllowThreads(__tstate);
33183 if (PyErr_Occurred()) SWIG_fail;
33184 }
33185 {
33186 #if wxUSE_UNICODE
33187 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33188 #else
33189 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33190 #endif
33191 }
33192 return resultobj;
33193 fail:
33194 return NULL;
33195 }
33196
33197
33198 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33199 PyObject *resultobj = 0;
33200 wxWindow *arg1 = (wxWindow *) 0 ;
33201 wxString *arg2 = 0 ;
33202 void *argp1 = 0 ;
33203 int res1 = 0 ;
33204 bool temp2 = false ;
33205 PyObject * obj0 = 0 ;
33206 PyObject * obj1 = 0 ;
33207 char * kwnames[] = {
33208 (char *) "self",(char *) "name", NULL
33209 };
33210
33211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
33212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33213 if (!SWIG_IsOK(res1)) {
33214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
33215 }
33216 arg1 = reinterpret_cast< wxWindow * >(argp1);
33217 {
33218 arg2 = wxString_in_helper(obj1);
33219 if (arg2 == NULL) SWIG_fail;
33220 temp2 = true;
33221 }
33222 {
33223 PyThreadState* __tstate = wxPyBeginAllowThreads();
33224 (arg1)->SetName((wxString const &)*arg2);
33225 wxPyEndAllowThreads(__tstate);
33226 if (PyErr_Occurred()) SWIG_fail;
33227 }
33228 resultobj = SWIG_Py_Void();
33229 {
33230 if (temp2)
33231 delete arg2;
33232 }
33233 return resultobj;
33234 fail:
33235 {
33236 if (temp2)
33237 delete arg2;
33238 }
33239 return NULL;
33240 }
33241
33242
33243 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33244 PyObject *resultobj = 0;
33245 wxWindow *arg1 = (wxWindow *) 0 ;
33246 wxString result;
33247 void *argp1 = 0 ;
33248 int res1 = 0 ;
33249 PyObject *swig_obj[1] ;
33250
33251 if (!args) SWIG_fail;
33252 swig_obj[0] = args;
33253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33254 if (!SWIG_IsOK(res1)) {
33255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
33256 }
33257 arg1 = reinterpret_cast< wxWindow * >(argp1);
33258 {
33259 PyThreadState* __tstate = wxPyBeginAllowThreads();
33260 result = ((wxWindow const *)arg1)->GetName();
33261 wxPyEndAllowThreads(__tstate);
33262 if (PyErr_Occurred()) SWIG_fail;
33263 }
33264 {
33265 #if wxUSE_UNICODE
33266 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33267 #else
33268 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33269 #endif
33270 }
33271 return resultobj;
33272 fail:
33273 return NULL;
33274 }
33275
33276
33277 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33278 PyObject *resultobj = 0;
33279 wxWindow *arg1 = (wxWindow *) 0 ;
33280 wxWindowVariant arg2 ;
33281 void *argp1 = 0 ;
33282 int res1 = 0 ;
33283 int val2 ;
33284 int ecode2 = 0 ;
33285 PyObject * obj0 = 0 ;
33286 PyObject * obj1 = 0 ;
33287 char * kwnames[] = {
33288 (char *) "self",(char *) "variant", NULL
33289 };
33290
33291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
33292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33293 if (!SWIG_IsOK(res1)) {
33294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
33295 }
33296 arg1 = reinterpret_cast< wxWindow * >(argp1);
33297 ecode2 = SWIG_AsVal_int(obj1, &val2);
33298 if (!SWIG_IsOK(ecode2)) {
33299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
33300 }
33301 arg2 = static_cast< wxWindowVariant >(val2);
33302 {
33303 PyThreadState* __tstate = wxPyBeginAllowThreads();
33304 (arg1)->SetWindowVariant(arg2);
33305 wxPyEndAllowThreads(__tstate);
33306 if (PyErr_Occurred()) SWIG_fail;
33307 }
33308 resultobj = SWIG_Py_Void();
33309 return resultobj;
33310 fail:
33311 return NULL;
33312 }
33313
33314
33315 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33316 PyObject *resultobj = 0;
33317 wxWindow *arg1 = (wxWindow *) 0 ;
33318 wxWindowVariant result;
33319 void *argp1 = 0 ;
33320 int res1 = 0 ;
33321 PyObject *swig_obj[1] ;
33322
33323 if (!args) SWIG_fail;
33324 swig_obj[0] = args;
33325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33326 if (!SWIG_IsOK(res1)) {
33327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
33328 }
33329 arg1 = reinterpret_cast< wxWindow * >(argp1);
33330 {
33331 PyThreadState* __tstate = wxPyBeginAllowThreads();
33332 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
33333 wxPyEndAllowThreads(__tstate);
33334 if (PyErr_Occurred()) SWIG_fail;
33335 }
33336 resultobj = SWIG_From_int(static_cast< int >(result));
33337 return resultobj;
33338 fail:
33339 return NULL;
33340 }
33341
33342
33343 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33344 PyObject *resultobj = 0;
33345 wxWindow *arg1 = (wxWindow *) 0 ;
33346 int arg2 ;
33347 void *argp1 = 0 ;
33348 int res1 = 0 ;
33349 int val2 ;
33350 int ecode2 = 0 ;
33351 PyObject * obj0 = 0 ;
33352 PyObject * obj1 = 0 ;
33353 char * kwnames[] = {
33354 (char *) "self",(char *) "winid", NULL
33355 };
33356
33357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
33358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33359 if (!SWIG_IsOK(res1)) {
33360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
33361 }
33362 arg1 = reinterpret_cast< wxWindow * >(argp1);
33363 ecode2 = SWIG_AsVal_int(obj1, &val2);
33364 if (!SWIG_IsOK(ecode2)) {
33365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
33366 }
33367 arg2 = static_cast< int >(val2);
33368 {
33369 PyThreadState* __tstate = wxPyBeginAllowThreads();
33370 (arg1)->SetId(arg2);
33371 wxPyEndAllowThreads(__tstate);
33372 if (PyErr_Occurred()) SWIG_fail;
33373 }
33374 resultobj = SWIG_Py_Void();
33375 return resultobj;
33376 fail:
33377 return NULL;
33378 }
33379
33380
33381 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33382 PyObject *resultobj = 0;
33383 wxWindow *arg1 = (wxWindow *) 0 ;
33384 int result;
33385 void *argp1 = 0 ;
33386 int res1 = 0 ;
33387 PyObject *swig_obj[1] ;
33388
33389 if (!args) SWIG_fail;
33390 swig_obj[0] = args;
33391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33392 if (!SWIG_IsOK(res1)) {
33393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
33394 }
33395 arg1 = reinterpret_cast< wxWindow * >(argp1);
33396 {
33397 PyThreadState* __tstate = wxPyBeginAllowThreads();
33398 result = (int)((wxWindow const *)arg1)->GetId();
33399 wxPyEndAllowThreads(__tstate);
33400 if (PyErr_Occurred()) SWIG_fail;
33401 }
33402 resultobj = SWIG_From_int(static_cast< int >(result));
33403 return resultobj;
33404 fail:
33405 return NULL;
33406 }
33407
33408
33409 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33410 PyObject *resultobj = 0;
33411 int result;
33412
33413 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
33414 {
33415 PyThreadState* __tstate = wxPyBeginAllowThreads();
33416 result = (int)wxWindow::NewControlId();
33417 wxPyEndAllowThreads(__tstate);
33418 if (PyErr_Occurred()) SWIG_fail;
33419 }
33420 resultobj = SWIG_From_int(static_cast< int >(result));
33421 return resultobj;
33422 fail:
33423 return NULL;
33424 }
33425
33426
33427 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33428 PyObject *resultobj = 0;
33429 int arg1 ;
33430 int result;
33431 int val1 ;
33432 int ecode1 = 0 ;
33433 PyObject * obj0 = 0 ;
33434 char * kwnames[] = {
33435 (char *) "winid", NULL
33436 };
33437
33438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
33439 ecode1 = SWIG_AsVal_int(obj0, &val1);
33440 if (!SWIG_IsOK(ecode1)) {
33441 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
33442 }
33443 arg1 = static_cast< int >(val1);
33444 {
33445 PyThreadState* __tstate = wxPyBeginAllowThreads();
33446 result = (int)wxWindow::NextControlId(arg1);
33447 wxPyEndAllowThreads(__tstate);
33448 if (PyErr_Occurred()) SWIG_fail;
33449 }
33450 resultobj = SWIG_From_int(static_cast< int >(result));
33451 return resultobj;
33452 fail:
33453 return NULL;
33454 }
33455
33456
33457 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33458 PyObject *resultobj = 0;
33459 int arg1 ;
33460 int result;
33461 int val1 ;
33462 int ecode1 = 0 ;
33463 PyObject * obj0 = 0 ;
33464 char * kwnames[] = {
33465 (char *) "winid", NULL
33466 };
33467
33468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
33469 ecode1 = SWIG_AsVal_int(obj0, &val1);
33470 if (!SWIG_IsOK(ecode1)) {
33471 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
33472 }
33473 arg1 = static_cast< int >(val1);
33474 {
33475 PyThreadState* __tstate = wxPyBeginAllowThreads();
33476 result = (int)wxWindow::PrevControlId(arg1);
33477 wxPyEndAllowThreads(__tstate);
33478 if (PyErr_Occurred()) SWIG_fail;
33479 }
33480 resultobj = SWIG_From_int(static_cast< int >(result));
33481 return resultobj;
33482 fail:
33483 return NULL;
33484 }
33485
33486
33487 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33488 PyObject *resultobj = 0;
33489 wxWindow *arg1 = (wxWindow *) 0 ;
33490 wxLayoutDirection result;
33491 void *argp1 = 0 ;
33492 int res1 = 0 ;
33493 PyObject *swig_obj[1] ;
33494
33495 if (!args) SWIG_fail;
33496 swig_obj[0] = args;
33497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33498 if (!SWIG_IsOK(res1)) {
33499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33500 }
33501 arg1 = reinterpret_cast< wxWindow * >(argp1);
33502 {
33503 PyThreadState* __tstate = wxPyBeginAllowThreads();
33504 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
33505 wxPyEndAllowThreads(__tstate);
33506 if (PyErr_Occurred()) SWIG_fail;
33507 }
33508 resultobj = SWIG_From_int(static_cast< int >(result));
33509 return resultobj;
33510 fail:
33511 return NULL;
33512 }
33513
33514
33515 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33516 PyObject *resultobj = 0;
33517 wxWindow *arg1 = (wxWindow *) 0 ;
33518 wxLayoutDirection arg2 ;
33519 void *argp1 = 0 ;
33520 int res1 = 0 ;
33521 int val2 ;
33522 int ecode2 = 0 ;
33523 PyObject * obj0 = 0 ;
33524 PyObject * obj1 = 0 ;
33525 char * kwnames[] = {
33526 (char *) "self",(char *) "dir", NULL
33527 };
33528
33529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
33530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33531 if (!SWIG_IsOK(res1)) {
33532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
33533 }
33534 arg1 = reinterpret_cast< wxWindow * >(argp1);
33535 ecode2 = SWIG_AsVal_int(obj1, &val2);
33536 if (!SWIG_IsOK(ecode2)) {
33537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
33538 }
33539 arg2 = static_cast< wxLayoutDirection >(val2);
33540 {
33541 PyThreadState* __tstate = wxPyBeginAllowThreads();
33542 (arg1)->SetLayoutDirection(arg2);
33543 wxPyEndAllowThreads(__tstate);
33544 if (PyErr_Occurred()) SWIG_fail;
33545 }
33546 resultobj = SWIG_Py_Void();
33547 return resultobj;
33548 fail:
33549 return NULL;
33550 }
33551
33552
33553 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33554 PyObject *resultobj = 0;
33555 wxWindow *arg1 = (wxWindow *) 0 ;
33556 int arg2 ;
33557 int arg3 ;
33558 int arg4 ;
33559 int result;
33560 void *argp1 = 0 ;
33561 int res1 = 0 ;
33562 int val2 ;
33563 int ecode2 = 0 ;
33564 int val3 ;
33565 int ecode3 = 0 ;
33566 int val4 ;
33567 int ecode4 = 0 ;
33568 PyObject * obj0 = 0 ;
33569 PyObject * obj1 = 0 ;
33570 PyObject * obj2 = 0 ;
33571 PyObject * obj3 = 0 ;
33572 char * kwnames[] = {
33573 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
33574 };
33575
33576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33578 if (!SWIG_IsOK(res1)) {
33579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33580 }
33581 arg1 = reinterpret_cast< wxWindow * >(argp1);
33582 ecode2 = SWIG_AsVal_int(obj1, &val2);
33583 if (!SWIG_IsOK(ecode2)) {
33584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
33585 }
33586 arg2 = static_cast< int >(val2);
33587 ecode3 = SWIG_AsVal_int(obj2, &val3);
33588 if (!SWIG_IsOK(ecode3)) {
33589 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
33590 }
33591 arg3 = static_cast< int >(val3);
33592 ecode4 = SWIG_AsVal_int(obj3, &val4);
33593 if (!SWIG_IsOK(ecode4)) {
33594 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
33595 }
33596 arg4 = static_cast< int >(val4);
33597 {
33598 PyThreadState* __tstate = wxPyBeginAllowThreads();
33599 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
33600 wxPyEndAllowThreads(__tstate);
33601 if (PyErr_Occurred()) SWIG_fail;
33602 }
33603 resultobj = SWIG_From_int(static_cast< int >(result));
33604 return resultobj;
33605 fail:
33606 return NULL;
33607 }
33608
33609
33610 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33611 PyObject *resultobj = 0;
33612 wxWindow *arg1 = (wxWindow *) 0 ;
33613 wxSize *arg2 = 0 ;
33614 void *argp1 = 0 ;
33615 int res1 = 0 ;
33616 wxSize temp2 ;
33617 PyObject * obj0 = 0 ;
33618 PyObject * obj1 = 0 ;
33619 char * kwnames[] = {
33620 (char *) "self",(char *) "size", NULL
33621 };
33622
33623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
33624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33625 if (!SWIG_IsOK(res1)) {
33626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33627 }
33628 arg1 = reinterpret_cast< wxWindow * >(argp1);
33629 {
33630 arg2 = &temp2;
33631 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33632 }
33633 {
33634 PyThreadState* __tstate = wxPyBeginAllowThreads();
33635 (arg1)->SetSize((wxSize const &)*arg2);
33636 wxPyEndAllowThreads(__tstate);
33637 if (PyErr_Occurred()) SWIG_fail;
33638 }
33639 resultobj = SWIG_Py_Void();
33640 return resultobj;
33641 fail:
33642 return NULL;
33643 }
33644
33645
33646 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33647 PyObject *resultobj = 0;
33648 wxWindow *arg1 = (wxWindow *) 0 ;
33649 int arg2 ;
33650 int arg3 ;
33651 int arg4 ;
33652 int arg5 ;
33653 int arg6 = (int) wxSIZE_AUTO ;
33654 void *argp1 = 0 ;
33655 int res1 = 0 ;
33656 int val2 ;
33657 int ecode2 = 0 ;
33658 int val3 ;
33659 int ecode3 = 0 ;
33660 int val4 ;
33661 int ecode4 = 0 ;
33662 int val5 ;
33663 int ecode5 = 0 ;
33664 int val6 ;
33665 int ecode6 = 0 ;
33666 PyObject * obj0 = 0 ;
33667 PyObject * obj1 = 0 ;
33668 PyObject * obj2 = 0 ;
33669 PyObject * obj3 = 0 ;
33670 PyObject * obj4 = 0 ;
33671 PyObject * obj5 = 0 ;
33672 char * kwnames[] = {
33673 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
33674 };
33675
33676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
33677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33678 if (!SWIG_IsOK(res1)) {
33679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
33680 }
33681 arg1 = reinterpret_cast< wxWindow * >(argp1);
33682 ecode2 = SWIG_AsVal_int(obj1, &val2);
33683 if (!SWIG_IsOK(ecode2)) {
33684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
33685 }
33686 arg2 = static_cast< int >(val2);
33687 ecode3 = SWIG_AsVal_int(obj2, &val3);
33688 if (!SWIG_IsOK(ecode3)) {
33689 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
33690 }
33691 arg3 = static_cast< int >(val3);
33692 ecode4 = SWIG_AsVal_int(obj3, &val4);
33693 if (!SWIG_IsOK(ecode4)) {
33694 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
33695 }
33696 arg4 = static_cast< int >(val4);
33697 ecode5 = SWIG_AsVal_int(obj4, &val5);
33698 if (!SWIG_IsOK(ecode5)) {
33699 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
33700 }
33701 arg5 = static_cast< int >(val5);
33702 if (obj5) {
33703 ecode6 = SWIG_AsVal_int(obj5, &val6);
33704 if (!SWIG_IsOK(ecode6)) {
33705 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
33706 }
33707 arg6 = static_cast< int >(val6);
33708 }
33709 {
33710 PyThreadState* __tstate = wxPyBeginAllowThreads();
33711 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
33712 wxPyEndAllowThreads(__tstate);
33713 if (PyErr_Occurred()) SWIG_fail;
33714 }
33715 resultobj = SWIG_Py_Void();
33716 return resultobj;
33717 fail:
33718 return NULL;
33719 }
33720
33721
33722 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33723 PyObject *resultobj = 0;
33724 wxWindow *arg1 = (wxWindow *) 0 ;
33725 wxRect *arg2 = 0 ;
33726 int arg3 = (int) wxSIZE_AUTO ;
33727 void *argp1 = 0 ;
33728 int res1 = 0 ;
33729 wxRect temp2 ;
33730 int val3 ;
33731 int ecode3 = 0 ;
33732 PyObject * obj0 = 0 ;
33733 PyObject * obj1 = 0 ;
33734 PyObject * obj2 = 0 ;
33735 char * kwnames[] = {
33736 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
33737 };
33738
33739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33741 if (!SWIG_IsOK(res1)) {
33742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
33743 }
33744 arg1 = reinterpret_cast< wxWindow * >(argp1);
33745 {
33746 arg2 = &temp2;
33747 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
33748 }
33749 if (obj2) {
33750 ecode3 = SWIG_AsVal_int(obj2, &val3);
33751 if (!SWIG_IsOK(ecode3)) {
33752 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
33753 }
33754 arg3 = static_cast< int >(val3);
33755 }
33756 {
33757 PyThreadState* __tstate = wxPyBeginAllowThreads();
33758 (arg1)->SetSize((wxRect const &)*arg2,arg3);
33759 wxPyEndAllowThreads(__tstate);
33760 if (PyErr_Occurred()) SWIG_fail;
33761 }
33762 resultobj = SWIG_Py_Void();
33763 return resultobj;
33764 fail:
33765 return NULL;
33766 }
33767
33768
33769 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33770 PyObject *resultobj = 0;
33771 wxWindow *arg1 = (wxWindow *) 0 ;
33772 int arg2 ;
33773 int arg3 ;
33774 void *argp1 = 0 ;
33775 int res1 = 0 ;
33776 int val2 ;
33777 int ecode2 = 0 ;
33778 int val3 ;
33779 int ecode3 = 0 ;
33780 PyObject * obj0 = 0 ;
33781 PyObject * obj1 = 0 ;
33782 PyObject * obj2 = 0 ;
33783 char * kwnames[] = {
33784 (char *) "self",(char *) "width",(char *) "height", NULL
33785 };
33786
33787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33789 if (!SWIG_IsOK(res1)) {
33790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33791 }
33792 arg1 = reinterpret_cast< wxWindow * >(argp1);
33793 ecode2 = SWIG_AsVal_int(obj1, &val2);
33794 if (!SWIG_IsOK(ecode2)) {
33795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
33796 }
33797 arg2 = static_cast< int >(val2);
33798 ecode3 = SWIG_AsVal_int(obj2, &val3);
33799 if (!SWIG_IsOK(ecode3)) {
33800 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
33801 }
33802 arg3 = static_cast< int >(val3);
33803 {
33804 PyThreadState* __tstate = wxPyBeginAllowThreads();
33805 (arg1)->SetSize(arg2,arg3);
33806 wxPyEndAllowThreads(__tstate);
33807 if (PyErr_Occurred()) SWIG_fail;
33808 }
33809 resultobj = SWIG_Py_Void();
33810 return resultobj;
33811 fail:
33812 return NULL;
33813 }
33814
33815
33816 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33817 PyObject *resultobj = 0;
33818 wxWindow *arg1 = (wxWindow *) 0 ;
33819 wxPoint *arg2 = 0 ;
33820 int arg3 = (int) wxSIZE_USE_EXISTING ;
33821 void *argp1 = 0 ;
33822 int res1 = 0 ;
33823 wxPoint temp2 ;
33824 int val3 ;
33825 int ecode3 = 0 ;
33826 PyObject * obj0 = 0 ;
33827 PyObject * obj1 = 0 ;
33828 PyObject * obj2 = 0 ;
33829 char * kwnames[] = {
33830 (char *) "self",(char *) "pt",(char *) "flags", NULL
33831 };
33832
33833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33835 if (!SWIG_IsOK(res1)) {
33836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
33837 }
33838 arg1 = reinterpret_cast< wxWindow * >(argp1);
33839 {
33840 arg2 = &temp2;
33841 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33842 }
33843 if (obj2) {
33844 ecode3 = SWIG_AsVal_int(obj2, &val3);
33845 if (!SWIG_IsOK(ecode3)) {
33846 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
33847 }
33848 arg3 = static_cast< int >(val3);
33849 }
33850 {
33851 PyThreadState* __tstate = wxPyBeginAllowThreads();
33852 (arg1)->Move((wxPoint const &)*arg2,arg3);
33853 wxPyEndAllowThreads(__tstate);
33854 if (PyErr_Occurred()) SWIG_fail;
33855 }
33856 resultobj = SWIG_Py_Void();
33857 return resultobj;
33858 fail:
33859 return NULL;
33860 }
33861
33862
33863 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33864 PyObject *resultobj = 0;
33865 wxWindow *arg1 = (wxWindow *) 0 ;
33866 int arg2 ;
33867 int arg3 ;
33868 int arg4 = (int) wxSIZE_USE_EXISTING ;
33869 void *argp1 = 0 ;
33870 int res1 = 0 ;
33871 int val2 ;
33872 int ecode2 = 0 ;
33873 int val3 ;
33874 int ecode3 = 0 ;
33875 int val4 ;
33876 int ecode4 = 0 ;
33877 PyObject * obj0 = 0 ;
33878 PyObject * obj1 = 0 ;
33879 PyObject * obj2 = 0 ;
33880 PyObject * obj3 = 0 ;
33881 char * kwnames[] = {
33882 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
33883 };
33884
33885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33887 if (!SWIG_IsOK(res1)) {
33888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
33889 }
33890 arg1 = reinterpret_cast< wxWindow * >(argp1);
33891 ecode2 = SWIG_AsVal_int(obj1, &val2);
33892 if (!SWIG_IsOK(ecode2)) {
33893 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
33894 }
33895 arg2 = static_cast< int >(val2);
33896 ecode3 = SWIG_AsVal_int(obj2, &val3);
33897 if (!SWIG_IsOK(ecode3)) {
33898 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
33899 }
33900 arg3 = static_cast< int >(val3);
33901 if (obj3) {
33902 ecode4 = SWIG_AsVal_int(obj3, &val4);
33903 if (!SWIG_IsOK(ecode4)) {
33904 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
33905 }
33906 arg4 = static_cast< int >(val4);
33907 }
33908 {
33909 PyThreadState* __tstate = wxPyBeginAllowThreads();
33910 (arg1)->Move(arg2,arg3,arg4);
33911 wxPyEndAllowThreads(__tstate);
33912 if (PyErr_Occurred()) SWIG_fail;
33913 }
33914 resultobj = SWIG_Py_Void();
33915 return resultobj;
33916 fail:
33917 return NULL;
33918 }
33919
33920
33921 SWIGINTERN PyObject *_wrap_Window_SetInitialSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33922 PyObject *resultobj = 0;
33923 wxWindow *arg1 = (wxWindow *) 0 ;
33924 wxSize const &arg2_defvalue = wxDefaultSize ;
33925 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
33926 void *argp1 = 0 ;
33927 int res1 = 0 ;
33928 wxSize temp2 ;
33929 PyObject * obj0 = 0 ;
33930 PyObject * obj1 = 0 ;
33931 char * kwnames[] = {
33932 (char *) "self",(char *) "size", NULL
33933 };
33934
33935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetInitialSize",kwnames,&obj0,&obj1)) SWIG_fail;
33936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33937 if (!SWIG_IsOK(res1)) {
33938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetInitialSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33939 }
33940 arg1 = reinterpret_cast< wxWindow * >(argp1);
33941 if (obj1) {
33942 {
33943 arg2 = &temp2;
33944 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33945 }
33946 }
33947 {
33948 PyThreadState* __tstate = wxPyBeginAllowThreads();
33949 (arg1)->SetInitialSize((wxSize const &)*arg2);
33950 wxPyEndAllowThreads(__tstate);
33951 if (PyErr_Occurred()) SWIG_fail;
33952 }
33953 resultobj = SWIG_Py_Void();
33954 return resultobj;
33955 fail:
33956 return NULL;
33957 }
33958
33959
33960 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33961 PyObject *resultobj = 0;
33962 wxWindow *arg1 = (wxWindow *) 0 ;
33963 void *argp1 = 0 ;
33964 int res1 = 0 ;
33965 PyObject *swig_obj[1] ;
33966
33967 if (!args) SWIG_fail;
33968 swig_obj[0] = args;
33969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33970 if (!SWIG_IsOK(res1)) {
33971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
33972 }
33973 arg1 = reinterpret_cast< wxWindow * >(argp1);
33974 {
33975 PyThreadState* __tstate = wxPyBeginAllowThreads();
33976 (arg1)->Raise();
33977 wxPyEndAllowThreads(__tstate);
33978 if (PyErr_Occurred()) SWIG_fail;
33979 }
33980 resultobj = SWIG_Py_Void();
33981 return resultobj;
33982 fail:
33983 return NULL;
33984 }
33985
33986
33987 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33988 PyObject *resultobj = 0;
33989 wxWindow *arg1 = (wxWindow *) 0 ;
33990 void *argp1 = 0 ;
33991 int res1 = 0 ;
33992 PyObject *swig_obj[1] ;
33993
33994 if (!args) SWIG_fail;
33995 swig_obj[0] = args;
33996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33997 if (!SWIG_IsOK(res1)) {
33998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
33999 }
34000 arg1 = reinterpret_cast< wxWindow * >(argp1);
34001 {
34002 PyThreadState* __tstate = wxPyBeginAllowThreads();
34003 (arg1)->Lower();
34004 wxPyEndAllowThreads(__tstate);
34005 if (PyErr_Occurred()) SWIG_fail;
34006 }
34007 resultobj = SWIG_Py_Void();
34008 return resultobj;
34009 fail:
34010 return NULL;
34011 }
34012
34013
34014 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34015 PyObject *resultobj = 0;
34016 wxWindow *arg1 = (wxWindow *) 0 ;
34017 wxSize *arg2 = 0 ;
34018 void *argp1 = 0 ;
34019 int res1 = 0 ;
34020 wxSize temp2 ;
34021 PyObject * obj0 = 0 ;
34022 PyObject * obj1 = 0 ;
34023 char * kwnames[] = {
34024 (char *) "self",(char *) "size", NULL
34025 };
34026
34027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
34028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34029 if (!SWIG_IsOK(res1)) {
34030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34031 }
34032 arg1 = reinterpret_cast< wxWindow * >(argp1);
34033 {
34034 arg2 = &temp2;
34035 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34036 }
34037 {
34038 PyThreadState* __tstate = wxPyBeginAllowThreads();
34039 (arg1)->SetClientSize((wxSize const &)*arg2);
34040 wxPyEndAllowThreads(__tstate);
34041 if (PyErr_Occurred()) SWIG_fail;
34042 }
34043 resultobj = SWIG_Py_Void();
34044 return resultobj;
34045 fail:
34046 return NULL;
34047 }
34048
34049
34050 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34051 PyObject *resultobj = 0;
34052 wxWindow *arg1 = (wxWindow *) 0 ;
34053 int arg2 ;
34054 int arg3 ;
34055 void *argp1 = 0 ;
34056 int res1 = 0 ;
34057 int val2 ;
34058 int ecode2 = 0 ;
34059 int val3 ;
34060 int ecode3 = 0 ;
34061 PyObject * obj0 = 0 ;
34062 PyObject * obj1 = 0 ;
34063 PyObject * obj2 = 0 ;
34064 char * kwnames[] = {
34065 (char *) "self",(char *) "width",(char *) "height", NULL
34066 };
34067
34068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34070 if (!SWIG_IsOK(res1)) {
34071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
34072 }
34073 arg1 = reinterpret_cast< wxWindow * >(argp1);
34074 ecode2 = SWIG_AsVal_int(obj1, &val2);
34075 if (!SWIG_IsOK(ecode2)) {
34076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
34077 }
34078 arg2 = static_cast< int >(val2);
34079 ecode3 = SWIG_AsVal_int(obj2, &val3);
34080 if (!SWIG_IsOK(ecode3)) {
34081 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
34082 }
34083 arg3 = static_cast< int >(val3);
34084 {
34085 PyThreadState* __tstate = wxPyBeginAllowThreads();
34086 (arg1)->SetClientSize(arg2,arg3);
34087 wxPyEndAllowThreads(__tstate);
34088 if (PyErr_Occurred()) SWIG_fail;
34089 }
34090 resultobj = SWIG_Py_Void();
34091 return resultobj;
34092 fail:
34093 return NULL;
34094 }
34095
34096
34097 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34098 PyObject *resultobj = 0;
34099 wxWindow *arg1 = (wxWindow *) 0 ;
34100 wxRect *arg2 = 0 ;
34101 void *argp1 = 0 ;
34102 int res1 = 0 ;
34103 wxRect temp2 ;
34104 PyObject * obj0 = 0 ;
34105 PyObject * obj1 = 0 ;
34106 char * kwnames[] = {
34107 (char *) "self",(char *) "rect", NULL
34108 };
34109
34110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
34111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34112 if (!SWIG_IsOK(res1)) {
34113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34114 }
34115 arg1 = reinterpret_cast< wxWindow * >(argp1);
34116 {
34117 arg2 = &temp2;
34118 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34119 }
34120 {
34121 PyThreadState* __tstate = wxPyBeginAllowThreads();
34122 (arg1)->SetClientSize((wxRect const &)*arg2);
34123 wxPyEndAllowThreads(__tstate);
34124 if (PyErr_Occurred()) SWIG_fail;
34125 }
34126 resultobj = SWIG_Py_Void();
34127 return resultobj;
34128 fail:
34129 return NULL;
34130 }
34131
34132
34133 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34134 PyObject *resultobj = 0;
34135 wxWindow *arg1 = (wxWindow *) 0 ;
34136 wxPoint result;
34137 void *argp1 = 0 ;
34138 int res1 = 0 ;
34139 PyObject *swig_obj[1] ;
34140
34141 if (!args) SWIG_fail;
34142 swig_obj[0] = args;
34143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34144 if (!SWIG_IsOK(res1)) {
34145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34146 }
34147 arg1 = reinterpret_cast< wxWindow * >(argp1);
34148 {
34149 PyThreadState* __tstate = wxPyBeginAllowThreads();
34150 result = ((wxWindow const *)arg1)->GetPosition();
34151 wxPyEndAllowThreads(__tstate);
34152 if (PyErr_Occurred()) SWIG_fail;
34153 }
34154 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34155 return resultobj;
34156 fail:
34157 return NULL;
34158 }
34159
34160
34161 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34162 PyObject *resultobj = 0;
34163 wxWindow *arg1 = (wxWindow *) 0 ;
34164 int *arg2 = (int *) 0 ;
34165 int *arg3 = (int *) 0 ;
34166 void *argp1 = 0 ;
34167 int res1 = 0 ;
34168 int temp2 ;
34169 int res2 = SWIG_TMPOBJ ;
34170 int temp3 ;
34171 int res3 = SWIG_TMPOBJ ;
34172 PyObject *swig_obj[1] ;
34173
34174 arg2 = &temp2;
34175 arg3 = &temp3;
34176 if (!args) SWIG_fail;
34177 swig_obj[0] = args;
34178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34179 if (!SWIG_IsOK(res1)) {
34180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34181 }
34182 arg1 = reinterpret_cast< wxWindow * >(argp1);
34183 {
34184 PyThreadState* __tstate = wxPyBeginAllowThreads();
34185 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
34186 wxPyEndAllowThreads(__tstate);
34187 if (PyErr_Occurred()) SWIG_fail;
34188 }
34189 resultobj = SWIG_Py_Void();
34190 if (SWIG_IsTmpObj(res2)) {
34191 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34192 } else {
34193 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34194 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34195 }
34196 if (SWIG_IsTmpObj(res3)) {
34197 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34198 } else {
34199 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34200 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34201 }
34202 return resultobj;
34203 fail:
34204 return NULL;
34205 }
34206
34207
34208 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34209 PyObject *resultobj = 0;
34210 wxWindow *arg1 = (wxWindow *) 0 ;
34211 wxPoint result;
34212 void *argp1 = 0 ;
34213 int res1 = 0 ;
34214 PyObject *swig_obj[1] ;
34215
34216 if (!args) SWIG_fail;
34217 swig_obj[0] = args;
34218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34219 if (!SWIG_IsOK(res1)) {
34220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34221 }
34222 arg1 = reinterpret_cast< wxWindow * >(argp1);
34223 {
34224 PyThreadState* __tstate = wxPyBeginAllowThreads();
34225 result = ((wxWindow const *)arg1)->GetScreenPosition();
34226 wxPyEndAllowThreads(__tstate);
34227 if (PyErr_Occurred()) SWIG_fail;
34228 }
34229 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34230 return resultobj;
34231 fail:
34232 return NULL;
34233 }
34234
34235
34236 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34237 PyObject *resultobj = 0;
34238 wxWindow *arg1 = (wxWindow *) 0 ;
34239 int *arg2 = (int *) 0 ;
34240 int *arg3 = (int *) 0 ;
34241 void *argp1 = 0 ;
34242 int res1 = 0 ;
34243 int temp2 ;
34244 int res2 = SWIG_TMPOBJ ;
34245 int temp3 ;
34246 int res3 = SWIG_TMPOBJ ;
34247 PyObject *swig_obj[1] ;
34248
34249 arg2 = &temp2;
34250 arg3 = &temp3;
34251 if (!args) SWIG_fail;
34252 swig_obj[0] = args;
34253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34254 if (!SWIG_IsOK(res1)) {
34255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34256 }
34257 arg1 = reinterpret_cast< wxWindow * >(argp1);
34258 {
34259 PyThreadState* __tstate = wxPyBeginAllowThreads();
34260 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
34261 wxPyEndAllowThreads(__tstate);
34262 if (PyErr_Occurred()) SWIG_fail;
34263 }
34264 resultobj = SWIG_Py_Void();
34265 if (SWIG_IsTmpObj(res2)) {
34266 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34267 } else {
34268 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34269 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34270 }
34271 if (SWIG_IsTmpObj(res3)) {
34272 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34273 } else {
34274 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34275 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34276 }
34277 return resultobj;
34278 fail:
34279 return NULL;
34280 }
34281
34282
34283 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34284 PyObject *resultobj = 0;
34285 wxWindow *arg1 = (wxWindow *) 0 ;
34286 wxRect result;
34287 void *argp1 = 0 ;
34288 int res1 = 0 ;
34289 PyObject *swig_obj[1] ;
34290
34291 if (!args) SWIG_fail;
34292 swig_obj[0] = args;
34293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34294 if (!SWIG_IsOK(res1)) {
34295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34296 }
34297 arg1 = reinterpret_cast< wxWindow * >(argp1);
34298 {
34299 PyThreadState* __tstate = wxPyBeginAllowThreads();
34300 result = ((wxWindow const *)arg1)->GetScreenRect();
34301 wxPyEndAllowThreads(__tstate);
34302 if (PyErr_Occurred()) SWIG_fail;
34303 }
34304 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34305 return resultobj;
34306 fail:
34307 return NULL;
34308 }
34309
34310
34311 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34312 PyObject *resultobj = 0;
34313 wxWindow *arg1 = (wxWindow *) 0 ;
34314 wxSize result;
34315 void *argp1 = 0 ;
34316 int res1 = 0 ;
34317 PyObject *swig_obj[1] ;
34318
34319 if (!args) SWIG_fail;
34320 swig_obj[0] = args;
34321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34322 if (!SWIG_IsOK(res1)) {
34323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34324 }
34325 arg1 = reinterpret_cast< wxWindow * >(argp1);
34326 {
34327 PyThreadState* __tstate = wxPyBeginAllowThreads();
34328 result = ((wxWindow const *)arg1)->GetSize();
34329 wxPyEndAllowThreads(__tstate);
34330 if (PyErr_Occurred()) SWIG_fail;
34331 }
34332 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34333 return resultobj;
34334 fail:
34335 return NULL;
34336 }
34337
34338
34339 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34340 PyObject *resultobj = 0;
34341 wxWindow *arg1 = (wxWindow *) 0 ;
34342 int *arg2 = (int *) 0 ;
34343 int *arg3 = (int *) 0 ;
34344 void *argp1 = 0 ;
34345 int res1 = 0 ;
34346 int temp2 ;
34347 int res2 = SWIG_TMPOBJ ;
34348 int temp3 ;
34349 int res3 = SWIG_TMPOBJ ;
34350 PyObject *swig_obj[1] ;
34351
34352 arg2 = &temp2;
34353 arg3 = &temp3;
34354 if (!args) SWIG_fail;
34355 swig_obj[0] = args;
34356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34357 if (!SWIG_IsOK(res1)) {
34358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34359 }
34360 arg1 = reinterpret_cast< wxWindow * >(argp1);
34361 {
34362 PyThreadState* __tstate = wxPyBeginAllowThreads();
34363 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
34364 wxPyEndAllowThreads(__tstate);
34365 if (PyErr_Occurred()) SWIG_fail;
34366 }
34367 resultobj = SWIG_Py_Void();
34368 if (SWIG_IsTmpObj(res2)) {
34369 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34370 } else {
34371 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34372 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34373 }
34374 if (SWIG_IsTmpObj(res3)) {
34375 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34376 } else {
34377 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34378 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34379 }
34380 return resultobj;
34381 fail:
34382 return NULL;
34383 }
34384
34385
34386 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34387 PyObject *resultobj = 0;
34388 wxWindow *arg1 = (wxWindow *) 0 ;
34389 wxRect result;
34390 void *argp1 = 0 ;
34391 int res1 = 0 ;
34392 PyObject *swig_obj[1] ;
34393
34394 if (!args) SWIG_fail;
34395 swig_obj[0] = args;
34396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34397 if (!SWIG_IsOK(res1)) {
34398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34399 }
34400 arg1 = reinterpret_cast< wxWindow * >(argp1);
34401 {
34402 PyThreadState* __tstate = wxPyBeginAllowThreads();
34403 result = ((wxWindow const *)arg1)->GetRect();
34404 wxPyEndAllowThreads(__tstate);
34405 if (PyErr_Occurred()) SWIG_fail;
34406 }
34407 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34408 return resultobj;
34409 fail:
34410 return NULL;
34411 }
34412
34413
34414 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34415 PyObject *resultobj = 0;
34416 wxWindow *arg1 = (wxWindow *) 0 ;
34417 wxSize result;
34418 void *argp1 = 0 ;
34419 int res1 = 0 ;
34420 PyObject *swig_obj[1] ;
34421
34422 if (!args) SWIG_fail;
34423 swig_obj[0] = args;
34424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34425 if (!SWIG_IsOK(res1)) {
34426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34427 }
34428 arg1 = reinterpret_cast< wxWindow * >(argp1);
34429 {
34430 PyThreadState* __tstate = wxPyBeginAllowThreads();
34431 result = ((wxWindow const *)arg1)->GetClientSize();
34432 wxPyEndAllowThreads(__tstate);
34433 if (PyErr_Occurred()) SWIG_fail;
34434 }
34435 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34436 return resultobj;
34437 fail:
34438 return NULL;
34439 }
34440
34441
34442 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34443 PyObject *resultobj = 0;
34444 wxWindow *arg1 = (wxWindow *) 0 ;
34445 int *arg2 = (int *) 0 ;
34446 int *arg3 = (int *) 0 ;
34447 void *argp1 = 0 ;
34448 int res1 = 0 ;
34449 int temp2 ;
34450 int res2 = SWIG_TMPOBJ ;
34451 int temp3 ;
34452 int res3 = SWIG_TMPOBJ ;
34453 PyObject *swig_obj[1] ;
34454
34455 arg2 = &temp2;
34456 arg3 = &temp3;
34457 if (!args) SWIG_fail;
34458 swig_obj[0] = args;
34459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34460 if (!SWIG_IsOK(res1)) {
34461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34462 }
34463 arg1 = reinterpret_cast< wxWindow * >(argp1);
34464 {
34465 PyThreadState* __tstate = wxPyBeginAllowThreads();
34466 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
34467 wxPyEndAllowThreads(__tstate);
34468 if (PyErr_Occurred()) SWIG_fail;
34469 }
34470 resultobj = SWIG_Py_Void();
34471 if (SWIG_IsTmpObj(res2)) {
34472 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34473 } else {
34474 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34475 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34476 }
34477 if (SWIG_IsTmpObj(res3)) {
34478 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34479 } else {
34480 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34481 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34482 }
34483 return resultobj;
34484 fail:
34485 return NULL;
34486 }
34487
34488
34489 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34490 PyObject *resultobj = 0;
34491 wxWindow *arg1 = (wxWindow *) 0 ;
34492 wxPoint result;
34493 void *argp1 = 0 ;
34494 int res1 = 0 ;
34495 PyObject *swig_obj[1] ;
34496
34497 if (!args) SWIG_fail;
34498 swig_obj[0] = args;
34499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34500 if (!SWIG_IsOK(res1)) {
34501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
34502 }
34503 arg1 = reinterpret_cast< wxWindow * >(argp1);
34504 {
34505 PyThreadState* __tstate = wxPyBeginAllowThreads();
34506 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
34507 wxPyEndAllowThreads(__tstate);
34508 if (PyErr_Occurred()) SWIG_fail;
34509 }
34510 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34511 return resultobj;
34512 fail:
34513 return NULL;
34514 }
34515
34516
34517 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34518 PyObject *resultobj = 0;
34519 wxWindow *arg1 = (wxWindow *) 0 ;
34520 wxRect result;
34521 void *argp1 = 0 ;
34522 int res1 = 0 ;
34523 PyObject *swig_obj[1] ;
34524
34525 if (!args) SWIG_fail;
34526 swig_obj[0] = args;
34527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34528 if (!SWIG_IsOK(res1)) {
34529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34530 }
34531 arg1 = reinterpret_cast< wxWindow * >(argp1);
34532 {
34533 PyThreadState* __tstate = wxPyBeginAllowThreads();
34534 result = ((wxWindow const *)arg1)->GetClientRect();
34535 wxPyEndAllowThreads(__tstate);
34536 if (PyErr_Occurred()) SWIG_fail;
34537 }
34538 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34539 return resultobj;
34540 fail:
34541 return NULL;
34542 }
34543
34544
34545 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34546 PyObject *resultobj = 0;
34547 wxWindow *arg1 = (wxWindow *) 0 ;
34548 wxSize result;
34549 void *argp1 = 0 ;
34550 int res1 = 0 ;
34551 PyObject *swig_obj[1] ;
34552
34553 if (!args) SWIG_fail;
34554 swig_obj[0] = args;
34555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34556 if (!SWIG_IsOK(res1)) {
34557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34558 }
34559 arg1 = reinterpret_cast< wxWindow * >(argp1);
34560 {
34561 PyThreadState* __tstate = wxPyBeginAllowThreads();
34562 result = ((wxWindow const *)arg1)->GetBestSize();
34563 wxPyEndAllowThreads(__tstate);
34564 if (PyErr_Occurred()) SWIG_fail;
34565 }
34566 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34567 return resultobj;
34568 fail:
34569 return NULL;
34570 }
34571
34572
34573 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34574 PyObject *resultobj = 0;
34575 wxWindow *arg1 = (wxWindow *) 0 ;
34576 int *arg2 = (int *) 0 ;
34577 int *arg3 = (int *) 0 ;
34578 void *argp1 = 0 ;
34579 int res1 = 0 ;
34580 int temp2 ;
34581 int res2 = SWIG_TMPOBJ ;
34582 int temp3 ;
34583 int res3 = SWIG_TMPOBJ ;
34584 PyObject *swig_obj[1] ;
34585
34586 arg2 = &temp2;
34587 arg3 = &temp3;
34588 if (!args) SWIG_fail;
34589 swig_obj[0] = args;
34590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34591 if (!SWIG_IsOK(res1)) {
34592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34593 }
34594 arg1 = reinterpret_cast< wxWindow * >(argp1);
34595 {
34596 PyThreadState* __tstate = wxPyBeginAllowThreads();
34597 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
34598 wxPyEndAllowThreads(__tstate);
34599 if (PyErr_Occurred()) SWIG_fail;
34600 }
34601 resultobj = SWIG_Py_Void();
34602 if (SWIG_IsTmpObj(res2)) {
34603 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34604 } else {
34605 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34606 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34607 }
34608 if (SWIG_IsTmpObj(res3)) {
34609 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34610 } else {
34611 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34612 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34613 }
34614 return resultobj;
34615 fail:
34616 return NULL;
34617 }
34618
34619
34620 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34621 PyObject *resultobj = 0;
34622 wxWindow *arg1 = (wxWindow *) 0 ;
34623 void *argp1 = 0 ;
34624 int res1 = 0 ;
34625 PyObject *swig_obj[1] ;
34626
34627 if (!args) SWIG_fail;
34628 swig_obj[0] = args;
34629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34630 if (!SWIG_IsOK(res1)) {
34631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34632 }
34633 arg1 = reinterpret_cast< wxWindow * >(argp1);
34634 {
34635 PyThreadState* __tstate = wxPyBeginAllowThreads();
34636 (arg1)->InvalidateBestSize();
34637 wxPyEndAllowThreads(__tstate);
34638 if (PyErr_Occurred()) SWIG_fail;
34639 }
34640 resultobj = SWIG_Py_Void();
34641 return resultobj;
34642 fail:
34643 return NULL;
34644 }
34645
34646
34647 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34648 PyObject *resultobj = 0;
34649 wxWindow *arg1 = (wxWindow *) 0 ;
34650 wxSize *arg2 = 0 ;
34651 void *argp1 = 0 ;
34652 int res1 = 0 ;
34653 wxSize temp2 ;
34654 PyObject * obj0 = 0 ;
34655 PyObject * obj1 = 0 ;
34656 char * kwnames[] = {
34657 (char *) "self",(char *) "size", NULL
34658 };
34659
34660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
34661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34662 if (!SWIG_IsOK(res1)) {
34663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34664 }
34665 arg1 = reinterpret_cast< wxWindow * >(argp1);
34666 {
34667 arg2 = &temp2;
34668 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34669 }
34670 {
34671 PyThreadState* __tstate = wxPyBeginAllowThreads();
34672 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
34673 wxPyEndAllowThreads(__tstate);
34674 if (PyErr_Occurred()) SWIG_fail;
34675 }
34676 resultobj = SWIG_Py_Void();
34677 return resultobj;
34678 fail:
34679 return NULL;
34680 }
34681
34682
34683 SWIGINTERN PyObject *_wrap_Window_GetEffectiveMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34684 PyObject *resultobj = 0;
34685 wxWindow *arg1 = (wxWindow *) 0 ;
34686 wxSize result;
34687 void *argp1 = 0 ;
34688 int res1 = 0 ;
34689 PyObject *swig_obj[1] ;
34690
34691 if (!args) SWIG_fail;
34692 swig_obj[0] = args;
34693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34694 if (!SWIG_IsOK(res1)) {
34695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEffectiveMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34696 }
34697 arg1 = reinterpret_cast< wxWindow * >(argp1);
34698 {
34699 PyThreadState* __tstate = wxPyBeginAllowThreads();
34700 result = ((wxWindow const *)arg1)->GetEffectiveMinSize();
34701 wxPyEndAllowThreads(__tstate);
34702 if (PyErr_Occurred()) SWIG_fail;
34703 }
34704 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34705 return resultobj;
34706 fail:
34707 return NULL;
34708 }
34709
34710
34711 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34712 PyObject *resultobj = 0;
34713 wxWindow *arg1 = (wxWindow *) 0 ;
34714 int arg2 = (int) wxBOTH ;
34715 void *argp1 = 0 ;
34716 int res1 = 0 ;
34717 int val2 ;
34718 int ecode2 = 0 ;
34719 PyObject * obj0 = 0 ;
34720 PyObject * obj1 = 0 ;
34721 char * kwnames[] = {
34722 (char *) "self",(char *) "direction", NULL
34723 };
34724
34725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
34726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34727 if (!SWIG_IsOK(res1)) {
34728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
34729 }
34730 arg1 = reinterpret_cast< wxWindow * >(argp1);
34731 if (obj1) {
34732 ecode2 = SWIG_AsVal_int(obj1, &val2);
34733 if (!SWIG_IsOK(ecode2)) {
34734 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
34735 }
34736 arg2 = static_cast< int >(val2);
34737 }
34738 {
34739 PyThreadState* __tstate = wxPyBeginAllowThreads();
34740 (arg1)->Center(arg2);
34741 wxPyEndAllowThreads(__tstate);
34742 if (PyErr_Occurred()) SWIG_fail;
34743 }
34744 resultobj = SWIG_Py_Void();
34745 return resultobj;
34746 fail:
34747 return NULL;
34748 }
34749
34750
34751 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34752 PyObject *resultobj = 0;
34753 wxWindow *arg1 = (wxWindow *) 0 ;
34754 int arg2 = (int) wxBOTH ;
34755 void *argp1 = 0 ;
34756 int res1 = 0 ;
34757 int val2 ;
34758 int ecode2 = 0 ;
34759 PyObject * obj0 = 0 ;
34760 PyObject * obj1 = 0 ;
34761 char * kwnames[] = {
34762 (char *) "self",(char *) "dir", NULL
34763 };
34764
34765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
34766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34767 if (!SWIG_IsOK(res1)) {
34768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
34769 }
34770 arg1 = reinterpret_cast< wxWindow * >(argp1);
34771 if (obj1) {
34772 ecode2 = SWIG_AsVal_int(obj1, &val2);
34773 if (!SWIG_IsOK(ecode2)) {
34774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
34775 }
34776 arg2 = static_cast< int >(val2);
34777 }
34778 {
34779 PyThreadState* __tstate = wxPyBeginAllowThreads();
34780 (arg1)->CenterOnParent(arg2);
34781 wxPyEndAllowThreads(__tstate);
34782 if (PyErr_Occurred()) SWIG_fail;
34783 }
34784 resultobj = SWIG_Py_Void();
34785 return resultobj;
34786 fail:
34787 return NULL;
34788 }
34789
34790
34791 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34792 PyObject *resultobj = 0;
34793 wxWindow *arg1 = (wxWindow *) 0 ;
34794 void *argp1 = 0 ;
34795 int res1 = 0 ;
34796 PyObject *swig_obj[1] ;
34797
34798 if (!args) SWIG_fail;
34799 swig_obj[0] = args;
34800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34801 if (!SWIG_IsOK(res1)) {
34802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
34803 }
34804 arg1 = reinterpret_cast< wxWindow * >(argp1);
34805 {
34806 PyThreadState* __tstate = wxPyBeginAllowThreads();
34807 (arg1)->Fit();
34808 wxPyEndAllowThreads(__tstate);
34809 if (PyErr_Occurred()) SWIG_fail;
34810 }
34811 resultobj = SWIG_Py_Void();
34812 return resultobj;
34813 fail:
34814 return NULL;
34815 }
34816
34817
34818 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34819 PyObject *resultobj = 0;
34820 wxWindow *arg1 = (wxWindow *) 0 ;
34821 void *argp1 = 0 ;
34822 int res1 = 0 ;
34823 PyObject *swig_obj[1] ;
34824
34825 if (!args) SWIG_fail;
34826 swig_obj[0] = args;
34827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34828 if (!SWIG_IsOK(res1)) {
34829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
34830 }
34831 arg1 = reinterpret_cast< wxWindow * >(argp1);
34832 {
34833 PyThreadState* __tstate = wxPyBeginAllowThreads();
34834 (arg1)->FitInside();
34835 wxPyEndAllowThreads(__tstate);
34836 if (PyErr_Occurred()) SWIG_fail;
34837 }
34838 resultobj = SWIG_Py_Void();
34839 return resultobj;
34840 fail:
34841 return NULL;
34842 }
34843
34844
34845 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34846 PyObject *resultobj = 0;
34847 wxWindow *arg1 = (wxWindow *) 0 ;
34848 int arg2 ;
34849 int arg3 ;
34850 int arg4 = (int) -1 ;
34851 int arg5 = (int) -1 ;
34852 int arg6 = (int) -1 ;
34853 int arg7 = (int) -1 ;
34854 void *argp1 = 0 ;
34855 int res1 = 0 ;
34856 int val2 ;
34857 int ecode2 = 0 ;
34858 int val3 ;
34859 int ecode3 = 0 ;
34860 int val4 ;
34861 int ecode4 = 0 ;
34862 int val5 ;
34863 int ecode5 = 0 ;
34864 int val6 ;
34865 int ecode6 = 0 ;
34866 int val7 ;
34867 int ecode7 = 0 ;
34868 PyObject * obj0 = 0 ;
34869 PyObject * obj1 = 0 ;
34870 PyObject * obj2 = 0 ;
34871 PyObject * obj3 = 0 ;
34872 PyObject * obj4 = 0 ;
34873 PyObject * obj5 = 0 ;
34874 PyObject * obj6 = 0 ;
34875 char * kwnames[] = {
34876 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
34877 };
34878
34879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
34880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34881 if (!SWIG_IsOK(res1)) {
34882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34883 }
34884 arg1 = reinterpret_cast< wxWindow * >(argp1);
34885 ecode2 = SWIG_AsVal_int(obj1, &val2);
34886 if (!SWIG_IsOK(ecode2)) {
34887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
34888 }
34889 arg2 = static_cast< int >(val2);
34890 ecode3 = SWIG_AsVal_int(obj2, &val3);
34891 if (!SWIG_IsOK(ecode3)) {
34892 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
34893 }
34894 arg3 = static_cast< int >(val3);
34895 if (obj3) {
34896 ecode4 = SWIG_AsVal_int(obj3, &val4);
34897 if (!SWIG_IsOK(ecode4)) {
34898 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
34899 }
34900 arg4 = static_cast< int >(val4);
34901 }
34902 if (obj4) {
34903 ecode5 = SWIG_AsVal_int(obj4, &val5);
34904 if (!SWIG_IsOK(ecode5)) {
34905 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
34906 }
34907 arg5 = static_cast< int >(val5);
34908 }
34909 if (obj5) {
34910 ecode6 = SWIG_AsVal_int(obj5, &val6);
34911 if (!SWIG_IsOK(ecode6)) {
34912 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
34913 }
34914 arg6 = static_cast< int >(val6);
34915 }
34916 if (obj6) {
34917 ecode7 = SWIG_AsVal_int(obj6, &val7);
34918 if (!SWIG_IsOK(ecode7)) {
34919 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
34920 }
34921 arg7 = static_cast< int >(val7);
34922 }
34923 {
34924 PyThreadState* __tstate = wxPyBeginAllowThreads();
34925 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
34926 wxPyEndAllowThreads(__tstate);
34927 if (PyErr_Occurred()) SWIG_fail;
34928 }
34929 resultobj = SWIG_Py_Void();
34930 return resultobj;
34931 fail:
34932 return NULL;
34933 }
34934
34935
34936 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34937 PyObject *resultobj = 0;
34938 wxWindow *arg1 = (wxWindow *) 0 ;
34939 wxSize *arg2 = 0 ;
34940 wxSize const &arg3_defvalue = wxDefaultSize ;
34941 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
34942 wxSize const &arg4_defvalue = wxDefaultSize ;
34943 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
34944 void *argp1 = 0 ;
34945 int res1 = 0 ;
34946 wxSize temp2 ;
34947 wxSize temp3 ;
34948 wxSize temp4 ;
34949 PyObject * obj0 = 0 ;
34950 PyObject * obj1 = 0 ;
34951 PyObject * obj2 = 0 ;
34952 PyObject * obj3 = 0 ;
34953 char * kwnames[] = {
34954 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
34955 };
34956
34957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34959 if (!SWIG_IsOK(res1)) {
34960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
34961 }
34962 arg1 = reinterpret_cast< wxWindow * >(argp1);
34963 {
34964 arg2 = &temp2;
34965 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34966 }
34967 if (obj2) {
34968 {
34969 arg3 = &temp3;
34970 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
34971 }
34972 }
34973 if (obj3) {
34974 {
34975 arg4 = &temp4;
34976 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
34977 }
34978 }
34979 {
34980 PyThreadState* __tstate = wxPyBeginAllowThreads();
34981 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
34982 wxPyEndAllowThreads(__tstate);
34983 if (PyErr_Occurred()) SWIG_fail;
34984 }
34985 resultobj = SWIG_Py_Void();
34986 return resultobj;
34987 fail:
34988 return NULL;
34989 }
34990
34991
34992 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34993 PyObject *resultobj = 0;
34994 wxWindow *arg1 = (wxWindow *) 0 ;
34995 int arg2 ;
34996 int arg3 ;
34997 int arg4 = (int) -1 ;
34998 int arg5 = (int) -1 ;
34999 void *argp1 = 0 ;
35000 int res1 = 0 ;
35001 int val2 ;
35002 int ecode2 = 0 ;
35003 int val3 ;
35004 int ecode3 = 0 ;
35005 int val4 ;
35006 int ecode4 = 0 ;
35007 int val5 ;
35008 int ecode5 = 0 ;
35009 PyObject * obj0 = 0 ;
35010 PyObject * obj1 = 0 ;
35011 PyObject * obj2 = 0 ;
35012 PyObject * obj3 = 0 ;
35013 PyObject * obj4 = 0 ;
35014 char * kwnames[] = {
35015 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
35016 };
35017
35018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
35019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35020 if (!SWIG_IsOK(res1)) {
35021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
35022 }
35023 arg1 = reinterpret_cast< wxWindow * >(argp1);
35024 ecode2 = SWIG_AsVal_int(obj1, &val2);
35025 if (!SWIG_IsOK(ecode2)) {
35026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
35027 }
35028 arg2 = static_cast< int >(val2);
35029 ecode3 = SWIG_AsVal_int(obj2, &val3);
35030 if (!SWIG_IsOK(ecode3)) {
35031 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
35032 }
35033 arg3 = static_cast< int >(val3);
35034 if (obj3) {
35035 ecode4 = SWIG_AsVal_int(obj3, &val4);
35036 if (!SWIG_IsOK(ecode4)) {
35037 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
35038 }
35039 arg4 = static_cast< int >(val4);
35040 }
35041 if (obj4) {
35042 ecode5 = SWIG_AsVal_int(obj4, &val5);
35043 if (!SWIG_IsOK(ecode5)) {
35044 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
35045 }
35046 arg5 = static_cast< int >(val5);
35047 }
35048 {
35049 PyThreadState* __tstate = wxPyBeginAllowThreads();
35050 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
35051 wxPyEndAllowThreads(__tstate);
35052 if (PyErr_Occurred()) SWIG_fail;
35053 }
35054 resultobj = SWIG_Py_Void();
35055 return resultobj;
35056 fail:
35057 return NULL;
35058 }
35059
35060
35061 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35062 PyObject *resultobj = 0;
35063 wxWindow *arg1 = (wxWindow *) 0 ;
35064 wxSize *arg2 = 0 ;
35065 wxSize const &arg3_defvalue = wxDefaultSize ;
35066 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
35067 void *argp1 = 0 ;
35068 int res1 = 0 ;
35069 wxSize temp2 ;
35070 wxSize temp3 ;
35071 PyObject * obj0 = 0 ;
35072 PyObject * obj1 = 0 ;
35073 PyObject * obj2 = 0 ;
35074 char * kwnames[] = {
35075 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
35076 };
35077
35078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35080 if (!SWIG_IsOK(res1)) {
35081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
35082 }
35083 arg1 = reinterpret_cast< wxWindow * >(argp1);
35084 {
35085 arg2 = &temp2;
35086 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35087 }
35088 if (obj2) {
35089 {
35090 arg3 = &temp3;
35091 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
35092 }
35093 }
35094 {
35095 PyThreadState* __tstate = wxPyBeginAllowThreads();
35096 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
35097 wxPyEndAllowThreads(__tstate);
35098 if (PyErr_Occurred()) SWIG_fail;
35099 }
35100 resultobj = SWIG_Py_Void();
35101 return resultobj;
35102 fail:
35103 return NULL;
35104 }
35105
35106
35107 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35108 PyObject *resultobj = 0;
35109 wxWindow *arg1 = (wxWindow *) 0 ;
35110 wxSize result;
35111 void *argp1 = 0 ;
35112 int res1 = 0 ;
35113 PyObject *swig_obj[1] ;
35114
35115 if (!args) SWIG_fail;
35116 swig_obj[0] = args;
35117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35118 if (!SWIG_IsOK(res1)) {
35119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35120 }
35121 arg1 = reinterpret_cast< wxWindow * >(argp1);
35122 {
35123 PyThreadState* __tstate = wxPyBeginAllowThreads();
35124 result = ((wxWindow const *)arg1)->GetMaxSize();
35125 wxPyEndAllowThreads(__tstate);
35126 if (PyErr_Occurred()) SWIG_fail;
35127 }
35128 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35129 return resultobj;
35130 fail:
35131 return NULL;
35132 }
35133
35134
35135 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35136 PyObject *resultobj = 0;
35137 wxWindow *arg1 = (wxWindow *) 0 ;
35138 wxSize result;
35139 void *argp1 = 0 ;
35140 int res1 = 0 ;
35141 PyObject *swig_obj[1] ;
35142
35143 if (!args) SWIG_fail;
35144 swig_obj[0] = args;
35145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35146 if (!SWIG_IsOK(res1)) {
35147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35148 }
35149 arg1 = reinterpret_cast< wxWindow * >(argp1);
35150 {
35151 PyThreadState* __tstate = wxPyBeginAllowThreads();
35152 result = ((wxWindow const *)arg1)->GetMinSize();
35153 wxPyEndAllowThreads(__tstate);
35154 if (PyErr_Occurred()) SWIG_fail;
35155 }
35156 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35157 return resultobj;
35158 fail:
35159 return NULL;
35160 }
35161
35162
35163 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35164 PyObject *resultobj = 0;
35165 wxWindow *arg1 = (wxWindow *) 0 ;
35166 wxSize *arg2 = 0 ;
35167 void *argp1 = 0 ;
35168 int res1 = 0 ;
35169 wxSize temp2 ;
35170 PyObject * obj0 = 0 ;
35171 PyObject * obj1 = 0 ;
35172 char * kwnames[] = {
35173 (char *) "self",(char *) "minSize", NULL
35174 };
35175
35176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
35177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35178 if (!SWIG_IsOK(res1)) {
35179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35180 }
35181 arg1 = reinterpret_cast< wxWindow * >(argp1);
35182 {
35183 arg2 = &temp2;
35184 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35185 }
35186 {
35187 PyThreadState* __tstate = wxPyBeginAllowThreads();
35188 (arg1)->SetMinSize((wxSize const &)*arg2);
35189 wxPyEndAllowThreads(__tstate);
35190 if (PyErr_Occurred()) SWIG_fail;
35191 }
35192 resultobj = SWIG_Py_Void();
35193 return resultobj;
35194 fail:
35195 return NULL;
35196 }
35197
35198
35199 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35200 PyObject *resultobj = 0;
35201 wxWindow *arg1 = (wxWindow *) 0 ;
35202 wxSize *arg2 = 0 ;
35203 void *argp1 = 0 ;
35204 int res1 = 0 ;
35205 wxSize temp2 ;
35206 PyObject * obj0 = 0 ;
35207 PyObject * obj1 = 0 ;
35208 char * kwnames[] = {
35209 (char *) "self",(char *) "maxSize", NULL
35210 };
35211
35212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
35213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35214 if (!SWIG_IsOK(res1)) {
35215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35216 }
35217 arg1 = reinterpret_cast< wxWindow * >(argp1);
35218 {
35219 arg2 = &temp2;
35220 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35221 }
35222 {
35223 PyThreadState* __tstate = wxPyBeginAllowThreads();
35224 (arg1)->SetMaxSize((wxSize const &)*arg2);
35225 wxPyEndAllowThreads(__tstate);
35226 if (PyErr_Occurred()) SWIG_fail;
35227 }
35228 resultobj = SWIG_Py_Void();
35229 return resultobj;
35230 fail:
35231 return NULL;
35232 }
35233
35234
35235 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35236 PyObject *resultobj = 0;
35237 wxWindow *arg1 = (wxWindow *) 0 ;
35238 int result;
35239 void *argp1 = 0 ;
35240 int res1 = 0 ;
35241 PyObject *swig_obj[1] ;
35242
35243 if (!args) SWIG_fail;
35244 swig_obj[0] = args;
35245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35246 if (!SWIG_IsOK(res1)) {
35247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35248 }
35249 arg1 = reinterpret_cast< wxWindow * >(argp1);
35250 {
35251 PyThreadState* __tstate = wxPyBeginAllowThreads();
35252 result = (int)((wxWindow const *)arg1)->GetMinWidth();
35253 wxPyEndAllowThreads(__tstate);
35254 if (PyErr_Occurred()) SWIG_fail;
35255 }
35256 resultobj = SWIG_From_int(static_cast< int >(result));
35257 return resultobj;
35258 fail:
35259 return NULL;
35260 }
35261
35262
35263 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35264 PyObject *resultobj = 0;
35265 wxWindow *arg1 = (wxWindow *) 0 ;
35266 int result;
35267 void *argp1 = 0 ;
35268 int res1 = 0 ;
35269 PyObject *swig_obj[1] ;
35270
35271 if (!args) SWIG_fail;
35272 swig_obj[0] = args;
35273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35274 if (!SWIG_IsOK(res1)) {
35275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35276 }
35277 arg1 = reinterpret_cast< wxWindow * >(argp1);
35278 {
35279 PyThreadState* __tstate = wxPyBeginAllowThreads();
35280 result = (int)((wxWindow const *)arg1)->GetMinHeight();
35281 wxPyEndAllowThreads(__tstate);
35282 if (PyErr_Occurred()) SWIG_fail;
35283 }
35284 resultobj = SWIG_From_int(static_cast< int >(result));
35285 return resultobj;
35286 fail:
35287 return NULL;
35288 }
35289
35290
35291 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35292 PyObject *resultobj = 0;
35293 wxWindow *arg1 = (wxWindow *) 0 ;
35294 int result;
35295 void *argp1 = 0 ;
35296 int res1 = 0 ;
35297 PyObject *swig_obj[1] ;
35298
35299 if (!args) SWIG_fail;
35300 swig_obj[0] = args;
35301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35302 if (!SWIG_IsOK(res1)) {
35303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35304 }
35305 arg1 = reinterpret_cast< wxWindow * >(argp1);
35306 {
35307 PyThreadState* __tstate = wxPyBeginAllowThreads();
35308 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
35309 wxPyEndAllowThreads(__tstate);
35310 if (PyErr_Occurred()) SWIG_fail;
35311 }
35312 resultobj = SWIG_From_int(static_cast< int >(result));
35313 return resultobj;
35314 fail:
35315 return NULL;
35316 }
35317
35318
35319 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35320 PyObject *resultobj = 0;
35321 wxWindow *arg1 = (wxWindow *) 0 ;
35322 int result;
35323 void *argp1 = 0 ;
35324 int res1 = 0 ;
35325 PyObject *swig_obj[1] ;
35326
35327 if (!args) SWIG_fail;
35328 swig_obj[0] = args;
35329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35330 if (!SWIG_IsOK(res1)) {
35331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35332 }
35333 arg1 = reinterpret_cast< wxWindow * >(argp1);
35334 {
35335 PyThreadState* __tstate = wxPyBeginAllowThreads();
35336 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
35337 wxPyEndAllowThreads(__tstate);
35338 if (PyErr_Occurred()) SWIG_fail;
35339 }
35340 resultobj = SWIG_From_int(static_cast< int >(result));
35341 return resultobj;
35342 fail:
35343 return NULL;
35344 }
35345
35346
35347 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35348 PyObject *resultobj = 0;
35349 wxWindow *arg1 = (wxWindow *) 0 ;
35350 wxSize *arg2 = 0 ;
35351 void *argp1 = 0 ;
35352 int res1 = 0 ;
35353 wxSize temp2 ;
35354 PyObject * obj0 = 0 ;
35355 PyObject * obj1 = 0 ;
35356 char * kwnames[] = {
35357 (char *) "self",(char *) "size", NULL
35358 };
35359
35360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
35361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35362 if (!SWIG_IsOK(res1)) {
35363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35364 }
35365 arg1 = reinterpret_cast< wxWindow * >(argp1);
35366 {
35367 arg2 = &temp2;
35368 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35369 }
35370 {
35371 PyThreadState* __tstate = wxPyBeginAllowThreads();
35372 (arg1)->SetVirtualSize((wxSize const &)*arg2);
35373 wxPyEndAllowThreads(__tstate);
35374 if (PyErr_Occurred()) SWIG_fail;
35375 }
35376 resultobj = SWIG_Py_Void();
35377 return resultobj;
35378 fail:
35379 return NULL;
35380 }
35381
35382
35383 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35384 PyObject *resultobj = 0;
35385 wxWindow *arg1 = (wxWindow *) 0 ;
35386 int arg2 ;
35387 int arg3 ;
35388 void *argp1 = 0 ;
35389 int res1 = 0 ;
35390 int val2 ;
35391 int ecode2 = 0 ;
35392 int val3 ;
35393 int ecode3 = 0 ;
35394 PyObject * obj0 = 0 ;
35395 PyObject * obj1 = 0 ;
35396 PyObject * obj2 = 0 ;
35397 char * kwnames[] = {
35398 (char *) "self",(char *) "w",(char *) "h", NULL
35399 };
35400
35401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35403 if (!SWIG_IsOK(res1)) {
35404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
35405 }
35406 arg1 = reinterpret_cast< wxWindow * >(argp1);
35407 ecode2 = SWIG_AsVal_int(obj1, &val2);
35408 if (!SWIG_IsOK(ecode2)) {
35409 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
35410 }
35411 arg2 = static_cast< int >(val2);
35412 ecode3 = SWIG_AsVal_int(obj2, &val3);
35413 if (!SWIG_IsOK(ecode3)) {
35414 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
35415 }
35416 arg3 = static_cast< int >(val3);
35417 {
35418 PyThreadState* __tstate = wxPyBeginAllowThreads();
35419 (arg1)->SetVirtualSize(arg2,arg3);
35420 wxPyEndAllowThreads(__tstate);
35421 if (PyErr_Occurred()) SWIG_fail;
35422 }
35423 resultobj = SWIG_Py_Void();
35424 return resultobj;
35425 fail:
35426 return NULL;
35427 }
35428
35429
35430 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35431 PyObject *resultobj = 0;
35432 wxWindow *arg1 = (wxWindow *) 0 ;
35433 wxSize result;
35434 void *argp1 = 0 ;
35435 int res1 = 0 ;
35436 PyObject *swig_obj[1] ;
35437
35438 if (!args) SWIG_fail;
35439 swig_obj[0] = args;
35440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35441 if (!SWIG_IsOK(res1)) {
35442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35443 }
35444 arg1 = reinterpret_cast< wxWindow * >(argp1);
35445 {
35446 PyThreadState* __tstate = wxPyBeginAllowThreads();
35447 result = ((wxWindow const *)arg1)->GetVirtualSize();
35448 wxPyEndAllowThreads(__tstate);
35449 if (PyErr_Occurred()) SWIG_fail;
35450 }
35451 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35452 return resultobj;
35453 fail:
35454 return NULL;
35455 }
35456
35457
35458 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35459 PyObject *resultobj = 0;
35460 wxWindow *arg1 = (wxWindow *) 0 ;
35461 int *arg2 = (int *) 0 ;
35462 int *arg3 = (int *) 0 ;
35463 void *argp1 = 0 ;
35464 int res1 = 0 ;
35465 int temp2 ;
35466 int res2 = SWIG_TMPOBJ ;
35467 int temp3 ;
35468 int res3 = SWIG_TMPOBJ ;
35469 PyObject *swig_obj[1] ;
35470
35471 arg2 = &temp2;
35472 arg3 = &temp3;
35473 if (!args) SWIG_fail;
35474 swig_obj[0] = args;
35475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35476 if (!SWIG_IsOK(res1)) {
35477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
35478 }
35479 arg1 = reinterpret_cast< wxWindow * >(argp1);
35480 {
35481 PyThreadState* __tstate = wxPyBeginAllowThreads();
35482 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
35483 wxPyEndAllowThreads(__tstate);
35484 if (PyErr_Occurred()) SWIG_fail;
35485 }
35486 resultobj = SWIG_Py_Void();
35487 if (SWIG_IsTmpObj(res2)) {
35488 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35489 } else {
35490 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35491 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35492 }
35493 if (SWIG_IsTmpObj(res3)) {
35494 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35495 } else {
35496 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35497 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35498 }
35499 return resultobj;
35500 fail:
35501 return NULL;
35502 }
35503
35504
35505 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35506 PyObject *resultobj = 0;
35507 wxWindow *arg1 = (wxWindow *) 0 ;
35508 wxSize result;
35509 void *argp1 = 0 ;
35510 int res1 = 0 ;
35511 PyObject *swig_obj[1] ;
35512
35513 if (!args) SWIG_fail;
35514 swig_obj[0] = args;
35515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35516 if (!SWIG_IsOK(res1)) {
35517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35518 }
35519 arg1 = reinterpret_cast< wxWindow * >(argp1);
35520 {
35521 PyThreadState* __tstate = wxPyBeginAllowThreads();
35522 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
35523 wxPyEndAllowThreads(__tstate);
35524 if (PyErr_Occurred()) SWIG_fail;
35525 }
35526 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35527 return resultobj;
35528 fail:
35529 return NULL;
35530 }
35531
35532
35533 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35534 PyObject *resultobj = 0;
35535 wxWindow *arg1 = (wxWindow *) 0 ;
35536 bool arg2 = (bool) true ;
35537 bool result;
35538 void *argp1 = 0 ;
35539 int res1 = 0 ;
35540 bool val2 ;
35541 int ecode2 = 0 ;
35542 PyObject * obj0 = 0 ;
35543 PyObject * obj1 = 0 ;
35544 char * kwnames[] = {
35545 (char *) "self",(char *) "show", NULL
35546 };
35547
35548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
35549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35550 if (!SWIG_IsOK(res1)) {
35551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
35552 }
35553 arg1 = reinterpret_cast< wxWindow * >(argp1);
35554 if (obj1) {
35555 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35556 if (!SWIG_IsOK(ecode2)) {
35557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
35558 }
35559 arg2 = static_cast< bool >(val2);
35560 }
35561 {
35562 PyThreadState* __tstate = wxPyBeginAllowThreads();
35563 result = (bool)(arg1)->Show(arg2);
35564 wxPyEndAllowThreads(__tstate);
35565 if (PyErr_Occurred()) SWIG_fail;
35566 }
35567 {
35568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35569 }
35570 return resultobj;
35571 fail:
35572 return NULL;
35573 }
35574
35575
35576 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35577 PyObject *resultobj = 0;
35578 wxWindow *arg1 = (wxWindow *) 0 ;
35579 bool result;
35580 void *argp1 = 0 ;
35581 int res1 = 0 ;
35582 PyObject *swig_obj[1] ;
35583
35584 if (!args) SWIG_fail;
35585 swig_obj[0] = args;
35586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35587 if (!SWIG_IsOK(res1)) {
35588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
35589 }
35590 arg1 = reinterpret_cast< wxWindow * >(argp1);
35591 {
35592 PyThreadState* __tstate = wxPyBeginAllowThreads();
35593 result = (bool)(arg1)->Hide();
35594 wxPyEndAllowThreads(__tstate);
35595 if (PyErr_Occurred()) SWIG_fail;
35596 }
35597 {
35598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35599 }
35600 return resultobj;
35601 fail:
35602 return NULL;
35603 }
35604
35605
35606 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35607 PyObject *resultobj = 0;
35608 wxWindow *arg1 = (wxWindow *) 0 ;
35609 bool arg2 = (bool) true ;
35610 bool result;
35611 void *argp1 = 0 ;
35612 int res1 = 0 ;
35613 bool val2 ;
35614 int ecode2 = 0 ;
35615 PyObject * obj0 = 0 ;
35616 PyObject * obj1 = 0 ;
35617 char * kwnames[] = {
35618 (char *) "self",(char *) "enable", NULL
35619 };
35620
35621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
35622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35623 if (!SWIG_IsOK(res1)) {
35624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
35625 }
35626 arg1 = reinterpret_cast< wxWindow * >(argp1);
35627 if (obj1) {
35628 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35629 if (!SWIG_IsOK(ecode2)) {
35630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
35631 }
35632 arg2 = static_cast< bool >(val2);
35633 }
35634 {
35635 PyThreadState* __tstate = wxPyBeginAllowThreads();
35636 result = (bool)(arg1)->Enable(arg2);
35637 wxPyEndAllowThreads(__tstate);
35638 if (PyErr_Occurred()) SWIG_fail;
35639 }
35640 {
35641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35642 }
35643 return resultobj;
35644 fail:
35645 return NULL;
35646 }
35647
35648
35649 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35650 PyObject *resultobj = 0;
35651 wxWindow *arg1 = (wxWindow *) 0 ;
35652 bool result;
35653 void *argp1 = 0 ;
35654 int res1 = 0 ;
35655 PyObject *swig_obj[1] ;
35656
35657 if (!args) SWIG_fail;
35658 swig_obj[0] = args;
35659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35660 if (!SWIG_IsOK(res1)) {
35661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
35662 }
35663 arg1 = reinterpret_cast< wxWindow * >(argp1);
35664 {
35665 PyThreadState* __tstate = wxPyBeginAllowThreads();
35666 result = (bool)(arg1)->Disable();
35667 wxPyEndAllowThreads(__tstate);
35668 if (PyErr_Occurred()) SWIG_fail;
35669 }
35670 {
35671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35672 }
35673 return resultobj;
35674 fail:
35675 return NULL;
35676 }
35677
35678
35679 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35680 PyObject *resultobj = 0;
35681 wxWindow *arg1 = (wxWindow *) 0 ;
35682 bool result;
35683 void *argp1 = 0 ;
35684 int res1 = 0 ;
35685 PyObject *swig_obj[1] ;
35686
35687 if (!args) SWIG_fail;
35688 swig_obj[0] = args;
35689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35690 if (!SWIG_IsOK(res1)) {
35691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
35692 }
35693 arg1 = reinterpret_cast< wxWindow * >(argp1);
35694 {
35695 PyThreadState* __tstate = wxPyBeginAllowThreads();
35696 result = (bool)((wxWindow const *)arg1)->IsShown();
35697 wxPyEndAllowThreads(__tstate);
35698 if (PyErr_Occurred()) SWIG_fail;
35699 }
35700 {
35701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35702 }
35703 return resultobj;
35704 fail:
35705 return NULL;
35706 }
35707
35708
35709 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35710 PyObject *resultobj = 0;
35711 wxWindow *arg1 = (wxWindow *) 0 ;
35712 bool result;
35713 void *argp1 = 0 ;
35714 int res1 = 0 ;
35715 PyObject *swig_obj[1] ;
35716
35717 if (!args) SWIG_fail;
35718 swig_obj[0] = args;
35719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35720 if (!SWIG_IsOK(res1)) {
35721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
35722 }
35723 arg1 = reinterpret_cast< wxWindow * >(argp1);
35724 {
35725 PyThreadState* __tstate = wxPyBeginAllowThreads();
35726 result = (bool)((wxWindow const *)arg1)->IsEnabled();
35727 wxPyEndAllowThreads(__tstate);
35728 if (PyErr_Occurred()) SWIG_fail;
35729 }
35730 {
35731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35732 }
35733 return resultobj;
35734 fail:
35735 return NULL;
35736 }
35737
35738
35739 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35740 PyObject *resultobj = 0;
35741 wxWindow *arg1 = (wxWindow *) 0 ;
35742 bool result;
35743 void *argp1 = 0 ;
35744 int res1 = 0 ;
35745 PyObject *swig_obj[1] ;
35746
35747 if (!args) SWIG_fail;
35748 swig_obj[0] = args;
35749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35750 if (!SWIG_IsOK(res1)) {
35751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35752 }
35753 arg1 = reinterpret_cast< wxWindow * >(argp1);
35754 {
35755 PyThreadState* __tstate = wxPyBeginAllowThreads();
35756 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
35757 wxPyEndAllowThreads(__tstate);
35758 if (PyErr_Occurred()) SWIG_fail;
35759 }
35760 {
35761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35762 }
35763 return resultobj;
35764 fail:
35765 return NULL;
35766 }
35767
35768
35769 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35770 PyObject *resultobj = 0;
35771 wxWindow *arg1 = (wxWindow *) 0 ;
35772 long arg2 ;
35773 void *argp1 = 0 ;
35774 int res1 = 0 ;
35775 long val2 ;
35776 int ecode2 = 0 ;
35777 PyObject * obj0 = 0 ;
35778 PyObject * obj1 = 0 ;
35779 char * kwnames[] = {
35780 (char *) "self",(char *) "style", NULL
35781 };
35782
35783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35785 if (!SWIG_IsOK(res1)) {
35786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
35787 }
35788 arg1 = reinterpret_cast< wxWindow * >(argp1);
35789 ecode2 = SWIG_AsVal_long(obj1, &val2);
35790 if (!SWIG_IsOK(ecode2)) {
35791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
35792 }
35793 arg2 = static_cast< long >(val2);
35794 {
35795 PyThreadState* __tstate = wxPyBeginAllowThreads();
35796 (arg1)->SetWindowStyleFlag(arg2);
35797 wxPyEndAllowThreads(__tstate);
35798 if (PyErr_Occurred()) SWIG_fail;
35799 }
35800 resultobj = SWIG_Py_Void();
35801 return resultobj;
35802 fail:
35803 return NULL;
35804 }
35805
35806
35807 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35808 PyObject *resultobj = 0;
35809 wxWindow *arg1 = (wxWindow *) 0 ;
35810 long result;
35811 void *argp1 = 0 ;
35812 int res1 = 0 ;
35813 PyObject *swig_obj[1] ;
35814
35815 if (!args) SWIG_fail;
35816 swig_obj[0] = args;
35817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35818 if (!SWIG_IsOK(res1)) {
35819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35820 }
35821 arg1 = reinterpret_cast< wxWindow * >(argp1);
35822 {
35823 PyThreadState* __tstate = wxPyBeginAllowThreads();
35824 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
35825 wxPyEndAllowThreads(__tstate);
35826 if (PyErr_Occurred()) SWIG_fail;
35827 }
35828 resultobj = SWIG_From_long(static_cast< long >(result));
35829 return resultobj;
35830 fail:
35831 return NULL;
35832 }
35833
35834
35835 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35836 PyObject *resultobj = 0;
35837 wxWindow *arg1 = (wxWindow *) 0 ;
35838 int arg2 ;
35839 bool result;
35840 void *argp1 = 0 ;
35841 int res1 = 0 ;
35842 int val2 ;
35843 int ecode2 = 0 ;
35844 PyObject * obj0 = 0 ;
35845 PyObject * obj1 = 0 ;
35846 char * kwnames[] = {
35847 (char *) "self",(char *) "flag", NULL
35848 };
35849
35850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35852 if (!SWIG_IsOK(res1)) {
35853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35854 }
35855 arg1 = reinterpret_cast< wxWindow * >(argp1);
35856 ecode2 = SWIG_AsVal_int(obj1, &val2);
35857 if (!SWIG_IsOK(ecode2)) {
35858 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
35859 }
35860 arg2 = static_cast< int >(val2);
35861 {
35862 PyThreadState* __tstate = wxPyBeginAllowThreads();
35863 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
35864 wxPyEndAllowThreads(__tstate);
35865 if (PyErr_Occurred()) SWIG_fail;
35866 }
35867 {
35868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35869 }
35870 return resultobj;
35871 fail:
35872 return NULL;
35873 }
35874
35875
35876 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35877 PyObject *resultobj = 0;
35878 wxWindow *arg1 = (wxWindow *) 0 ;
35879 bool result;
35880 void *argp1 = 0 ;
35881 int res1 = 0 ;
35882 PyObject *swig_obj[1] ;
35883
35884 if (!args) SWIG_fail;
35885 swig_obj[0] = args;
35886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35887 if (!SWIG_IsOK(res1)) {
35888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
35889 }
35890 arg1 = reinterpret_cast< wxWindow * >(argp1);
35891 {
35892 PyThreadState* __tstate = wxPyBeginAllowThreads();
35893 result = (bool)((wxWindow const *)arg1)->IsRetained();
35894 wxPyEndAllowThreads(__tstate);
35895 if (PyErr_Occurred()) SWIG_fail;
35896 }
35897 {
35898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35899 }
35900 return resultobj;
35901 fail:
35902 return NULL;
35903 }
35904
35905
35906 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35907 PyObject *resultobj = 0;
35908 wxWindow *arg1 = (wxWindow *) 0 ;
35909 long arg2 ;
35910 void *argp1 = 0 ;
35911 int res1 = 0 ;
35912 long val2 ;
35913 int ecode2 = 0 ;
35914 PyObject * obj0 = 0 ;
35915 PyObject * obj1 = 0 ;
35916 char * kwnames[] = {
35917 (char *) "self",(char *) "exStyle", NULL
35918 };
35919
35920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35922 if (!SWIG_IsOK(res1)) {
35923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35924 }
35925 arg1 = reinterpret_cast< wxWindow * >(argp1);
35926 ecode2 = SWIG_AsVal_long(obj1, &val2);
35927 if (!SWIG_IsOK(ecode2)) {
35928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
35929 }
35930 arg2 = static_cast< long >(val2);
35931 {
35932 PyThreadState* __tstate = wxPyBeginAllowThreads();
35933 (arg1)->SetExtraStyle(arg2);
35934 wxPyEndAllowThreads(__tstate);
35935 if (PyErr_Occurred()) SWIG_fail;
35936 }
35937 resultobj = SWIG_Py_Void();
35938 return resultobj;
35939 fail:
35940 return NULL;
35941 }
35942
35943
35944 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35945 PyObject *resultobj = 0;
35946 wxWindow *arg1 = (wxWindow *) 0 ;
35947 long result;
35948 void *argp1 = 0 ;
35949 int res1 = 0 ;
35950 PyObject *swig_obj[1] ;
35951
35952 if (!args) SWIG_fail;
35953 swig_obj[0] = args;
35954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35955 if (!SWIG_IsOK(res1)) {
35956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35957 }
35958 arg1 = reinterpret_cast< wxWindow * >(argp1);
35959 {
35960 PyThreadState* __tstate = wxPyBeginAllowThreads();
35961 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
35962 wxPyEndAllowThreads(__tstate);
35963 if (PyErr_Occurred()) SWIG_fail;
35964 }
35965 resultobj = SWIG_From_long(static_cast< long >(result));
35966 return resultobj;
35967 fail:
35968 return NULL;
35969 }
35970
35971
35972 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35973 PyObject *resultobj = 0;
35974 wxWindow *arg1 = (wxWindow *) 0 ;
35975 bool arg2 = (bool) true ;
35976 void *argp1 = 0 ;
35977 int res1 = 0 ;
35978 bool val2 ;
35979 int ecode2 = 0 ;
35980 PyObject * obj0 = 0 ;
35981 PyObject * obj1 = 0 ;
35982 char * kwnames[] = {
35983 (char *) "self",(char *) "modal", NULL
35984 };
35985
35986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
35987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35988 if (!SWIG_IsOK(res1)) {
35989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
35990 }
35991 arg1 = reinterpret_cast< wxWindow * >(argp1);
35992 if (obj1) {
35993 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35994 if (!SWIG_IsOK(ecode2)) {
35995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
35996 }
35997 arg2 = static_cast< bool >(val2);
35998 }
35999 {
36000 PyThreadState* __tstate = wxPyBeginAllowThreads();
36001 (arg1)->MakeModal(arg2);
36002 wxPyEndAllowThreads(__tstate);
36003 if (PyErr_Occurred()) SWIG_fail;
36004 }
36005 resultobj = SWIG_Py_Void();
36006 return resultobj;
36007 fail:
36008 return NULL;
36009 }
36010
36011
36012 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36013 PyObject *resultobj = 0;
36014 wxWindow *arg1 = (wxWindow *) 0 ;
36015 bool arg2 ;
36016 void *argp1 = 0 ;
36017 int res1 = 0 ;
36018 bool val2 ;
36019 int ecode2 = 0 ;
36020 PyObject * obj0 = 0 ;
36021 PyObject * obj1 = 0 ;
36022 char * kwnames[] = {
36023 (char *) "self",(char *) "enableTheme", NULL
36024 };
36025
36026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
36027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36028 if (!SWIG_IsOK(res1)) {
36029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
36030 }
36031 arg1 = reinterpret_cast< wxWindow * >(argp1);
36032 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36033 if (!SWIG_IsOK(ecode2)) {
36034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
36035 }
36036 arg2 = static_cast< bool >(val2);
36037 {
36038 PyThreadState* __tstate = wxPyBeginAllowThreads();
36039 (arg1)->SetThemeEnabled(arg2);
36040 wxPyEndAllowThreads(__tstate);
36041 if (PyErr_Occurred()) SWIG_fail;
36042 }
36043 resultobj = SWIG_Py_Void();
36044 return resultobj;
36045 fail:
36046 return NULL;
36047 }
36048
36049
36050 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36051 PyObject *resultobj = 0;
36052 wxWindow *arg1 = (wxWindow *) 0 ;
36053 bool result;
36054 void *argp1 = 0 ;
36055 int res1 = 0 ;
36056 PyObject *swig_obj[1] ;
36057
36058 if (!args) SWIG_fail;
36059 swig_obj[0] = args;
36060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36061 if (!SWIG_IsOK(res1)) {
36062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
36063 }
36064 arg1 = reinterpret_cast< wxWindow * >(argp1);
36065 {
36066 PyThreadState* __tstate = wxPyBeginAllowThreads();
36067 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
36068 wxPyEndAllowThreads(__tstate);
36069 if (PyErr_Occurred()) SWIG_fail;
36070 }
36071 {
36072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36073 }
36074 return resultobj;
36075 fail:
36076 return NULL;
36077 }
36078
36079
36080 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36081 PyObject *resultobj = 0;
36082 wxWindow *arg1 = (wxWindow *) 0 ;
36083 void *argp1 = 0 ;
36084 int res1 = 0 ;
36085 PyObject *swig_obj[1] ;
36086
36087 if (!args) SWIG_fail;
36088 swig_obj[0] = args;
36089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36090 if (!SWIG_IsOK(res1)) {
36091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
36092 }
36093 arg1 = reinterpret_cast< wxWindow * >(argp1);
36094 {
36095 PyThreadState* __tstate = wxPyBeginAllowThreads();
36096 (arg1)->SetFocus();
36097 wxPyEndAllowThreads(__tstate);
36098 if (PyErr_Occurred()) SWIG_fail;
36099 }
36100 resultobj = SWIG_Py_Void();
36101 return resultobj;
36102 fail:
36103 return NULL;
36104 }
36105
36106
36107 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36108 PyObject *resultobj = 0;
36109 wxWindow *arg1 = (wxWindow *) 0 ;
36110 void *argp1 = 0 ;
36111 int res1 = 0 ;
36112 PyObject *swig_obj[1] ;
36113
36114 if (!args) SWIG_fail;
36115 swig_obj[0] = args;
36116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36117 if (!SWIG_IsOK(res1)) {
36118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
36119 }
36120 arg1 = reinterpret_cast< wxWindow * >(argp1);
36121 {
36122 PyThreadState* __tstate = wxPyBeginAllowThreads();
36123 (arg1)->SetFocusFromKbd();
36124 wxPyEndAllowThreads(__tstate);
36125 if (PyErr_Occurred()) SWIG_fail;
36126 }
36127 resultobj = SWIG_Py_Void();
36128 return resultobj;
36129 fail:
36130 return NULL;
36131 }
36132
36133
36134 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36135 PyObject *resultobj = 0;
36136 wxWindow *result = 0 ;
36137
36138 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
36139 {
36140 if (!wxPyCheckForApp()) SWIG_fail;
36141 PyThreadState* __tstate = wxPyBeginAllowThreads();
36142 result = (wxWindow *)wxWindow::FindFocus();
36143 wxPyEndAllowThreads(__tstate);
36144 if (PyErr_Occurred()) SWIG_fail;
36145 }
36146 {
36147 resultobj = wxPyMake_wxObject(result, 0);
36148 }
36149 return resultobj;
36150 fail:
36151 return NULL;
36152 }
36153
36154
36155 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36156 PyObject *resultobj = 0;
36157 wxWindow *arg1 = (wxWindow *) 0 ;
36158 bool result;
36159 void *argp1 = 0 ;
36160 int res1 = 0 ;
36161 PyObject *swig_obj[1] ;
36162
36163 if (!args) SWIG_fail;
36164 swig_obj[0] = args;
36165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36166 if (!SWIG_IsOK(res1)) {
36167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36168 }
36169 arg1 = reinterpret_cast< wxWindow * >(argp1);
36170 {
36171 PyThreadState* __tstate = wxPyBeginAllowThreads();
36172 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
36173 wxPyEndAllowThreads(__tstate);
36174 if (PyErr_Occurred()) SWIG_fail;
36175 }
36176 {
36177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36178 }
36179 return resultobj;
36180 fail:
36181 return NULL;
36182 }
36183
36184
36185 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36186 PyObject *resultobj = 0;
36187 wxWindow *arg1 = (wxWindow *) 0 ;
36188 bool result;
36189 void *argp1 = 0 ;
36190 int res1 = 0 ;
36191 PyObject *swig_obj[1] ;
36192
36193 if (!args) SWIG_fail;
36194 swig_obj[0] = args;
36195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36196 if (!SWIG_IsOK(res1)) {
36197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36198 }
36199 arg1 = reinterpret_cast< wxWindow * >(argp1);
36200 {
36201 PyThreadState* __tstate = wxPyBeginAllowThreads();
36202 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
36203 wxPyEndAllowThreads(__tstate);
36204 if (PyErr_Occurred()) SWIG_fail;
36205 }
36206 {
36207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36208 }
36209 return resultobj;
36210 fail:
36211 return NULL;
36212 }
36213
36214
36215 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36216 PyObject *resultobj = 0;
36217 wxWindow *arg1 = (wxWindow *) 0 ;
36218 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
36219 bool result;
36220 void *argp1 = 0 ;
36221 int res1 = 0 ;
36222 int val2 ;
36223 int ecode2 = 0 ;
36224 PyObject * obj0 = 0 ;
36225 PyObject * obj1 = 0 ;
36226 char * kwnames[] = {
36227 (char *) "self",(char *) "flags", NULL
36228 };
36229
36230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
36231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36232 if (!SWIG_IsOK(res1)) {
36233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
36234 }
36235 arg1 = reinterpret_cast< wxWindow * >(argp1);
36236 if (obj1) {
36237 ecode2 = SWIG_AsVal_int(obj1, &val2);
36238 if (!SWIG_IsOK(ecode2)) {
36239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
36240 }
36241 arg2 = static_cast< int >(val2);
36242 }
36243 {
36244 PyThreadState* __tstate = wxPyBeginAllowThreads();
36245 result = (bool)(arg1)->Navigate(arg2);
36246 wxPyEndAllowThreads(__tstate);
36247 if (PyErr_Occurred()) SWIG_fail;
36248 }
36249 {
36250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36251 }
36252 return resultobj;
36253 fail:
36254 return NULL;
36255 }
36256
36257
36258 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36259 PyObject *resultobj = 0;
36260 wxWindow *arg1 = (wxWindow *) 0 ;
36261 wxWindow *arg2 = (wxWindow *) 0 ;
36262 void *argp1 = 0 ;
36263 int res1 = 0 ;
36264 void *argp2 = 0 ;
36265 int res2 = 0 ;
36266 PyObject * obj0 = 0 ;
36267 PyObject * obj1 = 0 ;
36268 char * kwnames[] = {
36269 (char *) "self",(char *) "win", NULL
36270 };
36271
36272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36274 if (!SWIG_IsOK(res1)) {
36275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36276 }
36277 arg1 = reinterpret_cast< wxWindow * >(argp1);
36278 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36279 if (!SWIG_IsOK(res2)) {
36280 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36281 }
36282 arg2 = reinterpret_cast< wxWindow * >(argp2);
36283 {
36284 PyThreadState* __tstate = wxPyBeginAllowThreads();
36285 (arg1)->MoveAfterInTabOrder(arg2);
36286 wxPyEndAllowThreads(__tstate);
36287 if (PyErr_Occurred()) SWIG_fail;
36288 }
36289 resultobj = SWIG_Py_Void();
36290 return resultobj;
36291 fail:
36292 return NULL;
36293 }
36294
36295
36296 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36297 PyObject *resultobj = 0;
36298 wxWindow *arg1 = (wxWindow *) 0 ;
36299 wxWindow *arg2 = (wxWindow *) 0 ;
36300 void *argp1 = 0 ;
36301 int res1 = 0 ;
36302 void *argp2 = 0 ;
36303 int res2 = 0 ;
36304 PyObject * obj0 = 0 ;
36305 PyObject * obj1 = 0 ;
36306 char * kwnames[] = {
36307 (char *) "self",(char *) "win", NULL
36308 };
36309
36310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36312 if (!SWIG_IsOK(res1)) {
36313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36314 }
36315 arg1 = reinterpret_cast< wxWindow * >(argp1);
36316 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36317 if (!SWIG_IsOK(res2)) {
36318 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36319 }
36320 arg2 = reinterpret_cast< wxWindow * >(argp2);
36321 {
36322 PyThreadState* __tstate = wxPyBeginAllowThreads();
36323 (arg1)->MoveBeforeInTabOrder(arg2);
36324 wxPyEndAllowThreads(__tstate);
36325 if (PyErr_Occurred()) SWIG_fail;
36326 }
36327 resultobj = SWIG_Py_Void();
36328 return resultobj;
36329 fail:
36330 return NULL;
36331 }
36332
36333
36334 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36335 PyObject *resultobj = 0;
36336 wxWindow *arg1 = (wxWindow *) 0 ;
36337 PyObject *result = 0 ;
36338 void *argp1 = 0 ;
36339 int res1 = 0 ;
36340 PyObject *swig_obj[1] ;
36341
36342 if (!args) SWIG_fail;
36343 swig_obj[0] = args;
36344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36345 if (!SWIG_IsOK(res1)) {
36346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
36347 }
36348 arg1 = reinterpret_cast< wxWindow * >(argp1);
36349 {
36350 PyThreadState* __tstate = wxPyBeginAllowThreads();
36351 result = (PyObject *)wxWindow_GetChildren(arg1);
36352 wxPyEndAllowThreads(__tstate);
36353 if (PyErr_Occurred()) SWIG_fail;
36354 }
36355 resultobj = result;
36356 return resultobj;
36357 fail:
36358 return NULL;
36359 }
36360
36361
36362 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36363 PyObject *resultobj = 0;
36364 wxWindow *arg1 = (wxWindow *) 0 ;
36365 wxWindow *result = 0 ;
36366 void *argp1 = 0 ;
36367 int res1 = 0 ;
36368 PyObject *swig_obj[1] ;
36369
36370 if (!args) SWIG_fail;
36371 swig_obj[0] = args;
36372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36373 if (!SWIG_IsOK(res1)) {
36374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36375 }
36376 arg1 = reinterpret_cast< wxWindow * >(argp1);
36377 {
36378 PyThreadState* __tstate = wxPyBeginAllowThreads();
36379 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
36380 wxPyEndAllowThreads(__tstate);
36381 if (PyErr_Occurred()) SWIG_fail;
36382 }
36383 {
36384 resultobj = wxPyMake_wxObject(result, 0);
36385 }
36386 return resultobj;
36387 fail:
36388 return NULL;
36389 }
36390
36391
36392 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36393 PyObject *resultobj = 0;
36394 wxWindow *arg1 = (wxWindow *) 0 ;
36395 wxWindow *result = 0 ;
36396 void *argp1 = 0 ;
36397 int res1 = 0 ;
36398 PyObject *swig_obj[1] ;
36399
36400 if (!args) SWIG_fail;
36401 swig_obj[0] = args;
36402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36403 if (!SWIG_IsOK(res1)) {
36404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36405 }
36406 arg1 = reinterpret_cast< wxWindow * >(argp1);
36407 {
36408 PyThreadState* __tstate = wxPyBeginAllowThreads();
36409 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
36410 wxPyEndAllowThreads(__tstate);
36411 if (PyErr_Occurred()) SWIG_fail;
36412 }
36413 {
36414 resultobj = wxPyMake_wxObject(result, 0);
36415 }
36416 return resultobj;
36417 fail:
36418 return NULL;
36419 }
36420
36421
36422 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36423 PyObject *resultobj = 0;
36424 wxWindow *arg1 = (wxWindow *) 0 ;
36425 bool result;
36426 void *argp1 = 0 ;
36427 int res1 = 0 ;
36428 PyObject *swig_obj[1] ;
36429
36430 if (!args) SWIG_fail;
36431 swig_obj[0] = args;
36432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36433 if (!SWIG_IsOK(res1)) {
36434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
36435 }
36436 arg1 = reinterpret_cast< wxWindow * >(argp1);
36437 {
36438 PyThreadState* __tstate = wxPyBeginAllowThreads();
36439 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
36440 wxPyEndAllowThreads(__tstate);
36441 if (PyErr_Occurred()) SWIG_fail;
36442 }
36443 {
36444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36445 }
36446 return resultobj;
36447 fail:
36448 return NULL;
36449 }
36450
36451
36452 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36453 PyObject *resultobj = 0;
36454 wxWindow *arg1 = (wxWindow *) 0 ;
36455 wxWindow *arg2 = (wxWindow *) 0 ;
36456 bool result;
36457 void *argp1 = 0 ;
36458 int res1 = 0 ;
36459 void *argp2 = 0 ;
36460 int res2 = 0 ;
36461 PyObject * obj0 = 0 ;
36462 PyObject * obj1 = 0 ;
36463 char * kwnames[] = {
36464 (char *) "self",(char *) "newParent", NULL
36465 };
36466
36467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
36468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36469 if (!SWIG_IsOK(res1)) {
36470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
36471 }
36472 arg1 = reinterpret_cast< wxWindow * >(argp1);
36473 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36474 if (!SWIG_IsOK(res2)) {
36475 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
36476 }
36477 arg2 = reinterpret_cast< wxWindow * >(argp2);
36478 {
36479 PyThreadState* __tstate = wxPyBeginAllowThreads();
36480 result = (bool)(arg1)->Reparent(arg2);
36481 wxPyEndAllowThreads(__tstate);
36482 if (PyErr_Occurred()) SWIG_fail;
36483 }
36484 {
36485 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36486 }
36487 return resultobj;
36488 fail:
36489 return NULL;
36490 }
36491
36492
36493 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36494 PyObject *resultobj = 0;
36495 wxWindow *arg1 = (wxWindow *) 0 ;
36496 wxWindow *arg2 = (wxWindow *) 0 ;
36497 void *argp1 = 0 ;
36498 int res1 = 0 ;
36499 void *argp2 = 0 ;
36500 int res2 = 0 ;
36501 PyObject * obj0 = 0 ;
36502 PyObject * obj1 = 0 ;
36503 char * kwnames[] = {
36504 (char *) "self",(char *) "child", NULL
36505 };
36506
36507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
36508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36509 if (!SWIG_IsOK(res1)) {
36510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36511 }
36512 arg1 = reinterpret_cast< wxWindow * >(argp1);
36513 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36514 if (!SWIG_IsOK(res2)) {
36515 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36516 }
36517 arg2 = reinterpret_cast< wxWindow * >(argp2);
36518 {
36519 PyThreadState* __tstate = wxPyBeginAllowThreads();
36520 (arg1)->AddChild(arg2);
36521 wxPyEndAllowThreads(__tstate);
36522 if (PyErr_Occurred()) SWIG_fail;
36523 }
36524 resultobj = SWIG_Py_Void();
36525 return resultobj;
36526 fail:
36527 return NULL;
36528 }
36529
36530
36531 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36532 PyObject *resultobj = 0;
36533 wxWindow *arg1 = (wxWindow *) 0 ;
36534 wxWindow *arg2 = (wxWindow *) 0 ;
36535 void *argp1 = 0 ;
36536 int res1 = 0 ;
36537 void *argp2 = 0 ;
36538 int res2 = 0 ;
36539 PyObject * obj0 = 0 ;
36540 PyObject * obj1 = 0 ;
36541 char * kwnames[] = {
36542 (char *) "self",(char *) "child", NULL
36543 };
36544
36545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
36546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36547 if (!SWIG_IsOK(res1)) {
36548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36549 }
36550 arg1 = reinterpret_cast< wxWindow * >(argp1);
36551 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36552 if (!SWIG_IsOK(res2)) {
36553 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36554 }
36555 arg2 = reinterpret_cast< wxWindow * >(argp2);
36556 {
36557 PyThreadState* __tstate = wxPyBeginAllowThreads();
36558 (arg1)->RemoveChild(arg2);
36559 wxPyEndAllowThreads(__tstate);
36560 if (PyErr_Occurred()) SWIG_fail;
36561 }
36562 resultobj = SWIG_Py_Void();
36563 return resultobj;
36564 fail:
36565 return NULL;
36566 }
36567
36568
36569 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36570 PyObject *resultobj = 0;
36571 wxWindow *arg1 = (wxWindow *) 0 ;
36572 bool arg2 ;
36573 void *argp1 = 0 ;
36574 int res1 = 0 ;
36575 bool val2 ;
36576 int ecode2 = 0 ;
36577 PyObject * obj0 = 0 ;
36578 PyObject * obj1 = 0 ;
36579 char * kwnames[] = {
36580 (char *) "self",(char *) "on", NULL
36581 };
36582
36583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
36584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36585 if (!SWIG_IsOK(res1)) {
36586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
36587 }
36588 arg1 = reinterpret_cast< wxWindow * >(argp1);
36589 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36590 if (!SWIG_IsOK(ecode2)) {
36591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
36592 }
36593 arg2 = static_cast< bool >(val2);
36594 {
36595 PyThreadState* __tstate = wxPyBeginAllowThreads();
36596 (arg1)->SetDoubleBuffered(arg2);
36597 wxPyEndAllowThreads(__tstate);
36598 if (PyErr_Occurred()) SWIG_fail;
36599 }
36600 resultobj = SWIG_Py_Void();
36601 return resultobj;
36602 fail:
36603 return NULL;
36604 }
36605
36606
36607 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36608 PyObject *resultobj = 0;
36609 wxWindow *arg1 = (wxWindow *) 0 ;
36610 long arg2 ;
36611 wxWindow *result = 0 ;
36612 void *argp1 = 0 ;
36613 int res1 = 0 ;
36614 long val2 ;
36615 int ecode2 = 0 ;
36616 PyObject * obj0 = 0 ;
36617 PyObject * obj1 = 0 ;
36618 char * kwnames[] = {
36619 (char *) "self",(char *) "winid", NULL
36620 };
36621
36622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
36623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36624 if (!SWIG_IsOK(res1)) {
36625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
36626 }
36627 arg1 = reinterpret_cast< wxWindow * >(argp1);
36628 ecode2 = SWIG_AsVal_long(obj1, &val2);
36629 if (!SWIG_IsOK(ecode2)) {
36630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
36631 }
36632 arg2 = static_cast< long >(val2);
36633 {
36634 PyThreadState* __tstate = wxPyBeginAllowThreads();
36635 result = (wxWindow *)(arg1)->FindWindow(arg2);
36636 wxPyEndAllowThreads(__tstate);
36637 if (PyErr_Occurred()) SWIG_fail;
36638 }
36639 {
36640 resultobj = wxPyMake_wxObject(result, 0);
36641 }
36642 return resultobj;
36643 fail:
36644 return NULL;
36645 }
36646
36647
36648 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36649 PyObject *resultobj = 0;
36650 wxWindow *arg1 = (wxWindow *) 0 ;
36651 wxString *arg2 = 0 ;
36652 wxWindow *result = 0 ;
36653 void *argp1 = 0 ;
36654 int res1 = 0 ;
36655 bool temp2 = false ;
36656 PyObject * obj0 = 0 ;
36657 PyObject * obj1 = 0 ;
36658 char * kwnames[] = {
36659 (char *) "self",(char *) "name", NULL
36660 };
36661
36662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
36663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36664 if (!SWIG_IsOK(res1)) {
36665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
36666 }
36667 arg1 = reinterpret_cast< wxWindow * >(argp1);
36668 {
36669 arg2 = wxString_in_helper(obj1);
36670 if (arg2 == NULL) SWIG_fail;
36671 temp2 = true;
36672 }
36673 {
36674 PyThreadState* __tstate = wxPyBeginAllowThreads();
36675 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
36676 wxPyEndAllowThreads(__tstate);
36677 if (PyErr_Occurred()) SWIG_fail;
36678 }
36679 {
36680 resultobj = wxPyMake_wxObject(result, 0);
36681 }
36682 {
36683 if (temp2)
36684 delete arg2;
36685 }
36686 return resultobj;
36687 fail:
36688 {
36689 if (temp2)
36690 delete arg2;
36691 }
36692 return NULL;
36693 }
36694
36695
36696 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36697 PyObject *resultobj = 0;
36698 wxWindow *arg1 = (wxWindow *) 0 ;
36699 wxEvtHandler *result = 0 ;
36700 void *argp1 = 0 ;
36701 int res1 = 0 ;
36702 PyObject *swig_obj[1] ;
36703
36704 if (!args) SWIG_fail;
36705 swig_obj[0] = args;
36706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36707 if (!SWIG_IsOK(res1)) {
36708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
36709 }
36710 arg1 = reinterpret_cast< wxWindow * >(argp1);
36711 {
36712 PyThreadState* __tstate = wxPyBeginAllowThreads();
36713 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
36714 wxPyEndAllowThreads(__tstate);
36715 if (PyErr_Occurred()) SWIG_fail;
36716 }
36717 {
36718 resultobj = wxPyMake_wxObject(result, 0);
36719 }
36720 return resultobj;
36721 fail:
36722 return NULL;
36723 }
36724
36725
36726 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36727 PyObject *resultobj = 0;
36728 wxWindow *arg1 = (wxWindow *) 0 ;
36729 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36730 void *argp1 = 0 ;
36731 int res1 = 0 ;
36732 void *argp2 = 0 ;
36733 int res2 = 0 ;
36734 PyObject * obj0 = 0 ;
36735 PyObject * obj1 = 0 ;
36736 char * kwnames[] = {
36737 (char *) "self",(char *) "handler", NULL
36738 };
36739
36740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36742 if (!SWIG_IsOK(res1)) {
36743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36744 }
36745 arg1 = reinterpret_cast< wxWindow * >(argp1);
36746 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36747 if (!SWIG_IsOK(res2)) {
36748 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36749 }
36750 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36751 {
36752 PyThreadState* __tstate = wxPyBeginAllowThreads();
36753 (arg1)->SetEventHandler(arg2);
36754 wxPyEndAllowThreads(__tstate);
36755 if (PyErr_Occurred()) SWIG_fail;
36756 }
36757 resultobj = SWIG_Py_Void();
36758 return resultobj;
36759 fail:
36760 return NULL;
36761 }
36762
36763
36764 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36765 PyObject *resultobj = 0;
36766 wxWindow *arg1 = (wxWindow *) 0 ;
36767 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36768 void *argp1 = 0 ;
36769 int res1 = 0 ;
36770 void *argp2 = 0 ;
36771 int res2 = 0 ;
36772 PyObject * obj0 = 0 ;
36773 PyObject * obj1 = 0 ;
36774 char * kwnames[] = {
36775 (char *) "self",(char *) "handler", NULL
36776 };
36777
36778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36780 if (!SWIG_IsOK(res1)) {
36781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36782 }
36783 arg1 = reinterpret_cast< wxWindow * >(argp1);
36784 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36785 if (!SWIG_IsOK(res2)) {
36786 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36787 }
36788 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36789 {
36790 PyThreadState* __tstate = wxPyBeginAllowThreads();
36791 (arg1)->PushEventHandler(arg2);
36792 wxPyEndAllowThreads(__tstate);
36793 if (PyErr_Occurred()) SWIG_fail;
36794 }
36795 resultobj = SWIG_Py_Void();
36796 return resultobj;
36797 fail:
36798 return NULL;
36799 }
36800
36801
36802 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36803 PyObject *resultobj = 0;
36804 wxWindow *arg1 = (wxWindow *) 0 ;
36805 bool arg2 = (bool) false ;
36806 wxEvtHandler *result = 0 ;
36807 void *argp1 = 0 ;
36808 int res1 = 0 ;
36809 bool val2 ;
36810 int ecode2 = 0 ;
36811 PyObject * obj0 = 0 ;
36812 PyObject * obj1 = 0 ;
36813 char * kwnames[] = {
36814 (char *) "self",(char *) "deleteHandler", NULL
36815 };
36816
36817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36819 if (!SWIG_IsOK(res1)) {
36820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36821 }
36822 arg1 = reinterpret_cast< wxWindow * >(argp1);
36823 if (obj1) {
36824 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36825 if (!SWIG_IsOK(ecode2)) {
36826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
36827 }
36828 arg2 = static_cast< bool >(val2);
36829 }
36830 {
36831 PyThreadState* __tstate = wxPyBeginAllowThreads();
36832 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
36833 wxPyEndAllowThreads(__tstate);
36834 if (PyErr_Occurred()) SWIG_fail;
36835 }
36836 {
36837 resultobj = wxPyMake_wxObject(result, 0);
36838 }
36839 return resultobj;
36840 fail:
36841 return NULL;
36842 }
36843
36844
36845 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36846 PyObject *resultobj = 0;
36847 wxWindow *arg1 = (wxWindow *) 0 ;
36848 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36849 bool result;
36850 void *argp1 = 0 ;
36851 int res1 = 0 ;
36852 void *argp2 = 0 ;
36853 int res2 = 0 ;
36854 PyObject * obj0 = 0 ;
36855 PyObject * obj1 = 0 ;
36856 char * kwnames[] = {
36857 (char *) "self",(char *) "handler", NULL
36858 };
36859
36860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36862 if (!SWIG_IsOK(res1)) {
36863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36864 }
36865 arg1 = reinterpret_cast< wxWindow * >(argp1);
36866 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36867 if (!SWIG_IsOK(res2)) {
36868 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36869 }
36870 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36871 {
36872 PyThreadState* __tstate = wxPyBeginAllowThreads();
36873 result = (bool)(arg1)->RemoveEventHandler(arg2);
36874 wxPyEndAllowThreads(__tstate);
36875 if (PyErr_Occurred()) SWIG_fail;
36876 }
36877 {
36878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36879 }
36880 return resultobj;
36881 fail:
36882 return NULL;
36883 }
36884
36885
36886 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36887 PyObject *resultobj = 0;
36888 wxWindow *arg1 = (wxWindow *) 0 ;
36889 wxValidator *arg2 = 0 ;
36890 void *argp1 = 0 ;
36891 int res1 = 0 ;
36892 void *argp2 = 0 ;
36893 int res2 = 0 ;
36894 PyObject * obj0 = 0 ;
36895 PyObject * obj1 = 0 ;
36896 char * kwnames[] = {
36897 (char *) "self",(char *) "validator", NULL
36898 };
36899
36900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
36901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36902 if (!SWIG_IsOK(res1)) {
36903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
36904 }
36905 arg1 = reinterpret_cast< wxWindow * >(argp1);
36906 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
36907 if (!SWIG_IsOK(res2)) {
36908 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
36909 }
36910 if (!argp2) {
36911 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
36912 }
36913 arg2 = reinterpret_cast< wxValidator * >(argp2);
36914 {
36915 PyThreadState* __tstate = wxPyBeginAllowThreads();
36916 (arg1)->SetValidator((wxValidator const &)*arg2);
36917 wxPyEndAllowThreads(__tstate);
36918 if (PyErr_Occurred()) SWIG_fail;
36919 }
36920 resultobj = SWIG_Py_Void();
36921 return resultobj;
36922 fail:
36923 return NULL;
36924 }
36925
36926
36927 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36928 PyObject *resultobj = 0;
36929 wxWindow *arg1 = (wxWindow *) 0 ;
36930 wxValidator *result = 0 ;
36931 void *argp1 = 0 ;
36932 int res1 = 0 ;
36933 PyObject *swig_obj[1] ;
36934
36935 if (!args) SWIG_fail;
36936 swig_obj[0] = args;
36937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36938 if (!SWIG_IsOK(res1)) {
36939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
36940 }
36941 arg1 = reinterpret_cast< wxWindow * >(argp1);
36942 {
36943 PyThreadState* __tstate = wxPyBeginAllowThreads();
36944 result = (wxValidator *)(arg1)->GetValidator();
36945 wxPyEndAllowThreads(__tstate);
36946 if (PyErr_Occurred()) SWIG_fail;
36947 }
36948 {
36949 resultobj = wxPyMake_wxObject(result, (bool)0);
36950 }
36951 return resultobj;
36952 fail:
36953 return NULL;
36954 }
36955
36956
36957 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36958 PyObject *resultobj = 0;
36959 wxWindow *arg1 = (wxWindow *) 0 ;
36960 bool result;
36961 void *argp1 = 0 ;
36962 int res1 = 0 ;
36963 PyObject *swig_obj[1] ;
36964
36965 if (!args) SWIG_fail;
36966 swig_obj[0] = args;
36967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36968 if (!SWIG_IsOK(res1)) {
36969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
36970 }
36971 arg1 = reinterpret_cast< wxWindow * >(argp1);
36972 {
36973 PyThreadState* __tstate = wxPyBeginAllowThreads();
36974 result = (bool)(arg1)->Validate();
36975 wxPyEndAllowThreads(__tstate);
36976 if (PyErr_Occurred()) SWIG_fail;
36977 }
36978 {
36979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36980 }
36981 return resultobj;
36982 fail:
36983 return NULL;
36984 }
36985
36986
36987 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36988 PyObject *resultobj = 0;
36989 wxWindow *arg1 = (wxWindow *) 0 ;
36990 bool result;
36991 void *argp1 = 0 ;
36992 int res1 = 0 ;
36993 PyObject *swig_obj[1] ;
36994
36995 if (!args) SWIG_fail;
36996 swig_obj[0] = args;
36997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36998 if (!SWIG_IsOK(res1)) {
36999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37000 }
37001 arg1 = reinterpret_cast< wxWindow * >(argp1);
37002 {
37003 PyThreadState* __tstate = wxPyBeginAllowThreads();
37004 result = (bool)(arg1)->TransferDataToWindow();
37005 wxPyEndAllowThreads(__tstate);
37006 if (PyErr_Occurred()) SWIG_fail;
37007 }
37008 {
37009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37010 }
37011 return resultobj;
37012 fail:
37013 return NULL;
37014 }
37015
37016
37017 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37018 PyObject *resultobj = 0;
37019 wxWindow *arg1 = (wxWindow *) 0 ;
37020 bool result;
37021 void *argp1 = 0 ;
37022 int res1 = 0 ;
37023 PyObject *swig_obj[1] ;
37024
37025 if (!args) SWIG_fail;
37026 swig_obj[0] = args;
37027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37028 if (!SWIG_IsOK(res1)) {
37029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37030 }
37031 arg1 = reinterpret_cast< wxWindow * >(argp1);
37032 {
37033 PyThreadState* __tstate = wxPyBeginAllowThreads();
37034 result = (bool)(arg1)->TransferDataFromWindow();
37035 wxPyEndAllowThreads(__tstate);
37036 if (PyErr_Occurred()) SWIG_fail;
37037 }
37038 {
37039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37040 }
37041 return resultobj;
37042 fail:
37043 return NULL;
37044 }
37045
37046
37047 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37048 PyObject *resultobj = 0;
37049 wxWindow *arg1 = (wxWindow *) 0 ;
37050 void *argp1 = 0 ;
37051 int res1 = 0 ;
37052 PyObject *swig_obj[1] ;
37053
37054 if (!args) SWIG_fail;
37055 swig_obj[0] = args;
37056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37057 if (!SWIG_IsOK(res1)) {
37058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37059 }
37060 arg1 = reinterpret_cast< wxWindow * >(argp1);
37061 {
37062 PyThreadState* __tstate = wxPyBeginAllowThreads();
37063 (arg1)->InitDialog();
37064 wxPyEndAllowThreads(__tstate);
37065 if (PyErr_Occurred()) SWIG_fail;
37066 }
37067 resultobj = SWIG_Py_Void();
37068 return resultobj;
37069 fail:
37070 return NULL;
37071 }
37072
37073
37074 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37075 PyObject *resultobj = 0;
37076 wxWindow *arg1 = (wxWindow *) 0 ;
37077 wxAcceleratorTable *arg2 = 0 ;
37078 void *argp1 = 0 ;
37079 int res1 = 0 ;
37080 void *argp2 = 0 ;
37081 int res2 = 0 ;
37082 PyObject * obj0 = 0 ;
37083 PyObject * obj1 = 0 ;
37084 char * kwnames[] = {
37085 (char *) "self",(char *) "accel", NULL
37086 };
37087
37088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
37089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37090 if (!SWIG_IsOK(res1)) {
37091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37092 }
37093 arg1 = reinterpret_cast< wxWindow * >(argp1);
37094 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
37095 if (!SWIG_IsOK(res2)) {
37096 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37097 }
37098 if (!argp2) {
37099 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37100 }
37101 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
37102 {
37103 PyThreadState* __tstate = wxPyBeginAllowThreads();
37104 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
37105 wxPyEndAllowThreads(__tstate);
37106 if (PyErr_Occurred()) SWIG_fail;
37107 }
37108 resultobj = SWIG_Py_Void();
37109 return resultobj;
37110 fail:
37111 return NULL;
37112 }
37113
37114
37115 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37116 PyObject *resultobj = 0;
37117 wxWindow *arg1 = (wxWindow *) 0 ;
37118 wxAcceleratorTable *result = 0 ;
37119 void *argp1 = 0 ;
37120 int res1 = 0 ;
37121 PyObject *swig_obj[1] ;
37122
37123 if (!args) SWIG_fail;
37124 swig_obj[0] = args;
37125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37126 if (!SWIG_IsOK(res1)) {
37127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37128 }
37129 arg1 = reinterpret_cast< wxWindow * >(argp1);
37130 {
37131 PyThreadState* __tstate = wxPyBeginAllowThreads();
37132 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
37133 wxPyEndAllowThreads(__tstate);
37134 if (PyErr_Occurred()) SWIG_fail;
37135 }
37136 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
37137 return resultobj;
37138 fail:
37139 return NULL;
37140 }
37141
37142
37143 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37144 PyObject *resultobj = 0;
37145 wxWindow *arg1 = (wxWindow *) 0 ;
37146 int arg2 ;
37147 int arg3 ;
37148 int arg4 ;
37149 bool result;
37150 void *argp1 = 0 ;
37151 int res1 = 0 ;
37152 int val2 ;
37153 int ecode2 = 0 ;
37154 int val3 ;
37155 int ecode3 = 0 ;
37156 int val4 ;
37157 int ecode4 = 0 ;
37158 PyObject * obj0 = 0 ;
37159 PyObject * obj1 = 0 ;
37160 PyObject * obj2 = 0 ;
37161 PyObject * obj3 = 0 ;
37162 char * kwnames[] = {
37163 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
37164 };
37165
37166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37168 if (!SWIG_IsOK(res1)) {
37169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37170 }
37171 arg1 = reinterpret_cast< wxWindow * >(argp1);
37172 ecode2 = SWIG_AsVal_int(obj1, &val2);
37173 if (!SWIG_IsOK(ecode2)) {
37174 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
37175 }
37176 arg2 = static_cast< int >(val2);
37177 ecode3 = SWIG_AsVal_int(obj2, &val3);
37178 if (!SWIG_IsOK(ecode3)) {
37179 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
37180 }
37181 arg3 = static_cast< int >(val3);
37182 ecode4 = SWIG_AsVal_int(obj3, &val4);
37183 if (!SWIG_IsOK(ecode4)) {
37184 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
37185 }
37186 arg4 = static_cast< int >(val4);
37187 {
37188 PyThreadState* __tstate = wxPyBeginAllowThreads();
37189 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
37190 wxPyEndAllowThreads(__tstate);
37191 if (PyErr_Occurred()) SWIG_fail;
37192 }
37193 {
37194 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37195 }
37196 return resultobj;
37197 fail:
37198 return NULL;
37199 }
37200
37201
37202 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37203 PyObject *resultobj = 0;
37204 wxWindow *arg1 = (wxWindow *) 0 ;
37205 int arg2 ;
37206 bool result;
37207 void *argp1 = 0 ;
37208 int res1 = 0 ;
37209 int val2 ;
37210 int ecode2 = 0 ;
37211 PyObject * obj0 = 0 ;
37212 PyObject * obj1 = 0 ;
37213 char * kwnames[] = {
37214 (char *) "self",(char *) "hotkeyId", NULL
37215 };
37216
37217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
37218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37219 if (!SWIG_IsOK(res1)) {
37220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37221 }
37222 arg1 = reinterpret_cast< wxWindow * >(argp1);
37223 ecode2 = SWIG_AsVal_int(obj1, &val2);
37224 if (!SWIG_IsOK(ecode2)) {
37225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
37226 }
37227 arg2 = static_cast< int >(val2);
37228 {
37229 PyThreadState* __tstate = wxPyBeginAllowThreads();
37230 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
37231 wxPyEndAllowThreads(__tstate);
37232 if (PyErr_Occurred()) SWIG_fail;
37233 }
37234 {
37235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37236 }
37237 return resultobj;
37238 fail:
37239 return NULL;
37240 }
37241
37242
37243 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37244 PyObject *resultobj = 0;
37245 wxWindow *arg1 = (wxWindow *) 0 ;
37246 wxPoint *arg2 = 0 ;
37247 wxPoint result;
37248 void *argp1 = 0 ;
37249 int res1 = 0 ;
37250 wxPoint temp2 ;
37251 PyObject * obj0 = 0 ;
37252 PyObject * obj1 = 0 ;
37253 char * kwnames[] = {
37254 (char *) "self",(char *) "pt", NULL
37255 };
37256
37257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37259 if (!SWIG_IsOK(res1)) {
37260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37261 }
37262 arg1 = reinterpret_cast< wxWindow * >(argp1);
37263 {
37264 arg2 = &temp2;
37265 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37266 }
37267 {
37268 PyThreadState* __tstate = wxPyBeginAllowThreads();
37269 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37270 wxPyEndAllowThreads(__tstate);
37271 if (PyErr_Occurred()) SWIG_fail;
37272 }
37273 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37274 return resultobj;
37275 fail:
37276 return NULL;
37277 }
37278
37279
37280 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37281 PyObject *resultobj = 0;
37282 wxWindow *arg1 = (wxWindow *) 0 ;
37283 wxSize *arg2 = 0 ;
37284 wxSize result;
37285 void *argp1 = 0 ;
37286 int res1 = 0 ;
37287 wxSize temp2 ;
37288 PyObject * obj0 = 0 ;
37289 PyObject * obj1 = 0 ;
37290 char * kwnames[] = {
37291 (char *) "self",(char *) "sz", NULL
37292 };
37293
37294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37296 if (!SWIG_IsOK(res1)) {
37297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37298 }
37299 arg1 = reinterpret_cast< wxWindow * >(argp1);
37300 {
37301 arg2 = &temp2;
37302 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37303 }
37304 {
37305 PyThreadState* __tstate = wxPyBeginAllowThreads();
37306 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37307 wxPyEndAllowThreads(__tstate);
37308 if (PyErr_Occurred()) SWIG_fail;
37309 }
37310 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37311 return resultobj;
37312 fail:
37313 return NULL;
37314 }
37315
37316
37317 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37318 PyObject *resultobj = 0;
37319 wxWindow *arg1 = (wxWindow *) 0 ;
37320 wxPoint *arg2 = 0 ;
37321 wxPoint result;
37322 void *argp1 = 0 ;
37323 int res1 = 0 ;
37324 wxPoint temp2 ;
37325 PyObject * obj0 = 0 ;
37326 PyObject * obj1 = 0 ;
37327 char * kwnames[] = {
37328 (char *) "self",(char *) "pt", NULL
37329 };
37330
37331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
37332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37333 if (!SWIG_IsOK(res1)) {
37334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
37335 }
37336 arg1 = reinterpret_cast< wxWindow * >(argp1);
37337 {
37338 arg2 = &temp2;
37339 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37340 }
37341 {
37342 PyThreadState* __tstate = wxPyBeginAllowThreads();
37343 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37344 wxPyEndAllowThreads(__tstate);
37345 if (PyErr_Occurred()) SWIG_fail;
37346 }
37347 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37348 return resultobj;
37349 fail:
37350 return NULL;
37351 }
37352
37353
37354 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37355 PyObject *resultobj = 0;
37356 wxWindow *arg1 = (wxWindow *) 0 ;
37357 wxSize *arg2 = 0 ;
37358 wxSize result;
37359 void *argp1 = 0 ;
37360 int res1 = 0 ;
37361 wxSize temp2 ;
37362 PyObject * obj0 = 0 ;
37363 PyObject * obj1 = 0 ;
37364 char * kwnames[] = {
37365 (char *) "self",(char *) "sz", NULL
37366 };
37367
37368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
37369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37370 if (!SWIG_IsOK(res1)) {
37371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
37372 }
37373 arg1 = reinterpret_cast< wxWindow * >(argp1);
37374 {
37375 arg2 = &temp2;
37376 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37377 }
37378 {
37379 PyThreadState* __tstate = wxPyBeginAllowThreads();
37380 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37381 wxPyEndAllowThreads(__tstate);
37382 if (PyErr_Occurred()) SWIG_fail;
37383 }
37384 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37385 return resultobj;
37386 fail:
37387 return NULL;
37388 }
37389
37390
37391 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37392 PyObject *resultobj = 0;
37393 wxWindow *arg1 = (wxWindow *) 0 ;
37394 wxPoint *arg2 = 0 ;
37395 wxPoint result;
37396 void *argp1 = 0 ;
37397 int res1 = 0 ;
37398 wxPoint temp2 ;
37399 PyObject * obj0 = 0 ;
37400 PyObject * obj1 = 0 ;
37401 char * kwnames[] = {
37402 (char *) "self",(char *) "pt", NULL
37403 };
37404
37405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37407 if (!SWIG_IsOK(res1)) {
37408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37409 }
37410 arg1 = reinterpret_cast< wxWindow * >(argp1);
37411 {
37412 arg2 = &temp2;
37413 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37414 }
37415 {
37416 PyThreadState* __tstate = wxPyBeginAllowThreads();
37417 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
37418 wxPyEndAllowThreads(__tstate);
37419 if (PyErr_Occurred()) SWIG_fail;
37420 }
37421 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37422 return resultobj;
37423 fail:
37424 return NULL;
37425 }
37426
37427
37428 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37429 PyObject *resultobj = 0;
37430 wxWindow *arg1 = (wxWindow *) 0 ;
37431 wxSize *arg2 = 0 ;
37432 wxSize result;
37433 void *argp1 = 0 ;
37434 int res1 = 0 ;
37435 wxSize temp2 ;
37436 PyObject * obj0 = 0 ;
37437 PyObject * obj1 = 0 ;
37438 char * kwnames[] = {
37439 (char *) "self",(char *) "sz", NULL
37440 };
37441
37442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37444 if (!SWIG_IsOK(res1)) {
37445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37446 }
37447 arg1 = reinterpret_cast< wxWindow * >(argp1);
37448 {
37449 arg2 = &temp2;
37450 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37451 }
37452 {
37453 PyThreadState* __tstate = wxPyBeginAllowThreads();
37454 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
37455 wxPyEndAllowThreads(__tstate);
37456 if (PyErr_Occurred()) SWIG_fail;
37457 }
37458 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37459 return resultobj;
37460 fail:
37461 return NULL;
37462 }
37463
37464
37465 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37466 PyObject *resultobj = 0;
37467 wxWindow *arg1 = (wxWindow *) 0 ;
37468 int arg2 ;
37469 int arg3 ;
37470 void *argp1 = 0 ;
37471 int res1 = 0 ;
37472 int val2 ;
37473 int ecode2 = 0 ;
37474 int val3 ;
37475 int ecode3 = 0 ;
37476 PyObject * obj0 = 0 ;
37477 PyObject * obj1 = 0 ;
37478 PyObject * obj2 = 0 ;
37479 char * kwnames[] = {
37480 (char *) "self",(char *) "x",(char *) "y", NULL
37481 };
37482
37483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37485 if (!SWIG_IsOK(res1)) {
37486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
37487 }
37488 arg1 = reinterpret_cast< wxWindow * >(argp1);
37489 ecode2 = SWIG_AsVal_int(obj1, &val2);
37490 if (!SWIG_IsOK(ecode2)) {
37491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
37492 }
37493 arg2 = static_cast< int >(val2);
37494 ecode3 = SWIG_AsVal_int(obj2, &val3);
37495 if (!SWIG_IsOK(ecode3)) {
37496 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
37497 }
37498 arg3 = static_cast< int >(val3);
37499 {
37500 PyThreadState* __tstate = wxPyBeginAllowThreads();
37501 (arg1)->WarpPointer(arg2,arg3);
37502 wxPyEndAllowThreads(__tstate);
37503 if (PyErr_Occurred()) SWIG_fail;
37504 }
37505 resultobj = SWIG_Py_Void();
37506 return resultobj;
37507 fail:
37508 return NULL;
37509 }
37510
37511
37512 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37513 PyObject *resultobj = 0;
37514 wxWindow *arg1 = (wxWindow *) 0 ;
37515 void *argp1 = 0 ;
37516 int res1 = 0 ;
37517 PyObject *swig_obj[1] ;
37518
37519 if (!args) SWIG_fail;
37520 swig_obj[0] = args;
37521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37522 if (!SWIG_IsOK(res1)) {
37523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37524 }
37525 arg1 = reinterpret_cast< wxWindow * >(argp1);
37526 {
37527 PyThreadState* __tstate = wxPyBeginAllowThreads();
37528 (arg1)->CaptureMouse();
37529 wxPyEndAllowThreads(__tstate);
37530 if (PyErr_Occurred()) SWIG_fail;
37531 }
37532 resultobj = SWIG_Py_Void();
37533 return resultobj;
37534 fail:
37535 return NULL;
37536 }
37537
37538
37539 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37540 PyObject *resultobj = 0;
37541 wxWindow *arg1 = (wxWindow *) 0 ;
37542 void *argp1 = 0 ;
37543 int res1 = 0 ;
37544 PyObject *swig_obj[1] ;
37545
37546 if (!args) SWIG_fail;
37547 swig_obj[0] = args;
37548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37549 if (!SWIG_IsOK(res1)) {
37550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37551 }
37552 arg1 = reinterpret_cast< wxWindow * >(argp1);
37553 {
37554 PyThreadState* __tstate = wxPyBeginAllowThreads();
37555 (arg1)->ReleaseMouse();
37556 wxPyEndAllowThreads(__tstate);
37557 if (PyErr_Occurred()) SWIG_fail;
37558 }
37559 resultobj = SWIG_Py_Void();
37560 return resultobj;
37561 fail:
37562 return NULL;
37563 }
37564
37565
37566 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37567 PyObject *resultobj = 0;
37568 wxWindow *result = 0 ;
37569
37570 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
37571 {
37572 if (!wxPyCheckForApp()) SWIG_fail;
37573 PyThreadState* __tstate = wxPyBeginAllowThreads();
37574 result = (wxWindow *)wxWindow::GetCapture();
37575 wxPyEndAllowThreads(__tstate);
37576 if (PyErr_Occurred()) SWIG_fail;
37577 }
37578 {
37579 resultobj = wxPyMake_wxObject(result, 0);
37580 }
37581 return resultobj;
37582 fail:
37583 return NULL;
37584 }
37585
37586
37587 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37588 PyObject *resultobj = 0;
37589 wxWindow *arg1 = (wxWindow *) 0 ;
37590 bool result;
37591 void *argp1 = 0 ;
37592 int res1 = 0 ;
37593 PyObject *swig_obj[1] ;
37594
37595 if (!args) SWIG_fail;
37596 swig_obj[0] = args;
37597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37598 if (!SWIG_IsOK(res1)) {
37599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
37600 }
37601 arg1 = reinterpret_cast< wxWindow * >(argp1);
37602 {
37603 PyThreadState* __tstate = wxPyBeginAllowThreads();
37604 result = (bool)((wxWindow const *)arg1)->HasCapture();
37605 wxPyEndAllowThreads(__tstate);
37606 if (PyErr_Occurred()) SWIG_fail;
37607 }
37608 {
37609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37610 }
37611 return resultobj;
37612 fail:
37613 return NULL;
37614 }
37615
37616
37617 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37618 PyObject *resultobj = 0;
37619 wxWindow *arg1 = (wxWindow *) 0 ;
37620 bool arg2 = (bool) true ;
37621 wxRect *arg3 = (wxRect *) NULL ;
37622 void *argp1 = 0 ;
37623 int res1 = 0 ;
37624 bool val2 ;
37625 int ecode2 = 0 ;
37626 void *argp3 = 0 ;
37627 int res3 = 0 ;
37628 PyObject * obj0 = 0 ;
37629 PyObject * obj1 = 0 ;
37630 PyObject * obj2 = 0 ;
37631 char * kwnames[] = {
37632 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
37633 };
37634
37635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37637 if (!SWIG_IsOK(res1)) {
37638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
37639 }
37640 arg1 = reinterpret_cast< wxWindow * >(argp1);
37641 if (obj1) {
37642 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37643 if (!SWIG_IsOK(ecode2)) {
37644 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
37645 }
37646 arg2 = static_cast< bool >(val2);
37647 }
37648 if (obj2) {
37649 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
37650 if (!SWIG_IsOK(res3)) {
37651 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
37652 }
37653 arg3 = reinterpret_cast< wxRect * >(argp3);
37654 }
37655 {
37656 PyThreadState* __tstate = wxPyBeginAllowThreads();
37657 (arg1)->Refresh(arg2,(wxRect const *)arg3);
37658 wxPyEndAllowThreads(__tstate);
37659 if (PyErr_Occurred()) SWIG_fail;
37660 }
37661 resultobj = SWIG_Py_Void();
37662 return resultobj;
37663 fail:
37664 return NULL;
37665 }
37666
37667
37668 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37669 PyObject *resultobj = 0;
37670 wxWindow *arg1 = (wxWindow *) 0 ;
37671 wxRect *arg2 = 0 ;
37672 bool arg3 = (bool) true ;
37673 void *argp1 = 0 ;
37674 int res1 = 0 ;
37675 wxRect temp2 ;
37676 bool val3 ;
37677 int ecode3 = 0 ;
37678 PyObject * obj0 = 0 ;
37679 PyObject * obj1 = 0 ;
37680 PyObject * obj2 = 0 ;
37681 char * kwnames[] = {
37682 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
37683 };
37684
37685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37687 if (!SWIG_IsOK(res1)) {
37688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
37689 }
37690 arg1 = reinterpret_cast< wxWindow * >(argp1);
37691 {
37692 arg2 = &temp2;
37693 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
37694 }
37695 if (obj2) {
37696 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37697 if (!SWIG_IsOK(ecode3)) {
37698 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
37699 }
37700 arg3 = static_cast< bool >(val3);
37701 }
37702 {
37703 PyThreadState* __tstate = wxPyBeginAllowThreads();
37704 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
37705 wxPyEndAllowThreads(__tstate);
37706 if (PyErr_Occurred()) SWIG_fail;
37707 }
37708 resultobj = SWIG_Py_Void();
37709 return resultobj;
37710 fail:
37711 return NULL;
37712 }
37713
37714
37715 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37716 PyObject *resultobj = 0;
37717 wxWindow *arg1 = (wxWindow *) 0 ;
37718 void *argp1 = 0 ;
37719 int res1 = 0 ;
37720 PyObject *swig_obj[1] ;
37721
37722 if (!args) SWIG_fail;
37723 swig_obj[0] = args;
37724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37725 if (!SWIG_IsOK(res1)) {
37726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
37727 }
37728 arg1 = reinterpret_cast< wxWindow * >(argp1);
37729 {
37730 PyThreadState* __tstate = wxPyBeginAllowThreads();
37731 (arg1)->Update();
37732 wxPyEndAllowThreads(__tstate);
37733 if (PyErr_Occurred()) SWIG_fail;
37734 }
37735 resultobj = SWIG_Py_Void();
37736 return resultobj;
37737 fail:
37738 return NULL;
37739 }
37740
37741
37742 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37743 PyObject *resultobj = 0;
37744 wxWindow *arg1 = (wxWindow *) 0 ;
37745 void *argp1 = 0 ;
37746 int res1 = 0 ;
37747 PyObject *swig_obj[1] ;
37748
37749 if (!args) SWIG_fail;
37750 swig_obj[0] = args;
37751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37752 if (!SWIG_IsOK(res1)) {
37753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
37754 }
37755 arg1 = reinterpret_cast< wxWindow * >(argp1);
37756 {
37757 PyThreadState* __tstate = wxPyBeginAllowThreads();
37758 (arg1)->ClearBackground();
37759 wxPyEndAllowThreads(__tstate);
37760 if (PyErr_Occurred()) SWIG_fail;
37761 }
37762 resultobj = SWIG_Py_Void();
37763 return resultobj;
37764 fail:
37765 return NULL;
37766 }
37767
37768
37769 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37770 PyObject *resultobj = 0;
37771 wxWindow *arg1 = (wxWindow *) 0 ;
37772 void *argp1 = 0 ;
37773 int res1 = 0 ;
37774 PyObject *swig_obj[1] ;
37775
37776 if (!args) SWIG_fail;
37777 swig_obj[0] = args;
37778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37779 if (!SWIG_IsOK(res1)) {
37780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
37781 }
37782 arg1 = reinterpret_cast< wxWindow * >(argp1);
37783 {
37784 PyThreadState* __tstate = wxPyBeginAllowThreads();
37785 (arg1)->Freeze();
37786 wxPyEndAllowThreads(__tstate);
37787 if (PyErr_Occurred()) SWIG_fail;
37788 }
37789 resultobj = SWIG_Py_Void();
37790 return resultobj;
37791 fail:
37792 return NULL;
37793 }
37794
37795
37796 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37797 PyObject *resultobj = 0;
37798 wxWindow *arg1 = (wxWindow *) 0 ;
37799 bool result;
37800 void *argp1 = 0 ;
37801 int res1 = 0 ;
37802 PyObject *swig_obj[1] ;
37803
37804 if (!args) SWIG_fail;
37805 swig_obj[0] = args;
37806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37807 if (!SWIG_IsOK(res1)) {
37808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
37809 }
37810 arg1 = reinterpret_cast< wxWindow * >(argp1);
37811 {
37812 PyThreadState* __tstate = wxPyBeginAllowThreads();
37813 result = (bool)((wxWindow const *)arg1)->IsFrozen();
37814 wxPyEndAllowThreads(__tstate);
37815 if (PyErr_Occurred()) SWIG_fail;
37816 }
37817 {
37818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37819 }
37820 return resultobj;
37821 fail:
37822 return NULL;
37823 }
37824
37825
37826 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37827 PyObject *resultobj = 0;
37828 wxWindow *arg1 = (wxWindow *) 0 ;
37829 void *argp1 = 0 ;
37830 int res1 = 0 ;
37831 PyObject *swig_obj[1] ;
37832
37833 if (!args) SWIG_fail;
37834 swig_obj[0] = args;
37835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37836 if (!SWIG_IsOK(res1)) {
37837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
37838 }
37839 arg1 = reinterpret_cast< wxWindow * >(argp1);
37840 {
37841 PyThreadState* __tstate = wxPyBeginAllowThreads();
37842 (arg1)->Thaw();
37843 wxPyEndAllowThreads(__tstate);
37844 if (PyErr_Occurred()) SWIG_fail;
37845 }
37846 resultobj = SWIG_Py_Void();
37847 return resultobj;
37848 fail:
37849 return NULL;
37850 }
37851
37852
37853 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37854 PyObject *resultobj = 0;
37855 wxWindow *arg1 = (wxWindow *) 0 ;
37856 wxDC *arg2 = 0 ;
37857 void *argp1 = 0 ;
37858 int res1 = 0 ;
37859 void *argp2 = 0 ;
37860 int res2 = 0 ;
37861 PyObject * obj0 = 0 ;
37862 PyObject * obj1 = 0 ;
37863 char * kwnames[] = {
37864 (char *) "self",(char *) "dc", NULL
37865 };
37866
37867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
37868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37869 if (!SWIG_IsOK(res1)) {
37870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
37871 }
37872 arg1 = reinterpret_cast< wxWindow * >(argp1);
37873 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
37874 if (!SWIG_IsOK(res2)) {
37875 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
37876 }
37877 if (!argp2) {
37878 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
37879 }
37880 arg2 = reinterpret_cast< wxDC * >(argp2);
37881 {
37882 PyThreadState* __tstate = wxPyBeginAllowThreads();
37883 (arg1)->PrepareDC(*arg2);
37884 wxPyEndAllowThreads(__tstate);
37885 if (PyErr_Occurred()) SWIG_fail;
37886 }
37887 resultobj = SWIG_Py_Void();
37888 return resultobj;
37889 fail:
37890 return NULL;
37891 }
37892
37893
37894 SWIGINTERN PyObject *_wrap_Window_IsDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37895 PyObject *resultobj = 0;
37896 wxWindow *arg1 = (wxWindow *) 0 ;
37897 bool result;
37898 void *argp1 = 0 ;
37899 int res1 = 0 ;
37900 PyObject *swig_obj[1] ;
37901
37902 if (!args) SWIG_fail;
37903 swig_obj[0] = args;
37904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37905 if (!SWIG_IsOK(res1)) {
37906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow const *""'");
37907 }
37908 arg1 = reinterpret_cast< wxWindow * >(argp1);
37909 {
37910 PyThreadState* __tstate = wxPyBeginAllowThreads();
37911 result = (bool)((wxWindow const *)arg1)->IsDoubleBuffered();
37912 wxPyEndAllowThreads(__tstate);
37913 if (PyErr_Occurred()) SWIG_fail;
37914 }
37915 {
37916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37917 }
37918 return resultobj;
37919 fail:
37920 return NULL;
37921 }
37922
37923
37924 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37925 PyObject *resultobj = 0;
37926 wxWindow *arg1 = (wxWindow *) 0 ;
37927 wxRegion *result = 0 ;
37928 void *argp1 = 0 ;
37929 int res1 = 0 ;
37930 PyObject *swig_obj[1] ;
37931
37932 if (!args) SWIG_fail;
37933 swig_obj[0] = args;
37934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37935 if (!SWIG_IsOK(res1)) {
37936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
37937 }
37938 arg1 = reinterpret_cast< wxWindow * >(argp1);
37939 {
37940 PyThreadState* __tstate = wxPyBeginAllowThreads();
37941 {
37942 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
37943 result = (wxRegion *) &_result_ref;
37944 }
37945 wxPyEndAllowThreads(__tstate);
37946 if (PyErr_Occurred()) SWIG_fail;
37947 }
37948 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
37949 return resultobj;
37950 fail:
37951 return NULL;
37952 }
37953
37954
37955 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37956 PyObject *resultobj = 0;
37957 wxWindow *arg1 = (wxWindow *) 0 ;
37958 wxRect result;
37959 void *argp1 = 0 ;
37960 int res1 = 0 ;
37961 PyObject *swig_obj[1] ;
37962
37963 if (!args) SWIG_fail;
37964 swig_obj[0] = args;
37965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37966 if (!SWIG_IsOK(res1)) {
37967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
37968 }
37969 arg1 = reinterpret_cast< wxWindow * >(argp1);
37970 {
37971 PyThreadState* __tstate = wxPyBeginAllowThreads();
37972 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
37973 wxPyEndAllowThreads(__tstate);
37974 if (PyErr_Occurred()) SWIG_fail;
37975 }
37976 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
37977 return resultobj;
37978 fail:
37979 return NULL;
37980 }
37981
37982
37983 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37984 PyObject *resultobj = 0;
37985 wxWindow *arg1 = (wxWindow *) 0 ;
37986 int arg2 ;
37987 int arg3 ;
37988 int arg4 = (int) 1 ;
37989 int arg5 = (int) 1 ;
37990 bool result;
37991 void *argp1 = 0 ;
37992 int res1 = 0 ;
37993 int val2 ;
37994 int ecode2 = 0 ;
37995 int val3 ;
37996 int ecode3 = 0 ;
37997 int val4 ;
37998 int ecode4 = 0 ;
37999 int val5 ;
38000 int ecode5 = 0 ;
38001 PyObject * obj0 = 0 ;
38002 PyObject * obj1 = 0 ;
38003 PyObject * obj2 = 0 ;
38004 PyObject * obj3 = 0 ;
38005 PyObject * obj4 = 0 ;
38006 char * kwnames[] = {
38007 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
38008 };
38009
38010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38012 if (!SWIG_IsOK(res1)) {
38013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
38014 }
38015 arg1 = reinterpret_cast< wxWindow * >(argp1);
38016 ecode2 = SWIG_AsVal_int(obj1, &val2);
38017 if (!SWIG_IsOK(ecode2)) {
38018 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
38019 }
38020 arg2 = static_cast< int >(val2);
38021 ecode3 = SWIG_AsVal_int(obj2, &val3);
38022 if (!SWIG_IsOK(ecode3)) {
38023 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
38024 }
38025 arg3 = static_cast< int >(val3);
38026 if (obj3) {
38027 ecode4 = SWIG_AsVal_int(obj3, &val4);
38028 if (!SWIG_IsOK(ecode4)) {
38029 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
38030 }
38031 arg4 = static_cast< int >(val4);
38032 }
38033 if (obj4) {
38034 ecode5 = SWIG_AsVal_int(obj4, &val5);
38035 if (!SWIG_IsOK(ecode5)) {
38036 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
38037 }
38038 arg5 = static_cast< int >(val5);
38039 }
38040 {
38041 PyThreadState* __tstate = wxPyBeginAllowThreads();
38042 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
38043 wxPyEndAllowThreads(__tstate);
38044 if (PyErr_Occurred()) SWIG_fail;
38045 }
38046 {
38047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38048 }
38049 return resultobj;
38050 fail:
38051 return NULL;
38052 }
38053
38054
38055 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38056 PyObject *resultobj = 0;
38057 wxWindow *arg1 = (wxWindow *) 0 ;
38058 wxPoint *arg2 = 0 ;
38059 bool result;
38060 void *argp1 = 0 ;
38061 int res1 = 0 ;
38062 wxPoint temp2 ;
38063 PyObject * obj0 = 0 ;
38064 PyObject * obj1 = 0 ;
38065 char * kwnames[] = {
38066 (char *) "self",(char *) "pt", NULL
38067 };
38068
38069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
38070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38071 if (!SWIG_IsOK(res1)) {
38072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
38073 }
38074 arg1 = reinterpret_cast< wxWindow * >(argp1);
38075 {
38076 arg2 = &temp2;
38077 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38078 }
38079 {
38080 PyThreadState* __tstate = wxPyBeginAllowThreads();
38081 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
38082 wxPyEndAllowThreads(__tstate);
38083 if (PyErr_Occurred()) SWIG_fail;
38084 }
38085 {
38086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38087 }
38088 return resultobj;
38089 fail:
38090 return NULL;
38091 }
38092
38093
38094 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38095 PyObject *resultobj = 0;
38096 wxWindow *arg1 = (wxWindow *) 0 ;
38097 wxRect *arg2 = 0 ;
38098 bool result;
38099 void *argp1 = 0 ;
38100 int res1 = 0 ;
38101 wxRect temp2 ;
38102 PyObject * obj0 = 0 ;
38103 PyObject * obj1 = 0 ;
38104 char * kwnames[] = {
38105 (char *) "self",(char *) "rect", NULL
38106 };
38107
38108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
38109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38110 if (!SWIG_IsOK(res1)) {
38111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38112 }
38113 arg1 = reinterpret_cast< wxWindow * >(argp1);
38114 {
38115 arg2 = &temp2;
38116 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38117 }
38118 {
38119 PyThreadState* __tstate = wxPyBeginAllowThreads();
38120 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
38121 wxPyEndAllowThreads(__tstate);
38122 if (PyErr_Occurred()) SWIG_fail;
38123 }
38124 {
38125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38126 }
38127 return resultobj;
38128 fail:
38129 return NULL;
38130 }
38131
38132
38133 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38134 PyObject *resultobj = 0;
38135 wxWindow *arg1 = (wxWindow *) 0 ;
38136 SwigValueWrapper<wxVisualAttributes > result;
38137 void *argp1 = 0 ;
38138 int res1 = 0 ;
38139 PyObject *swig_obj[1] ;
38140
38141 if (!args) SWIG_fail;
38142 swig_obj[0] = args;
38143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38144 if (!SWIG_IsOK(res1)) {
38145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
38146 }
38147 arg1 = reinterpret_cast< wxWindow * >(argp1);
38148 {
38149 PyThreadState* __tstate = wxPyBeginAllowThreads();
38150 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
38151 wxPyEndAllowThreads(__tstate);
38152 if (PyErr_Occurred()) SWIG_fail;
38153 }
38154 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38155 return resultobj;
38156 fail:
38157 return NULL;
38158 }
38159
38160
38161 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38162 PyObject *resultobj = 0;
38163 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38164 SwigValueWrapper<wxVisualAttributes > result;
38165 int val1 ;
38166 int ecode1 = 0 ;
38167 PyObject * obj0 = 0 ;
38168 char * kwnames[] = {
38169 (char *) "variant", NULL
38170 };
38171
38172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
38173 if (obj0) {
38174 ecode1 = SWIG_AsVal_int(obj0, &val1);
38175 if (!SWIG_IsOK(ecode1)) {
38176 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
38177 }
38178 arg1 = static_cast< wxWindowVariant >(val1);
38179 }
38180 {
38181 if (!wxPyCheckForApp()) SWIG_fail;
38182 PyThreadState* __tstate = wxPyBeginAllowThreads();
38183 result = wxWindow::GetClassDefaultAttributes(arg1);
38184 wxPyEndAllowThreads(__tstate);
38185 if (PyErr_Occurred()) SWIG_fail;
38186 }
38187 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38188 return resultobj;
38189 fail:
38190 return NULL;
38191 }
38192
38193
38194 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38195 PyObject *resultobj = 0;
38196 wxWindow *arg1 = (wxWindow *) 0 ;
38197 wxColour *arg2 = 0 ;
38198 bool result;
38199 void *argp1 = 0 ;
38200 int res1 = 0 ;
38201 wxColour temp2 ;
38202 PyObject * obj0 = 0 ;
38203 PyObject * obj1 = 0 ;
38204 char * kwnames[] = {
38205 (char *) "self",(char *) "colour", NULL
38206 };
38207
38208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38210 if (!SWIG_IsOK(res1)) {
38211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38212 }
38213 arg1 = reinterpret_cast< wxWindow * >(argp1);
38214 {
38215 arg2 = &temp2;
38216 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38217 }
38218 {
38219 PyThreadState* __tstate = wxPyBeginAllowThreads();
38220 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
38221 wxPyEndAllowThreads(__tstate);
38222 if (PyErr_Occurred()) SWIG_fail;
38223 }
38224 {
38225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38226 }
38227 return resultobj;
38228 fail:
38229 return NULL;
38230 }
38231
38232
38233 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38234 PyObject *resultobj = 0;
38235 wxWindow *arg1 = (wxWindow *) 0 ;
38236 wxColour *arg2 = 0 ;
38237 void *argp1 = 0 ;
38238 int res1 = 0 ;
38239 wxColour temp2 ;
38240 PyObject * obj0 = 0 ;
38241 PyObject * obj1 = 0 ;
38242 char * kwnames[] = {
38243 (char *) "self",(char *) "colour", NULL
38244 };
38245
38246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38248 if (!SWIG_IsOK(res1)) {
38249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38250 }
38251 arg1 = reinterpret_cast< wxWindow * >(argp1);
38252 {
38253 arg2 = &temp2;
38254 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38255 }
38256 {
38257 PyThreadState* __tstate = wxPyBeginAllowThreads();
38258 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
38259 wxPyEndAllowThreads(__tstate);
38260 if (PyErr_Occurred()) SWIG_fail;
38261 }
38262 resultobj = SWIG_Py_Void();
38263 return resultobj;
38264 fail:
38265 return NULL;
38266 }
38267
38268
38269 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38270 PyObject *resultobj = 0;
38271 wxWindow *arg1 = (wxWindow *) 0 ;
38272 wxColour *arg2 = 0 ;
38273 bool result;
38274 void *argp1 = 0 ;
38275 int res1 = 0 ;
38276 wxColour temp2 ;
38277 PyObject * obj0 = 0 ;
38278 PyObject * obj1 = 0 ;
38279 char * kwnames[] = {
38280 (char *) "self",(char *) "colour", NULL
38281 };
38282
38283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38285 if (!SWIG_IsOK(res1)) {
38286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38287 }
38288 arg1 = reinterpret_cast< wxWindow * >(argp1);
38289 {
38290 arg2 = &temp2;
38291 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38292 }
38293 {
38294 PyThreadState* __tstate = wxPyBeginAllowThreads();
38295 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
38296 wxPyEndAllowThreads(__tstate);
38297 if (PyErr_Occurred()) SWIG_fail;
38298 }
38299 {
38300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38301 }
38302 return resultobj;
38303 fail:
38304 return NULL;
38305 }
38306
38307
38308 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38309 PyObject *resultobj = 0;
38310 wxWindow *arg1 = (wxWindow *) 0 ;
38311 wxColour *arg2 = 0 ;
38312 void *argp1 = 0 ;
38313 int res1 = 0 ;
38314 wxColour temp2 ;
38315 PyObject * obj0 = 0 ;
38316 PyObject * obj1 = 0 ;
38317 char * kwnames[] = {
38318 (char *) "self",(char *) "colour", NULL
38319 };
38320
38321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38323 if (!SWIG_IsOK(res1)) {
38324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38325 }
38326 arg1 = reinterpret_cast< wxWindow * >(argp1);
38327 {
38328 arg2 = &temp2;
38329 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38330 }
38331 {
38332 PyThreadState* __tstate = wxPyBeginAllowThreads();
38333 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
38334 wxPyEndAllowThreads(__tstate);
38335 if (PyErr_Occurred()) SWIG_fail;
38336 }
38337 resultobj = SWIG_Py_Void();
38338 return resultobj;
38339 fail:
38340 return NULL;
38341 }
38342
38343
38344 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38345 PyObject *resultobj = 0;
38346 wxWindow *arg1 = (wxWindow *) 0 ;
38347 wxColour result;
38348 void *argp1 = 0 ;
38349 int res1 = 0 ;
38350 PyObject *swig_obj[1] ;
38351
38352 if (!args) SWIG_fail;
38353 swig_obj[0] = args;
38354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38355 if (!SWIG_IsOK(res1)) {
38356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38357 }
38358 arg1 = reinterpret_cast< wxWindow * >(argp1);
38359 {
38360 PyThreadState* __tstate = wxPyBeginAllowThreads();
38361 result = ((wxWindow const *)arg1)->GetBackgroundColour();
38362 wxPyEndAllowThreads(__tstate);
38363 if (PyErr_Occurred()) SWIG_fail;
38364 }
38365 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38366 return resultobj;
38367 fail:
38368 return NULL;
38369 }
38370
38371
38372 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38373 PyObject *resultobj = 0;
38374 wxWindow *arg1 = (wxWindow *) 0 ;
38375 wxColour result;
38376 void *argp1 = 0 ;
38377 int res1 = 0 ;
38378 PyObject *swig_obj[1] ;
38379
38380 if (!args) SWIG_fail;
38381 swig_obj[0] = args;
38382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38383 if (!SWIG_IsOK(res1)) {
38384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38385 }
38386 arg1 = reinterpret_cast< wxWindow * >(argp1);
38387 {
38388 PyThreadState* __tstate = wxPyBeginAllowThreads();
38389 result = ((wxWindow const *)arg1)->GetForegroundColour();
38390 wxPyEndAllowThreads(__tstate);
38391 if (PyErr_Occurred()) SWIG_fail;
38392 }
38393 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38394 return resultobj;
38395 fail:
38396 return NULL;
38397 }
38398
38399
38400 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38401 PyObject *resultobj = 0;
38402 wxWindow *arg1 = (wxWindow *) 0 ;
38403 bool result;
38404 void *argp1 = 0 ;
38405 int res1 = 0 ;
38406 PyObject *swig_obj[1] ;
38407
38408 if (!args) SWIG_fail;
38409 swig_obj[0] = args;
38410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38411 if (!SWIG_IsOK(res1)) {
38412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38413 }
38414 arg1 = reinterpret_cast< wxWindow * >(argp1);
38415 {
38416 PyThreadState* __tstate = wxPyBeginAllowThreads();
38417 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
38418 wxPyEndAllowThreads(__tstate);
38419 if (PyErr_Occurred()) SWIG_fail;
38420 }
38421 {
38422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38423 }
38424 return resultobj;
38425 fail:
38426 return NULL;
38427 }
38428
38429
38430 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38431 PyObject *resultobj = 0;
38432 wxWindow *arg1 = (wxWindow *) 0 ;
38433 bool result;
38434 void *argp1 = 0 ;
38435 int res1 = 0 ;
38436 PyObject *swig_obj[1] ;
38437
38438 if (!args) SWIG_fail;
38439 swig_obj[0] = args;
38440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38441 if (!SWIG_IsOK(res1)) {
38442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
38443 }
38444 arg1 = reinterpret_cast< wxWindow * >(argp1);
38445 {
38446 PyThreadState* __tstate = wxPyBeginAllowThreads();
38447 result = (bool)((wxWindow const *)arg1)->UseBgCol();
38448 wxPyEndAllowThreads(__tstate);
38449 if (PyErr_Occurred()) SWIG_fail;
38450 }
38451 {
38452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38453 }
38454 return resultobj;
38455 fail:
38456 return NULL;
38457 }
38458
38459
38460 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38461 PyObject *resultobj = 0;
38462 wxWindow *arg1 = (wxWindow *) 0 ;
38463 wxBackgroundStyle arg2 ;
38464 bool result;
38465 void *argp1 = 0 ;
38466 int res1 = 0 ;
38467 int val2 ;
38468 int ecode2 = 0 ;
38469 PyObject * obj0 = 0 ;
38470 PyObject * obj1 = 0 ;
38471 char * kwnames[] = {
38472 (char *) "self",(char *) "style", NULL
38473 };
38474
38475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
38476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38477 if (!SWIG_IsOK(res1)) {
38478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
38479 }
38480 arg1 = reinterpret_cast< wxWindow * >(argp1);
38481 ecode2 = SWIG_AsVal_int(obj1, &val2);
38482 if (!SWIG_IsOK(ecode2)) {
38483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
38484 }
38485 arg2 = static_cast< wxBackgroundStyle >(val2);
38486 {
38487 PyThreadState* __tstate = wxPyBeginAllowThreads();
38488 result = (bool)(arg1)->SetBackgroundStyle(arg2);
38489 wxPyEndAllowThreads(__tstate);
38490 if (PyErr_Occurred()) SWIG_fail;
38491 }
38492 {
38493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38494 }
38495 return resultobj;
38496 fail:
38497 return NULL;
38498 }
38499
38500
38501 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38502 PyObject *resultobj = 0;
38503 wxWindow *arg1 = (wxWindow *) 0 ;
38504 wxBackgroundStyle result;
38505 void *argp1 = 0 ;
38506 int res1 = 0 ;
38507 PyObject *swig_obj[1] ;
38508
38509 if (!args) SWIG_fail;
38510 swig_obj[0] = args;
38511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38512 if (!SWIG_IsOK(res1)) {
38513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
38514 }
38515 arg1 = reinterpret_cast< wxWindow * >(argp1);
38516 {
38517 PyThreadState* __tstate = wxPyBeginAllowThreads();
38518 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
38519 wxPyEndAllowThreads(__tstate);
38520 if (PyErr_Occurred()) SWIG_fail;
38521 }
38522 resultobj = SWIG_From_int(static_cast< int >(result));
38523 return resultobj;
38524 fail:
38525 return NULL;
38526 }
38527
38528
38529 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38530 PyObject *resultobj = 0;
38531 wxWindow *arg1 = (wxWindow *) 0 ;
38532 bool result;
38533 void *argp1 = 0 ;
38534 int res1 = 0 ;
38535 PyObject *swig_obj[1] ;
38536
38537 if (!args) SWIG_fail;
38538 swig_obj[0] = args;
38539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38540 if (!SWIG_IsOK(res1)) {
38541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
38542 }
38543 arg1 = reinterpret_cast< wxWindow * >(argp1);
38544 {
38545 PyThreadState* __tstate = wxPyBeginAllowThreads();
38546 result = (bool)(arg1)->HasTransparentBackground();
38547 wxPyEndAllowThreads(__tstate);
38548 if (PyErr_Occurred()) SWIG_fail;
38549 }
38550 {
38551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38552 }
38553 return resultobj;
38554 fail:
38555 return NULL;
38556 }
38557
38558
38559 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38560 PyObject *resultobj = 0;
38561 wxWindow *arg1 = (wxWindow *) 0 ;
38562 wxCursor *arg2 = 0 ;
38563 bool result;
38564 void *argp1 = 0 ;
38565 int res1 = 0 ;
38566 void *argp2 = 0 ;
38567 int res2 = 0 ;
38568 PyObject * obj0 = 0 ;
38569 PyObject * obj1 = 0 ;
38570 char * kwnames[] = {
38571 (char *) "self",(char *) "cursor", NULL
38572 };
38573
38574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
38575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38576 if (!SWIG_IsOK(res1)) {
38577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38578 }
38579 arg1 = reinterpret_cast< wxWindow * >(argp1);
38580 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
38581 if (!SWIG_IsOK(res2)) {
38582 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38583 }
38584 if (!argp2) {
38585 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38586 }
38587 arg2 = reinterpret_cast< wxCursor * >(argp2);
38588 {
38589 PyThreadState* __tstate = wxPyBeginAllowThreads();
38590 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
38591 wxPyEndAllowThreads(__tstate);
38592 if (PyErr_Occurred()) SWIG_fail;
38593 }
38594 {
38595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38596 }
38597 return resultobj;
38598 fail:
38599 return NULL;
38600 }
38601
38602
38603 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38604 PyObject *resultobj = 0;
38605 wxWindow *arg1 = (wxWindow *) 0 ;
38606 wxCursor result;
38607 void *argp1 = 0 ;
38608 int res1 = 0 ;
38609 PyObject *swig_obj[1] ;
38610
38611 if (!args) SWIG_fail;
38612 swig_obj[0] = args;
38613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38614 if (!SWIG_IsOK(res1)) {
38615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38616 }
38617 arg1 = reinterpret_cast< wxWindow * >(argp1);
38618 {
38619 PyThreadState* __tstate = wxPyBeginAllowThreads();
38620 result = (arg1)->GetCursor();
38621 wxPyEndAllowThreads(__tstate);
38622 if (PyErr_Occurred()) SWIG_fail;
38623 }
38624 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
38625 return resultobj;
38626 fail:
38627 return NULL;
38628 }
38629
38630
38631 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38632 PyObject *resultobj = 0;
38633 wxWindow *arg1 = (wxWindow *) 0 ;
38634 wxFont *arg2 = 0 ;
38635 bool result;
38636 void *argp1 = 0 ;
38637 int res1 = 0 ;
38638 void *argp2 = 0 ;
38639 int res2 = 0 ;
38640 PyObject * obj0 = 0 ;
38641 PyObject * obj1 = 0 ;
38642 char * kwnames[] = {
38643 (char *) "self",(char *) "font", NULL
38644 };
38645
38646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
38647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38648 if (!SWIG_IsOK(res1)) {
38649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38650 }
38651 arg1 = reinterpret_cast< wxWindow * >(argp1);
38652 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38653 if (!SWIG_IsOK(res2)) {
38654 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38655 }
38656 if (!argp2) {
38657 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38658 }
38659 arg2 = reinterpret_cast< wxFont * >(argp2);
38660 {
38661 PyThreadState* __tstate = wxPyBeginAllowThreads();
38662 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
38663 wxPyEndAllowThreads(__tstate);
38664 if (PyErr_Occurred()) SWIG_fail;
38665 }
38666 {
38667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38668 }
38669 return resultobj;
38670 fail:
38671 return NULL;
38672 }
38673
38674
38675 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38676 PyObject *resultobj = 0;
38677 wxWindow *arg1 = (wxWindow *) 0 ;
38678 wxFont *arg2 = 0 ;
38679 void *argp1 = 0 ;
38680 int res1 = 0 ;
38681 void *argp2 = 0 ;
38682 int res2 = 0 ;
38683 PyObject * obj0 = 0 ;
38684 PyObject * obj1 = 0 ;
38685 char * kwnames[] = {
38686 (char *) "self",(char *) "font", NULL
38687 };
38688
38689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
38690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38691 if (!SWIG_IsOK(res1)) {
38692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38693 }
38694 arg1 = reinterpret_cast< wxWindow * >(argp1);
38695 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38696 if (!SWIG_IsOK(res2)) {
38697 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38698 }
38699 if (!argp2) {
38700 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38701 }
38702 arg2 = reinterpret_cast< wxFont * >(argp2);
38703 {
38704 PyThreadState* __tstate = wxPyBeginAllowThreads();
38705 (arg1)->SetOwnFont((wxFont const &)*arg2);
38706 wxPyEndAllowThreads(__tstate);
38707 if (PyErr_Occurred()) SWIG_fail;
38708 }
38709 resultobj = SWIG_Py_Void();
38710 return resultobj;
38711 fail:
38712 return NULL;
38713 }
38714
38715
38716 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38717 PyObject *resultobj = 0;
38718 wxWindow *arg1 = (wxWindow *) 0 ;
38719 wxFont result;
38720 void *argp1 = 0 ;
38721 int res1 = 0 ;
38722 PyObject *swig_obj[1] ;
38723
38724 if (!args) SWIG_fail;
38725 swig_obj[0] = args;
38726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38727 if (!SWIG_IsOK(res1)) {
38728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38729 }
38730 arg1 = reinterpret_cast< wxWindow * >(argp1);
38731 {
38732 PyThreadState* __tstate = wxPyBeginAllowThreads();
38733 result = (arg1)->GetFont();
38734 wxPyEndAllowThreads(__tstate);
38735 if (PyErr_Occurred()) SWIG_fail;
38736 }
38737 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
38738 return resultobj;
38739 fail:
38740 return NULL;
38741 }
38742
38743
38744 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38745 PyObject *resultobj = 0;
38746 wxWindow *arg1 = (wxWindow *) 0 ;
38747 wxCaret *arg2 = (wxCaret *) 0 ;
38748 void *argp1 = 0 ;
38749 int res1 = 0 ;
38750 int res2 = 0 ;
38751 PyObject * obj0 = 0 ;
38752 PyObject * obj1 = 0 ;
38753 char * kwnames[] = {
38754 (char *) "self",(char *) "caret", NULL
38755 };
38756
38757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
38758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38759 if (!SWIG_IsOK(res1)) {
38760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
38761 }
38762 arg1 = reinterpret_cast< wxWindow * >(argp1);
38763 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
38764 if (!SWIG_IsOK(res2)) {
38765 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
38766 }
38767 {
38768 PyThreadState* __tstate = wxPyBeginAllowThreads();
38769 (arg1)->SetCaret(arg2);
38770 wxPyEndAllowThreads(__tstate);
38771 if (PyErr_Occurred()) SWIG_fail;
38772 }
38773 resultobj = SWIG_Py_Void();
38774 return resultobj;
38775 fail:
38776 return NULL;
38777 }
38778
38779
38780 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38781 PyObject *resultobj = 0;
38782 wxWindow *arg1 = (wxWindow *) 0 ;
38783 wxCaret *result = 0 ;
38784 void *argp1 = 0 ;
38785 int res1 = 0 ;
38786 PyObject *swig_obj[1] ;
38787
38788 if (!args) SWIG_fail;
38789 swig_obj[0] = args;
38790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38791 if (!SWIG_IsOK(res1)) {
38792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
38793 }
38794 arg1 = reinterpret_cast< wxWindow * >(argp1);
38795 {
38796 PyThreadState* __tstate = wxPyBeginAllowThreads();
38797 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
38798 wxPyEndAllowThreads(__tstate);
38799 if (PyErr_Occurred()) SWIG_fail;
38800 }
38801 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
38802 return resultobj;
38803 fail:
38804 return NULL;
38805 }
38806
38807
38808 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38809 PyObject *resultobj = 0;
38810 wxWindow *arg1 = (wxWindow *) 0 ;
38811 int result;
38812 void *argp1 = 0 ;
38813 int res1 = 0 ;
38814 PyObject *swig_obj[1] ;
38815
38816 if (!args) SWIG_fail;
38817 swig_obj[0] = args;
38818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38819 if (!SWIG_IsOK(res1)) {
38820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
38821 }
38822 arg1 = reinterpret_cast< wxWindow * >(argp1);
38823 {
38824 PyThreadState* __tstate = wxPyBeginAllowThreads();
38825 result = (int)((wxWindow const *)arg1)->GetCharHeight();
38826 wxPyEndAllowThreads(__tstate);
38827 if (PyErr_Occurred()) SWIG_fail;
38828 }
38829 resultobj = SWIG_From_int(static_cast< int >(result));
38830 return resultobj;
38831 fail:
38832 return NULL;
38833 }
38834
38835
38836 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38837 PyObject *resultobj = 0;
38838 wxWindow *arg1 = (wxWindow *) 0 ;
38839 int result;
38840 void *argp1 = 0 ;
38841 int res1 = 0 ;
38842 PyObject *swig_obj[1] ;
38843
38844 if (!args) SWIG_fail;
38845 swig_obj[0] = args;
38846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38847 if (!SWIG_IsOK(res1)) {
38848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
38849 }
38850 arg1 = reinterpret_cast< wxWindow * >(argp1);
38851 {
38852 PyThreadState* __tstate = wxPyBeginAllowThreads();
38853 result = (int)((wxWindow const *)arg1)->GetCharWidth();
38854 wxPyEndAllowThreads(__tstate);
38855 if (PyErr_Occurred()) SWIG_fail;
38856 }
38857 resultobj = SWIG_From_int(static_cast< int >(result));
38858 return resultobj;
38859 fail:
38860 return NULL;
38861 }
38862
38863
38864 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38865 PyObject *resultobj = 0;
38866 wxWindow *arg1 = (wxWindow *) 0 ;
38867 wxString *arg2 = 0 ;
38868 int *arg3 = (int *) 0 ;
38869 int *arg4 = (int *) 0 ;
38870 void *argp1 = 0 ;
38871 int res1 = 0 ;
38872 bool temp2 = false ;
38873 int temp3 ;
38874 int res3 = SWIG_TMPOBJ ;
38875 int temp4 ;
38876 int res4 = SWIG_TMPOBJ ;
38877 PyObject * obj0 = 0 ;
38878 PyObject * obj1 = 0 ;
38879 char * kwnames[] = {
38880 (char *) "self",(char *) "string", NULL
38881 };
38882
38883 arg3 = &temp3;
38884 arg4 = &temp4;
38885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
38886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38887 if (!SWIG_IsOK(res1)) {
38888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
38889 }
38890 arg1 = reinterpret_cast< wxWindow * >(argp1);
38891 {
38892 arg2 = wxString_in_helper(obj1);
38893 if (arg2 == NULL) SWIG_fail;
38894 temp2 = true;
38895 }
38896 {
38897 PyThreadState* __tstate = wxPyBeginAllowThreads();
38898 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
38899 wxPyEndAllowThreads(__tstate);
38900 if (PyErr_Occurred()) SWIG_fail;
38901 }
38902 resultobj = SWIG_Py_Void();
38903 if (SWIG_IsTmpObj(res3)) {
38904 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38905 } else {
38906 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38907 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38908 }
38909 if (SWIG_IsTmpObj(res4)) {
38910 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
38911 } else {
38912 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38913 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
38914 }
38915 {
38916 if (temp2)
38917 delete arg2;
38918 }
38919 return resultobj;
38920 fail:
38921 {
38922 if (temp2)
38923 delete arg2;
38924 }
38925 return NULL;
38926 }
38927
38928
38929 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38930 PyObject *resultobj = 0;
38931 wxWindow *arg1 = (wxWindow *) 0 ;
38932 wxString *arg2 = 0 ;
38933 int *arg3 = (int *) 0 ;
38934 int *arg4 = (int *) 0 ;
38935 int *arg5 = (int *) 0 ;
38936 int *arg6 = (int *) 0 ;
38937 wxFont *arg7 = (wxFont *) NULL ;
38938 void *argp1 = 0 ;
38939 int res1 = 0 ;
38940 bool temp2 = false ;
38941 int temp3 ;
38942 int res3 = SWIG_TMPOBJ ;
38943 int temp4 ;
38944 int res4 = SWIG_TMPOBJ ;
38945 int temp5 ;
38946 int res5 = SWIG_TMPOBJ ;
38947 int temp6 ;
38948 int res6 = SWIG_TMPOBJ ;
38949 void *argp7 = 0 ;
38950 int res7 = 0 ;
38951 PyObject * obj0 = 0 ;
38952 PyObject * obj1 = 0 ;
38953 PyObject * obj2 = 0 ;
38954 char * kwnames[] = {
38955 (char *) "self",(char *) "string",(char *) "font", NULL
38956 };
38957
38958 arg3 = &temp3;
38959 arg4 = &temp4;
38960 arg5 = &temp5;
38961 arg6 = &temp6;
38962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38964 if (!SWIG_IsOK(res1)) {
38965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
38966 }
38967 arg1 = reinterpret_cast< wxWindow * >(argp1);
38968 {
38969 arg2 = wxString_in_helper(obj1);
38970 if (arg2 == NULL) SWIG_fail;
38971 temp2 = true;
38972 }
38973 if (obj2) {
38974 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
38975 if (!SWIG_IsOK(res7)) {
38976 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
38977 }
38978 arg7 = reinterpret_cast< wxFont * >(argp7);
38979 }
38980 {
38981 PyThreadState* __tstate = wxPyBeginAllowThreads();
38982 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
38983 wxPyEndAllowThreads(__tstate);
38984 if (PyErr_Occurred()) SWIG_fail;
38985 }
38986 resultobj = SWIG_Py_Void();
38987 if (SWIG_IsTmpObj(res3)) {
38988 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38989 } else {
38990 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38991 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38992 }
38993 if (SWIG_IsTmpObj(res4)) {
38994 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
38995 } else {
38996 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38997 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
38998 }
38999 if (SWIG_IsTmpObj(res5)) {
39000 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
39001 } else {
39002 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39003 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
39004 }
39005 if (SWIG_IsTmpObj(res6)) {
39006 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
39007 } else {
39008 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39009 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
39010 }
39011 {
39012 if (temp2)
39013 delete arg2;
39014 }
39015 return resultobj;
39016 fail:
39017 {
39018 if (temp2)
39019 delete arg2;
39020 }
39021 return NULL;
39022 }
39023
39024
39025 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39026 PyObject *resultobj = 0;
39027 wxWindow *arg1 = (wxWindow *) 0 ;
39028 int *arg2 = (int *) 0 ;
39029 int *arg3 = (int *) 0 ;
39030 void *argp1 = 0 ;
39031 int res1 = 0 ;
39032 int temp2 ;
39033 int res2 = 0 ;
39034 int temp3 ;
39035 int res3 = 0 ;
39036 PyObject * obj0 = 0 ;
39037 PyObject * obj1 = 0 ;
39038 PyObject * obj2 = 0 ;
39039 char * kwnames[] = {
39040 (char *) "self",(char *) "x",(char *) "y", NULL
39041 };
39042
39043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39045 if (!SWIG_IsOK(res1)) {
39046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39047 }
39048 arg1 = reinterpret_cast< wxWindow * >(argp1);
39049 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39050 int val;
39051 int ecode = SWIG_AsVal_int(obj1, &val);
39052 if (!SWIG_IsOK(ecode)) {
39053 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
39054 }
39055 temp2 = static_cast< int >(val);
39056 arg2 = &temp2;
39057 res2 = SWIG_AddTmpMask(ecode);
39058 }
39059 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39060 int val;
39061 int ecode = SWIG_AsVal_int(obj2, &val);
39062 if (!SWIG_IsOK(ecode)) {
39063 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
39064 }
39065 temp3 = static_cast< int >(val);
39066 arg3 = &temp3;
39067 res3 = SWIG_AddTmpMask(ecode);
39068 }
39069 {
39070 PyThreadState* __tstate = wxPyBeginAllowThreads();
39071 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
39072 wxPyEndAllowThreads(__tstate);
39073 if (PyErr_Occurred()) SWIG_fail;
39074 }
39075 resultobj = SWIG_Py_Void();
39076 if (SWIG_IsTmpObj(res2)) {
39077 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39078 } else {
39079 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39080 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39081 }
39082 if (SWIG_IsTmpObj(res3)) {
39083 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39084 } else {
39085 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39086 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39087 }
39088 return resultobj;
39089 fail:
39090 return NULL;
39091 }
39092
39093
39094 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39095 PyObject *resultobj = 0;
39096 wxWindow *arg1 = (wxWindow *) 0 ;
39097 int *arg2 = (int *) 0 ;
39098 int *arg3 = (int *) 0 ;
39099 void *argp1 = 0 ;
39100 int res1 = 0 ;
39101 int temp2 ;
39102 int res2 = 0 ;
39103 int temp3 ;
39104 int res3 = 0 ;
39105 PyObject * obj0 = 0 ;
39106 PyObject * obj1 = 0 ;
39107 PyObject * obj2 = 0 ;
39108 char * kwnames[] = {
39109 (char *) "self",(char *) "x",(char *) "y", NULL
39110 };
39111
39112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39114 if (!SWIG_IsOK(res1)) {
39115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39116 }
39117 arg1 = reinterpret_cast< wxWindow * >(argp1);
39118 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39119 int val;
39120 int ecode = SWIG_AsVal_int(obj1, &val);
39121 if (!SWIG_IsOK(ecode)) {
39122 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
39123 }
39124 temp2 = static_cast< int >(val);
39125 arg2 = &temp2;
39126 res2 = SWIG_AddTmpMask(ecode);
39127 }
39128 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39129 int val;
39130 int ecode = SWIG_AsVal_int(obj2, &val);
39131 if (!SWIG_IsOK(ecode)) {
39132 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
39133 }
39134 temp3 = static_cast< int >(val);
39135 arg3 = &temp3;
39136 res3 = SWIG_AddTmpMask(ecode);
39137 }
39138 {
39139 PyThreadState* __tstate = wxPyBeginAllowThreads();
39140 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
39141 wxPyEndAllowThreads(__tstate);
39142 if (PyErr_Occurred()) SWIG_fail;
39143 }
39144 resultobj = SWIG_Py_Void();
39145 if (SWIG_IsTmpObj(res2)) {
39146 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39147 } else {
39148 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39149 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39150 }
39151 if (SWIG_IsTmpObj(res3)) {
39152 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39153 } else {
39154 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39155 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39156 }
39157 return resultobj;
39158 fail:
39159 return NULL;
39160 }
39161
39162
39163 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39164 PyObject *resultobj = 0;
39165 wxWindow *arg1 = (wxWindow *) 0 ;
39166 wxPoint *arg2 = 0 ;
39167 wxPoint result;
39168 void *argp1 = 0 ;
39169 int res1 = 0 ;
39170 wxPoint temp2 ;
39171 PyObject * obj0 = 0 ;
39172 PyObject * obj1 = 0 ;
39173 char * kwnames[] = {
39174 (char *) "self",(char *) "pt", NULL
39175 };
39176
39177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
39178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39179 if (!SWIG_IsOK(res1)) {
39180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
39181 }
39182 arg1 = reinterpret_cast< wxWindow * >(argp1);
39183 {
39184 arg2 = &temp2;
39185 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39186 }
39187 {
39188 PyThreadState* __tstate = wxPyBeginAllowThreads();
39189 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
39190 wxPyEndAllowThreads(__tstate);
39191 if (PyErr_Occurred()) SWIG_fail;
39192 }
39193 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39194 return resultobj;
39195 fail:
39196 return NULL;
39197 }
39198
39199
39200 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39201 PyObject *resultobj = 0;
39202 wxWindow *arg1 = (wxWindow *) 0 ;
39203 wxPoint *arg2 = 0 ;
39204 wxPoint result;
39205 void *argp1 = 0 ;
39206 int res1 = 0 ;
39207 wxPoint temp2 ;
39208 PyObject * obj0 = 0 ;
39209 PyObject * obj1 = 0 ;
39210 char * kwnames[] = {
39211 (char *) "self",(char *) "pt", NULL
39212 };
39213
39214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
39215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39216 if (!SWIG_IsOK(res1)) {
39217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
39218 }
39219 arg1 = reinterpret_cast< wxWindow * >(argp1);
39220 {
39221 arg2 = &temp2;
39222 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39223 }
39224 {
39225 PyThreadState* __tstate = wxPyBeginAllowThreads();
39226 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
39227 wxPyEndAllowThreads(__tstate);
39228 if (PyErr_Occurred()) SWIG_fail;
39229 }
39230 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39231 return resultobj;
39232 fail:
39233 return NULL;
39234 }
39235
39236
39237 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39238 PyObject *resultobj = 0;
39239 wxWindow *arg1 = (wxWindow *) 0 ;
39240 int arg2 ;
39241 int arg3 ;
39242 wxHitTest result;
39243 void *argp1 = 0 ;
39244 int res1 = 0 ;
39245 int val2 ;
39246 int ecode2 = 0 ;
39247 int val3 ;
39248 int ecode3 = 0 ;
39249 PyObject * obj0 = 0 ;
39250 PyObject * obj1 = 0 ;
39251 PyObject * obj2 = 0 ;
39252 char * kwnames[] = {
39253 (char *) "self",(char *) "x",(char *) "y", NULL
39254 };
39255
39256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39258 if (!SWIG_IsOK(res1)) {
39259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39260 }
39261 arg1 = reinterpret_cast< wxWindow * >(argp1);
39262 ecode2 = SWIG_AsVal_int(obj1, &val2);
39263 if (!SWIG_IsOK(ecode2)) {
39264 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
39265 }
39266 arg2 = static_cast< int >(val2);
39267 ecode3 = SWIG_AsVal_int(obj2, &val3);
39268 if (!SWIG_IsOK(ecode3)) {
39269 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
39270 }
39271 arg3 = static_cast< int >(val3);
39272 {
39273 PyThreadState* __tstate = wxPyBeginAllowThreads();
39274 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
39275 wxPyEndAllowThreads(__tstate);
39276 if (PyErr_Occurred()) SWIG_fail;
39277 }
39278 resultobj = SWIG_From_int(static_cast< int >(result));
39279 return resultobj;
39280 fail:
39281 return NULL;
39282 }
39283
39284
39285 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39286 PyObject *resultobj = 0;
39287 wxWindow *arg1 = (wxWindow *) 0 ;
39288 wxPoint *arg2 = 0 ;
39289 wxHitTest result;
39290 void *argp1 = 0 ;
39291 int res1 = 0 ;
39292 wxPoint temp2 ;
39293 PyObject * obj0 = 0 ;
39294 PyObject * obj1 = 0 ;
39295 char * kwnames[] = {
39296 (char *) "self",(char *) "pt", NULL
39297 };
39298
39299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
39300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39301 if (!SWIG_IsOK(res1)) {
39302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
39303 }
39304 arg1 = reinterpret_cast< wxWindow * >(argp1);
39305 {
39306 arg2 = &temp2;
39307 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39308 }
39309 {
39310 PyThreadState* __tstate = wxPyBeginAllowThreads();
39311 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
39312 wxPyEndAllowThreads(__tstate);
39313 if (PyErr_Occurred()) SWIG_fail;
39314 }
39315 resultobj = SWIG_From_int(static_cast< int >(result));
39316 return resultobj;
39317 fail:
39318 return NULL;
39319 }
39320
39321
39322 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39323 PyObject *resultobj = 0;
39324 wxWindow *arg1 = (wxWindow *) 0 ;
39325 long arg2 ;
39326 wxBorder result;
39327 void *argp1 = 0 ;
39328 int res1 = 0 ;
39329 long val2 ;
39330 int ecode2 = 0 ;
39331
39332 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
39333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39334 if (!SWIG_IsOK(res1)) {
39335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39336 }
39337 arg1 = reinterpret_cast< wxWindow * >(argp1);
39338 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
39339 if (!SWIG_IsOK(ecode2)) {
39340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
39341 }
39342 arg2 = static_cast< long >(val2);
39343 {
39344 PyThreadState* __tstate = wxPyBeginAllowThreads();
39345 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
39346 wxPyEndAllowThreads(__tstate);
39347 if (PyErr_Occurred()) SWIG_fail;
39348 }
39349 resultobj = SWIG_From_int(static_cast< int >(result));
39350 return resultobj;
39351 fail:
39352 return NULL;
39353 }
39354
39355
39356 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39357 PyObject *resultobj = 0;
39358 wxWindow *arg1 = (wxWindow *) 0 ;
39359 wxBorder result;
39360 void *argp1 = 0 ;
39361 int res1 = 0 ;
39362
39363 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
39364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39365 if (!SWIG_IsOK(res1)) {
39366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39367 }
39368 arg1 = reinterpret_cast< wxWindow * >(argp1);
39369 {
39370 PyThreadState* __tstate = wxPyBeginAllowThreads();
39371 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
39372 wxPyEndAllowThreads(__tstate);
39373 if (PyErr_Occurred()) SWIG_fail;
39374 }
39375 resultobj = SWIG_From_int(static_cast< int >(result));
39376 return resultobj;
39377 fail:
39378 return NULL;
39379 }
39380
39381
39382 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
39383 int argc;
39384 PyObject *argv[3];
39385
39386 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
39387 --argc;
39388 if (argc == 1) {
39389 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
39390 }
39391 if (argc == 2) {
39392 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
39393 }
39394
39395 fail:
39396 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
39397 return NULL;
39398 }
39399
39400
39401 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39402 PyObject *resultobj = 0;
39403 wxWindow *arg1 = (wxWindow *) 0 ;
39404 long arg2 = (long) wxUPDATE_UI_NONE ;
39405 void *argp1 = 0 ;
39406 int res1 = 0 ;
39407 long val2 ;
39408 int ecode2 = 0 ;
39409 PyObject * obj0 = 0 ;
39410 PyObject * obj1 = 0 ;
39411 char * kwnames[] = {
39412 (char *) "self",(char *) "flags", NULL
39413 };
39414
39415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
39416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39417 if (!SWIG_IsOK(res1)) {
39418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
39419 }
39420 arg1 = reinterpret_cast< wxWindow * >(argp1);
39421 if (obj1) {
39422 ecode2 = SWIG_AsVal_long(obj1, &val2);
39423 if (!SWIG_IsOK(ecode2)) {
39424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
39425 }
39426 arg2 = static_cast< long >(val2);
39427 }
39428 {
39429 PyThreadState* __tstate = wxPyBeginAllowThreads();
39430 (arg1)->UpdateWindowUI(arg2);
39431 wxPyEndAllowThreads(__tstate);
39432 if (PyErr_Occurred()) SWIG_fail;
39433 }
39434 resultobj = SWIG_Py_Void();
39435 return resultobj;
39436 fail:
39437 return NULL;
39438 }
39439
39440
39441 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39442 PyObject *resultobj = 0;
39443 wxWindow *arg1 = (wxWindow *) 0 ;
39444 wxMenu *arg2 = (wxMenu *) 0 ;
39445 int arg3 = (int) -1 ;
39446 int arg4 = (int) -1 ;
39447 bool result;
39448 void *argp1 = 0 ;
39449 int res1 = 0 ;
39450 void *argp2 = 0 ;
39451 int res2 = 0 ;
39452 int val3 ;
39453 int ecode3 = 0 ;
39454 int val4 ;
39455 int ecode4 = 0 ;
39456 PyObject * obj0 = 0 ;
39457 PyObject * obj1 = 0 ;
39458 PyObject * obj2 = 0 ;
39459 PyObject * obj3 = 0 ;
39460 char * kwnames[] = {
39461 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
39462 };
39463
39464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39466 if (!SWIG_IsOK(res1)) {
39467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
39468 }
39469 arg1 = reinterpret_cast< wxWindow * >(argp1);
39470 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39471 if (!SWIG_IsOK(res2)) {
39472 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
39473 }
39474 arg2 = reinterpret_cast< wxMenu * >(argp2);
39475 if (obj2) {
39476 ecode3 = SWIG_AsVal_int(obj2, &val3);
39477 if (!SWIG_IsOK(ecode3)) {
39478 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
39479 }
39480 arg3 = static_cast< int >(val3);
39481 }
39482 if (obj3) {
39483 ecode4 = SWIG_AsVal_int(obj3, &val4);
39484 if (!SWIG_IsOK(ecode4)) {
39485 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
39486 }
39487 arg4 = static_cast< int >(val4);
39488 }
39489 {
39490 PyThreadState* __tstate = wxPyBeginAllowThreads();
39491 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
39492 wxPyEndAllowThreads(__tstate);
39493 if (PyErr_Occurred()) SWIG_fail;
39494 }
39495 {
39496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39497 }
39498 return resultobj;
39499 fail:
39500 return NULL;
39501 }
39502
39503
39504 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39505 PyObject *resultobj = 0;
39506 wxWindow *arg1 = (wxWindow *) 0 ;
39507 wxMenu *arg2 = (wxMenu *) 0 ;
39508 wxPoint const &arg3_defvalue = wxDefaultPosition ;
39509 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
39510 bool result;
39511 void *argp1 = 0 ;
39512 int res1 = 0 ;
39513 void *argp2 = 0 ;
39514 int res2 = 0 ;
39515 wxPoint temp3 ;
39516 PyObject * obj0 = 0 ;
39517 PyObject * obj1 = 0 ;
39518 PyObject * obj2 = 0 ;
39519 char * kwnames[] = {
39520 (char *) "self",(char *) "menu",(char *) "pos", NULL
39521 };
39522
39523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39525 if (!SWIG_IsOK(res1)) {
39526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
39527 }
39528 arg1 = reinterpret_cast< wxWindow * >(argp1);
39529 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39530 if (!SWIG_IsOK(res2)) {
39531 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39532 }
39533 arg2 = reinterpret_cast< wxMenu * >(argp2);
39534 if (obj2) {
39535 {
39536 arg3 = &temp3;
39537 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
39538 }
39539 }
39540 {
39541 PyThreadState* __tstate = wxPyBeginAllowThreads();
39542 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
39543 wxPyEndAllowThreads(__tstate);
39544 if (PyErr_Occurred()) SWIG_fail;
39545 }
39546 {
39547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39548 }
39549 return resultobj;
39550 fail:
39551 return NULL;
39552 }
39553
39554
39555 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39556 PyObject *resultobj = 0;
39557 wxWindow *arg1 = (wxWindow *) 0 ;
39558 bool result;
39559 void *argp1 = 0 ;
39560 int res1 = 0 ;
39561 PyObject *swig_obj[1] ;
39562
39563 if (!args) SWIG_fail;
39564 swig_obj[0] = args;
39565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39566 if (!SWIG_IsOK(res1)) {
39567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
39568 }
39569 arg1 = reinterpret_cast< wxWindow * >(argp1);
39570 {
39571 PyThreadState* __tstate = wxPyBeginAllowThreads();
39572 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
39573 wxPyEndAllowThreads(__tstate);
39574 if (PyErr_Occurred()) SWIG_fail;
39575 }
39576 {
39577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39578 }
39579 return resultobj;
39580 fail:
39581 return NULL;
39582 }
39583
39584
39585 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39586 PyObject *resultobj = 0;
39587 wxWindow *arg1 = (wxWindow *) 0 ;
39588 long result;
39589 void *argp1 = 0 ;
39590 int res1 = 0 ;
39591 PyObject *swig_obj[1] ;
39592
39593 if (!args) SWIG_fail;
39594 swig_obj[0] = args;
39595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39596 if (!SWIG_IsOK(res1)) {
39597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39598 }
39599 arg1 = reinterpret_cast< wxWindow * >(argp1);
39600 {
39601 PyThreadState* __tstate = wxPyBeginAllowThreads();
39602 result = (long)wxWindow_GetHandle(arg1);
39603 wxPyEndAllowThreads(__tstate);
39604 if (PyErr_Occurred()) SWIG_fail;
39605 }
39606 resultobj = SWIG_From_long(static_cast< long >(result));
39607 return resultobj;
39608 fail:
39609 return NULL;
39610 }
39611
39612
39613 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39614 PyObject *resultobj = 0;
39615 wxWindow *arg1 = (wxWindow *) 0 ;
39616 long arg2 ;
39617 void *argp1 = 0 ;
39618 int res1 = 0 ;
39619 long val2 ;
39620 int ecode2 = 0 ;
39621 PyObject * obj0 = 0 ;
39622 PyObject * obj1 = 0 ;
39623 char * kwnames[] = {
39624 (char *) "self",(char *) "handle", NULL
39625 };
39626
39627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
39628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39629 if (!SWIG_IsOK(res1)) {
39630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39631 }
39632 arg1 = reinterpret_cast< wxWindow * >(argp1);
39633 ecode2 = SWIG_AsVal_long(obj1, &val2);
39634 if (!SWIG_IsOK(ecode2)) {
39635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
39636 }
39637 arg2 = static_cast< long >(val2);
39638 {
39639 PyThreadState* __tstate = wxPyBeginAllowThreads();
39640 wxWindow_AssociateHandle(arg1,arg2);
39641 wxPyEndAllowThreads(__tstate);
39642 if (PyErr_Occurred()) SWIG_fail;
39643 }
39644 resultobj = SWIG_Py_Void();
39645 return resultobj;
39646 fail:
39647 return NULL;
39648 }
39649
39650
39651 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39652 PyObject *resultobj = 0;
39653 wxWindow *arg1 = (wxWindow *) 0 ;
39654 void *argp1 = 0 ;
39655 int res1 = 0 ;
39656 PyObject *swig_obj[1] ;
39657
39658 if (!args) SWIG_fail;
39659 swig_obj[0] = args;
39660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39661 if (!SWIG_IsOK(res1)) {
39662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39663 }
39664 arg1 = reinterpret_cast< wxWindow * >(argp1);
39665 {
39666 PyThreadState* __tstate = wxPyBeginAllowThreads();
39667 (arg1)->DissociateHandle();
39668 wxPyEndAllowThreads(__tstate);
39669 if (PyErr_Occurred()) SWIG_fail;
39670 }
39671 resultobj = SWIG_Py_Void();
39672 return resultobj;
39673 fail:
39674 return NULL;
39675 }
39676
39677
39678 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39679 PyObject *resultobj = 0;
39680 wxWindow *arg1 = (wxWindow *) 0 ;
39681 int arg2 ;
39682 bool result;
39683 void *argp1 = 0 ;
39684 int res1 = 0 ;
39685 int val2 ;
39686 int ecode2 = 0 ;
39687 PyObject * obj0 = 0 ;
39688 PyObject * obj1 = 0 ;
39689 char * kwnames[] = {
39690 (char *) "self",(char *) "orient", NULL
39691 };
39692
39693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
39694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39695 if (!SWIG_IsOK(res1)) {
39696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
39697 }
39698 arg1 = reinterpret_cast< wxWindow * >(argp1);
39699 ecode2 = SWIG_AsVal_int(obj1, &val2);
39700 if (!SWIG_IsOK(ecode2)) {
39701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
39702 }
39703 arg2 = static_cast< int >(val2);
39704 {
39705 PyThreadState* __tstate = wxPyBeginAllowThreads();
39706 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
39707 wxPyEndAllowThreads(__tstate);
39708 if (PyErr_Occurred()) SWIG_fail;
39709 }
39710 {
39711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39712 }
39713 return resultobj;
39714 fail:
39715 return NULL;
39716 }
39717
39718
39719 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39720 PyObject *resultobj = 0;
39721 wxWindow *arg1 = (wxWindow *) 0 ;
39722 int arg2 ;
39723 int arg3 ;
39724 int arg4 ;
39725 int arg5 ;
39726 bool arg6 = (bool) true ;
39727 void *argp1 = 0 ;
39728 int res1 = 0 ;
39729 int val2 ;
39730 int ecode2 = 0 ;
39731 int val3 ;
39732 int ecode3 = 0 ;
39733 int val4 ;
39734 int ecode4 = 0 ;
39735 int val5 ;
39736 int ecode5 = 0 ;
39737 bool val6 ;
39738 int ecode6 = 0 ;
39739 PyObject * obj0 = 0 ;
39740 PyObject * obj1 = 0 ;
39741 PyObject * obj2 = 0 ;
39742 PyObject * obj3 = 0 ;
39743 PyObject * obj4 = 0 ;
39744 PyObject * obj5 = 0 ;
39745 char * kwnames[] = {
39746 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
39747 };
39748
39749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39751 if (!SWIG_IsOK(res1)) {
39752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
39753 }
39754 arg1 = reinterpret_cast< wxWindow * >(argp1);
39755 ecode2 = SWIG_AsVal_int(obj1, &val2);
39756 if (!SWIG_IsOK(ecode2)) {
39757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
39758 }
39759 arg2 = static_cast< int >(val2);
39760 ecode3 = SWIG_AsVal_int(obj2, &val3);
39761 if (!SWIG_IsOK(ecode3)) {
39762 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
39763 }
39764 arg3 = static_cast< int >(val3);
39765 ecode4 = SWIG_AsVal_int(obj3, &val4);
39766 if (!SWIG_IsOK(ecode4)) {
39767 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
39768 }
39769 arg4 = static_cast< int >(val4);
39770 ecode5 = SWIG_AsVal_int(obj4, &val5);
39771 if (!SWIG_IsOK(ecode5)) {
39772 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
39773 }
39774 arg5 = static_cast< int >(val5);
39775 if (obj5) {
39776 ecode6 = SWIG_AsVal_bool(obj5, &val6);
39777 if (!SWIG_IsOK(ecode6)) {
39778 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
39779 }
39780 arg6 = static_cast< bool >(val6);
39781 }
39782 {
39783 PyThreadState* __tstate = wxPyBeginAllowThreads();
39784 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
39785 wxPyEndAllowThreads(__tstate);
39786 if (PyErr_Occurred()) SWIG_fail;
39787 }
39788 resultobj = SWIG_Py_Void();
39789 return resultobj;
39790 fail:
39791 return NULL;
39792 }
39793
39794
39795 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39796 PyObject *resultobj = 0;
39797 wxWindow *arg1 = (wxWindow *) 0 ;
39798 int arg2 ;
39799 int arg3 ;
39800 bool arg4 = (bool) true ;
39801 void *argp1 = 0 ;
39802 int res1 = 0 ;
39803 int val2 ;
39804 int ecode2 = 0 ;
39805 int val3 ;
39806 int ecode3 = 0 ;
39807 bool val4 ;
39808 int ecode4 = 0 ;
39809 PyObject * obj0 = 0 ;
39810 PyObject * obj1 = 0 ;
39811 PyObject * obj2 = 0 ;
39812 PyObject * obj3 = 0 ;
39813 char * kwnames[] = {
39814 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
39815 };
39816
39817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39819 if (!SWIG_IsOK(res1)) {
39820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
39821 }
39822 arg1 = reinterpret_cast< wxWindow * >(argp1);
39823 ecode2 = SWIG_AsVal_int(obj1, &val2);
39824 if (!SWIG_IsOK(ecode2)) {
39825 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
39826 }
39827 arg2 = static_cast< int >(val2);
39828 ecode3 = SWIG_AsVal_int(obj2, &val3);
39829 if (!SWIG_IsOK(ecode3)) {
39830 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
39831 }
39832 arg3 = static_cast< int >(val3);
39833 if (obj3) {
39834 ecode4 = SWIG_AsVal_bool(obj3, &val4);
39835 if (!SWIG_IsOK(ecode4)) {
39836 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
39837 }
39838 arg4 = static_cast< bool >(val4);
39839 }
39840 {
39841 PyThreadState* __tstate = wxPyBeginAllowThreads();
39842 (arg1)->SetScrollPos(arg2,arg3,arg4);
39843 wxPyEndAllowThreads(__tstate);
39844 if (PyErr_Occurred()) SWIG_fail;
39845 }
39846 resultobj = SWIG_Py_Void();
39847 return resultobj;
39848 fail:
39849 return NULL;
39850 }
39851
39852
39853 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39854 PyObject *resultobj = 0;
39855 wxWindow *arg1 = (wxWindow *) 0 ;
39856 int arg2 ;
39857 int result;
39858 void *argp1 = 0 ;
39859 int res1 = 0 ;
39860 int val2 ;
39861 int ecode2 = 0 ;
39862 PyObject * obj0 = 0 ;
39863 PyObject * obj1 = 0 ;
39864 char * kwnames[] = {
39865 (char *) "self",(char *) "orientation", NULL
39866 };
39867
39868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
39869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39870 if (!SWIG_IsOK(res1)) {
39871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
39872 }
39873 arg1 = reinterpret_cast< wxWindow * >(argp1);
39874 ecode2 = SWIG_AsVal_int(obj1, &val2);
39875 if (!SWIG_IsOK(ecode2)) {
39876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
39877 }
39878 arg2 = static_cast< int >(val2);
39879 {
39880 PyThreadState* __tstate = wxPyBeginAllowThreads();
39881 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
39882 wxPyEndAllowThreads(__tstate);
39883 if (PyErr_Occurred()) SWIG_fail;
39884 }
39885 resultobj = SWIG_From_int(static_cast< int >(result));
39886 return resultobj;
39887 fail:
39888 return NULL;
39889 }
39890
39891
39892 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39893 PyObject *resultobj = 0;
39894 wxWindow *arg1 = (wxWindow *) 0 ;
39895 int arg2 ;
39896 int result;
39897 void *argp1 = 0 ;
39898 int res1 = 0 ;
39899 int val2 ;
39900 int ecode2 = 0 ;
39901 PyObject * obj0 = 0 ;
39902 PyObject * obj1 = 0 ;
39903 char * kwnames[] = {
39904 (char *) "self",(char *) "orientation", NULL
39905 };
39906
39907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
39908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39909 if (!SWIG_IsOK(res1)) {
39910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
39911 }
39912 arg1 = reinterpret_cast< wxWindow * >(argp1);
39913 ecode2 = SWIG_AsVal_int(obj1, &val2);
39914 if (!SWIG_IsOK(ecode2)) {
39915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
39916 }
39917 arg2 = static_cast< int >(val2);
39918 {
39919 PyThreadState* __tstate = wxPyBeginAllowThreads();
39920 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
39921 wxPyEndAllowThreads(__tstate);
39922 if (PyErr_Occurred()) SWIG_fail;
39923 }
39924 resultobj = SWIG_From_int(static_cast< int >(result));
39925 return resultobj;
39926 fail:
39927 return NULL;
39928 }
39929
39930
39931 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39932 PyObject *resultobj = 0;
39933 wxWindow *arg1 = (wxWindow *) 0 ;
39934 int arg2 ;
39935 int result;
39936 void *argp1 = 0 ;
39937 int res1 = 0 ;
39938 int val2 ;
39939 int ecode2 = 0 ;
39940 PyObject * obj0 = 0 ;
39941 PyObject * obj1 = 0 ;
39942 char * kwnames[] = {
39943 (char *) "self",(char *) "orientation", NULL
39944 };
39945
39946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
39947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39948 if (!SWIG_IsOK(res1)) {
39949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
39950 }
39951 arg1 = reinterpret_cast< wxWindow * >(argp1);
39952 ecode2 = SWIG_AsVal_int(obj1, &val2);
39953 if (!SWIG_IsOK(ecode2)) {
39954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
39955 }
39956 arg2 = static_cast< int >(val2);
39957 {
39958 PyThreadState* __tstate = wxPyBeginAllowThreads();
39959 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
39960 wxPyEndAllowThreads(__tstate);
39961 if (PyErr_Occurred()) SWIG_fail;
39962 }
39963 resultobj = SWIG_From_int(static_cast< int >(result));
39964 return resultobj;
39965 fail:
39966 return NULL;
39967 }
39968
39969
39970 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39971 PyObject *resultobj = 0;
39972 wxWindow *arg1 = (wxWindow *) 0 ;
39973 int arg2 ;
39974 int arg3 ;
39975 wxRect *arg4 = (wxRect *) NULL ;
39976 void *argp1 = 0 ;
39977 int res1 = 0 ;
39978 int val2 ;
39979 int ecode2 = 0 ;
39980 int val3 ;
39981 int ecode3 = 0 ;
39982 void *argp4 = 0 ;
39983 int res4 = 0 ;
39984 PyObject * obj0 = 0 ;
39985 PyObject * obj1 = 0 ;
39986 PyObject * obj2 = 0 ;
39987 PyObject * obj3 = 0 ;
39988 char * kwnames[] = {
39989 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
39990 };
39991
39992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39994 if (!SWIG_IsOK(res1)) {
39995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
39996 }
39997 arg1 = reinterpret_cast< wxWindow * >(argp1);
39998 ecode2 = SWIG_AsVal_int(obj1, &val2);
39999 if (!SWIG_IsOK(ecode2)) {
40000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
40001 }
40002 arg2 = static_cast< int >(val2);
40003 ecode3 = SWIG_AsVal_int(obj2, &val3);
40004 if (!SWIG_IsOK(ecode3)) {
40005 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
40006 }
40007 arg3 = static_cast< int >(val3);
40008 if (obj3) {
40009 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
40010 if (!SWIG_IsOK(res4)) {
40011 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
40012 }
40013 arg4 = reinterpret_cast< wxRect * >(argp4);
40014 }
40015 {
40016 PyThreadState* __tstate = wxPyBeginAllowThreads();
40017 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
40018 wxPyEndAllowThreads(__tstate);
40019 if (PyErr_Occurred()) SWIG_fail;
40020 }
40021 resultobj = SWIG_Py_Void();
40022 return resultobj;
40023 fail:
40024 return NULL;
40025 }
40026
40027
40028 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40029 PyObject *resultobj = 0;
40030 wxWindow *arg1 = (wxWindow *) 0 ;
40031 int arg2 ;
40032 bool result;
40033 void *argp1 = 0 ;
40034 int res1 = 0 ;
40035 int val2 ;
40036 int ecode2 = 0 ;
40037 PyObject * obj0 = 0 ;
40038 PyObject * obj1 = 0 ;
40039 char * kwnames[] = {
40040 (char *) "self",(char *) "lines", NULL
40041 };
40042
40043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
40044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40045 if (!SWIG_IsOK(res1)) {
40046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
40047 }
40048 arg1 = reinterpret_cast< wxWindow * >(argp1);
40049 ecode2 = SWIG_AsVal_int(obj1, &val2);
40050 if (!SWIG_IsOK(ecode2)) {
40051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
40052 }
40053 arg2 = static_cast< int >(val2);
40054 {
40055 PyThreadState* __tstate = wxPyBeginAllowThreads();
40056 result = (bool)(arg1)->ScrollLines(arg2);
40057 wxPyEndAllowThreads(__tstate);
40058 if (PyErr_Occurred()) SWIG_fail;
40059 }
40060 {
40061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40062 }
40063 return resultobj;
40064 fail:
40065 return NULL;
40066 }
40067
40068
40069 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40070 PyObject *resultobj = 0;
40071 wxWindow *arg1 = (wxWindow *) 0 ;
40072 int arg2 ;
40073 bool result;
40074 void *argp1 = 0 ;
40075 int res1 = 0 ;
40076 int val2 ;
40077 int ecode2 = 0 ;
40078 PyObject * obj0 = 0 ;
40079 PyObject * obj1 = 0 ;
40080 char * kwnames[] = {
40081 (char *) "self",(char *) "pages", NULL
40082 };
40083
40084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
40085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40086 if (!SWIG_IsOK(res1)) {
40087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
40088 }
40089 arg1 = reinterpret_cast< wxWindow * >(argp1);
40090 ecode2 = SWIG_AsVal_int(obj1, &val2);
40091 if (!SWIG_IsOK(ecode2)) {
40092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
40093 }
40094 arg2 = static_cast< int >(val2);
40095 {
40096 PyThreadState* __tstate = wxPyBeginAllowThreads();
40097 result = (bool)(arg1)->ScrollPages(arg2);
40098 wxPyEndAllowThreads(__tstate);
40099 if (PyErr_Occurred()) SWIG_fail;
40100 }
40101 {
40102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40103 }
40104 return resultobj;
40105 fail:
40106 return NULL;
40107 }
40108
40109
40110 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40111 PyObject *resultobj = 0;
40112 wxWindow *arg1 = (wxWindow *) 0 ;
40113 bool result;
40114 void *argp1 = 0 ;
40115 int res1 = 0 ;
40116 PyObject *swig_obj[1] ;
40117
40118 if (!args) SWIG_fail;
40119 swig_obj[0] = args;
40120 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40121 if (!SWIG_IsOK(res1)) {
40122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40123 }
40124 arg1 = reinterpret_cast< wxWindow * >(argp1);
40125 {
40126 PyThreadState* __tstate = wxPyBeginAllowThreads();
40127 result = (bool)(arg1)->LineUp();
40128 wxPyEndAllowThreads(__tstate);
40129 if (PyErr_Occurred()) SWIG_fail;
40130 }
40131 {
40132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40133 }
40134 return resultobj;
40135 fail:
40136 return NULL;
40137 }
40138
40139
40140 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40141 PyObject *resultobj = 0;
40142 wxWindow *arg1 = (wxWindow *) 0 ;
40143 bool result;
40144 void *argp1 = 0 ;
40145 int res1 = 0 ;
40146 PyObject *swig_obj[1] ;
40147
40148 if (!args) SWIG_fail;
40149 swig_obj[0] = args;
40150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40151 if (!SWIG_IsOK(res1)) {
40152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40153 }
40154 arg1 = reinterpret_cast< wxWindow * >(argp1);
40155 {
40156 PyThreadState* __tstate = wxPyBeginAllowThreads();
40157 result = (bool)(arg1)->LineDown();
40158 wxPyEndAllowThreads(__tstate);
40159 if (PyErr_Occurred()) SWIG_fail;
40160 }
40161 {
40162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40163 }
40164 return resultobj;
40165 fail:
40166 return NULL;
40167 }
40168
40169
40170 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40171 PyObject *resultobj = 0;
40172 wxWindow *arg1 = (wxWindow *) 0 ;
40173 bool result;
40174 void *argp1 = 0 ;
40175 int res1 = 0 ;
40176 PyObject *swig_obj[1] ;
40177
40178 if (!args) SWIG_fail;
40179 swig_obj[0] = args;
40180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40181 if (!SWIG_IsOK(res1)) {
40182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40183 }
40184 arg1 = reinterpret_cast< wxWindow * >(argp1);
40185 {
40186 PyThreadState* __tstate = wxPyBeginAllowThreads();
40187 result = (bool)(arg1)->PageUp();
40188 wxPyEndAllowThreads(__tstate);
40189 if (PyErr_Occurred()) SWIG_fail;
40190 }
40191 {
40192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40193 }
40194 return resultobj;
40195 fail:
40196 return NULL;
40197 }
40198
40199
40200 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40201 PyObject *resultobj = 0;
40202 wxWindow *arg1 = (wxWindow *) 0 ;
40203 bool result;
40204 void *argp1 = 0 ;
40205 int res1 = 0 ;
40206 PyObject *swig_obj[1] ;
40207
40208 if (!args) SWIG_fail;
40209 swig_obj[0] = args;
40210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40211 if (!SWIG_IsOK(res1)) {
40212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40213 }
40214 arg1 = reinterpret_cast< wxWindow * >(argp1);
40215 {
40216 PyThreadState* __tstate = wxPyBeginAllowThreads();
40217 result = (bool)(arg1)->PageDown();
40218 wxPyEndAllowThreads(__tstate);
40219 if (PyErr_Occurred()) SWIG_fail;
40220 }
40221 {
40222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40223 }
40224 return resultobj;
40225 fail:
40226 return NULL;
40227 }
40228
40229
40230 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40231 PyObject *resultobj = 0;
40232 wxWindow *arg1 = (wxWindow *) 0 ;
40233 wxString *arg2 = 0 ;
40234 void *argp1 = 0 ;
40235 int res1 = 0 ;
40236 bool temp2 = false ;
40237 PyObject * obj0 = 0 ;
40238 PyObject * obj1 = 0 ;
40239 char * kwnames[] = {
40240 (char *) "self",(char *) "text", NULL
40241 };
40242
40243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
40244 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40245 if (!SWIG_IsOK(res1)) {
40246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
40247 }
40248 arg1 = reinterpret_cast< wxWindow * >(argp1);
40249 {
40250 arg2 = wxString_in_helper(obj1);
40251 if (arg2 == NULL) SWIG_fail;
40252 temp2 = true;
40253 }
40254 {
40255 PyThreadState* __tstate = wxPyBeginAllowThreads();
40256 (arg1)->SetHelpText((wxString const &)*arg2);
40257 wxPyEndAllowThreads(__tstate);
40258 if (PyErr_Occurred()) SWIG_fail;
40259 }
40260 resultobj = SWIG_Py_Void();
40261 {
40262 if (temp2)
40263 delete arg2;
40264 }
40265 return resultobj;
40266 fail:
40267 {
40268 if (temp2)
40269 delete arg2;
40270 }
40271 return NULL;
40272 }
40273
40274
40275 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40276 PyObject *resultobj = 0;
40277 wxWindow *arg1 = (wxWindow *) 0 ;
40278 wxString *arg2 = 0 ;
40279 void *argp1 = 0 ;
40280 int res1 = 0 ;
40281 bool temp2 = false ;
40282 PyObject * obj0 = 0 ;
40283 PyObject * obj1 = 0 ;
40284 char * kwnames[] = {
40285 (char *) "self",(char *) "text", NULL
40286 };
40287
40288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
40289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40290 if (!SWIG_IsOK(res1)) {
40291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
40292 }
40293 arg1 = reinterpret_cast< wxWindow * >(argp1);
40294 {
40295 arg2 = wxString_in_helper(obj1);
40296 if (arg2 == NULL) SWIG_fail;
40297 temp2 = true;
40298 }
40299 {
40300 PyThreadState* __tstate = wxPyBeginAllowThreads();
40301 (arg1)->SetHelpTextForId((wxString const &)*arg2);
40302 wxPyEndAllowThreads(__tstate);
40303 if (PyErr_Occurred()) SWIG_fail;
40304 }
40305 resultobj = SWIG_Py_Void();
40306 {
40307 if (temp2)
40308 delete arg2;
40309 }
40310 return resultobj;
40311 fail:
40312 {
40313 if (temp2)
40314 delete arg2;
40315 }
40316 return NULL;
40317 }
40318
40319
40320 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40321 PyObject *resultobj = 0;
40322 wxWindow *arg1 = (wxWindow *) 0 ;
40323 wxPoint *arg2 = 0 ;
40324 wxHelpEvent::Origin arg3 ;
40325 wxString result;
40326 void *argp1 = 0 ;
40327 int res1 = 0 ;
40328 wxPoint temp2 ;
40329 void *argp3 ;
40330 int res3 = 0 ;
40331 PyObject * obj0 = 0 ;
40332 PyObject * obj1 = 0 ;
40333 PyObject * obj2 = 0 ;
40334 char * kwnames[] = {
40335 (char *) "self",(char *) "pt",(char *) "origin", NULL
40336 };
40337
40338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40340 if (!SWIG_IsOK(res1)) {
40341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
40342 }
40343 arg1 = reinterpret_cast< wxWindow * >(argp1);
40344 {
40345 arg2 = &temp2;
40346 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40347 }
40348 {
40349 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
40350 if (!SWIG_IsOK(res3)) {
40351 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40352 }
40353 if (!argp3) {
40354 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40355 } else {
40356 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
40357 arg3 = *temp;
40358 if (SWIG_IsNewObj(res3)) delete temp;
40359 }
40360 }
40361 {
40362 PyThreadState* __tstate = wxPyBeginAllowThreads();
40363 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
40364 wxPyEndAllowThreads(__tstate);
40365 if (PyErr_Occurred()) SWIG_fail;
40366 }
40367 {
40368 #if wxUSE_UNICODE
40369 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40370 #else
40371 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40372 #endif
40373 }
40374 return resultobj;
40375 fail:
40376 return NULL;
40377 }
40378
40379
40380 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40381 PyObject *resultobj = 0;
40382 wxWindow *arg1 = (wxWindow *) 0 ;
40383 wxString result;
40384 void *argp1 = 0 ;
40385 int res1 = 0 ;
40386 PyObject *swig_obj[1] ;
40387
40388 if (!args) SWIG_fail;
40389 swig_obj[0] = args;
40390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40391 if (!SWIG_IsOK(res1)) {
40392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
40393 }
40394 arg1 = reinterpret_cast< wxWindow * >(argp1);
40395 {
40396 PyThreadState* __tstate = wxPyBeginAllowThreads();
40397 result = ((wxWindow const *)arg1)->GetHelpText();
40398 wxPyEndAllowThreads(__tstate);
40399 if (PyErr_Occurred()) SWIG_fail;
40400 }
40401 {
40402 #if wxUSE_UNICODE
40403 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40404 #else
40405 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40406 #endif
40407 }
40408 return resultobj;
40409 fail:
40410 return NULL;
40411 }
40412
40413
40414 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40415 PyObject *resultobj = 0;
40416 wxWindow *arg1 = (wxWindow *) 0 ;
40417 wxString *arg2 = 0 ;
40418 void *argp1 = 0 ;
40419 int res1 = 0 ;
40420 bool temp2 = false ;
40421 PyObject * obj0 = 0 ;
40422 PyObject * obj1 = 0 ;
40423 char * kwnames[] = {
40424 (char *) "self",(char *) "tip", NULL
40425 };
40426
40427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
40428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40429 if (!SWIG_IsOK(res1)) {
40430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
40431 }
40432 arg1 = reinterpret_cast< wxWindow * >(argp1);
40433 {
40434 arg2 = wxString_in_helper(obj1);
40435 if (arg2 == NULL) SWIG_fail;
40436 temp2 = true;
40437 }
40438 {
40439 PyThreadState* __tstate = wxPyBeginAllowThreads();
40440 (arg1)->SetToolTip((wxString const &)*arg2);
40441 wxPyEndAllowThreads(__tstate);
40442 if (PyErr_Occurred()) SWIG_fail;
40443 }
40444 resultobj = SWIG_Py_Void();
40445 {
40446 if (temp2)
40447 delete arg2;
40448 }
40449 return resultobj;
40450 fail:
40451 {
40452 if (temp2)
40453 delete arg2;
40454 }
40455 return NULL;
40456 }
40457
40458
40459 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40460 PyObject *resultobj = 0;
40461 wxWindow *arg1 = (wxWindow *) 0 ;
40462 wxToolTip *arg2 = (wxToolTip *) 0 ;
40463 void *argp1 = 0 ;
40464 int res1 = 0 ;
40465 int res2 = 0 ;
40466 PyObject * obj0 = 0 ;
40467 PyObject * obj1 = 0 ;
40468 char * kwnames[] = {
40469 (char *) "self",(char *) "tip", NULL
40470 };
40471
40472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
40473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40474 if (!SWIG_IsOK(res1)) {
40475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
40476 }
40477 arg1 = reinterpret_cast< wxWindow * >(argp1);
40478 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
40479 if (!SWIG_IsOK(res2)) {
40480 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
40481 }
40482 {
40483 PyThreadState* __tstate = wxPyBeginAllowThreads();
40484 (arg1)->SetToolTip(arg2);
40485 wxPyEndAllowThreads(__tstate);
40486 if (PyErr_Occurred()) SWIG_fail;
40487 }
40488 resultobj = SWIG_Py_Void();
40489 return resultobj;
40490 fail:
40491 return NULL;
40492 }
40493
40494
40495 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40496 PyObject *resultobj = 0;
40497 wxWindow *arg1 = (wxWindow *) 0 ;
40498 wxToolTip *result = 0 ;
40499 void *argp1 = 0 ;
40500 int res1 = 0 ;
40501 PyObject *swig_obj[1] ;
40502
40503 if (!args) SWIG_fail;
40504 swig_obj[0] = args;
40505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40506 if (!SWIG_IsOK(res1)) {
40507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
40508 }
40509 arg1 = reinterpret_cast< wxWindow * >(argp1);
40510 {
40511 PyThreadState* __tstate = wxPyBeginAllowThreads();
40512 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
40513 wxPyEndAllowThreads(__tstate);
40514 if (PyErr_Occurred()) SWIG_fail;
40515 }
40516 {
40517 resultobj = wxPyMake_wxObject(result, (bool)0);
40518 }
40519 return resultobj;
40520 fail:
40521 return NULL;
40522 }
40523
40524
40525 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40526 PyObject *resultobj = 0;
40527 wxWindow *arg1 = (wxWindow *) 0 ;
40528 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
40529 void *argp1 = 0 ;
40530 int res1 = 0 ;
40531 int res2 = 0 ;
40532 PyObject * obj0 = 0 ;
40533 PyObject * obj1 = 0 ;
40534 char * kwnames[] = {
40535 (char *) "self",(char *) "dropTarget", NULL
40536 };
40537
40538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
40539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40540 if (!SWIG_IsOK(res1)) {
40541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
40542 }
40543 arg1 = reinterpret_cast< wxWindow * >(argp1);
40544 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
40545 if (!SWIG_IsOK(res2)) {
40546 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
40547 }
40548 {
40549 PyThreadState* __tstate = wxPyBeginAllowThreads();
40550 (arg1)->SetDropTarget(arg2);
40551 wxPyEndAllowThreads(__tstate);
40552 if (PyErr_Occurred()) SWIG_fail;
40553 }
40554 resultobj = SWIG_Py_Void();
40555 return resultobj;
40556 fail:
40557 return NULL;
40558 }
40559
40560
40561 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40562 PyObject *resultobj = 0;
40563 wxWindow *arg1 = (wxWindow *) 0 ;
40564 wxPyDropTarget *result = 0 ;
40565 void *argp1 = 0 ;
40566 int res1 = 0 ;
40567 PyObject *swig_obj[1] ;
40568
40569 if (!args) SWIG_fail;
40570 swig_obj[0] = args;
40571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40572 if (!SWIG_IsOK(res1)) {
40573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
40574 }
40575 arg1 = reinterpret_cast< wxWindow * >(argp1);
40576 {
40577 PyThreadState* __tstate = wxPyBeginAllowThreads();
40578 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
40579 wxPyEndAllowThreads(__tstate);
40580 if (PyErr_Occurred()) SWIG_fail;
40581 }
40582 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
40583 return resultobj;
40584 fail:
40585 return NULL;
40586 }
40587
40588
40589 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40590 PyObject *resultobj = 0;
40591 wxWindow *arg1 = (wxWindow *) 0 ;
40592 bool arg2 ;
40593 void *argp1 = 0 ;
40594 int res1 = 0 ;
40595 bool val2 ;
40596 int ecode2 = 0 ;
40597 PyObject * obj0 = 0 ;
40598 PyObject * obj1 = 0 ;
40599 char * kwnames[] = {
40600 (char *) "self",(char *) "accept", NULL
40601 };
40602
40603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
40604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40605 if (!SWIG_IsOK(res1)) {
40606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
40607 }
40608 arg1 = reinterpret_cast< wxWindow * >(argp1);
40609 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40610 if (!SWIG_IsOK(ecode2)) {
40611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
40612 }
40613 arg2 = static_cast< bool >(val2);
40614 {
40615 PyThreadState* __tstate = wxPyBeginAllowThreads();
40616 wxWindow_DragAcceptFiles(arg1,arg2);
40617 wxPyEndAllowThreads(__tstate);
40618 if (PyErr_Occurred()) SWIG_fail;
40619 }
40620 resultobj = SWIG_Py_Void();
40621 return resultobj;
40622 fail:
40623 return NULL;
40624 }
40625
40626
40627 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40628 PyObject *resultobj = 0;
40629 wxWindow *arg1 = (wxWindow *) 0 ;
40630 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
40631 void *argp1 = 0 ;
40632 int res1 = 0 ;
40633 int res2 = 0 ;
40634 PyObject * obj0 = 0 ;
40635 PyObject * obj1 = 0 ;
40636 char * kwnames[] = {
40637 (char *) "self",(char *) "constraints", NULL
40638 };
40639
40640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
40641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40642 if (!SWIG_IsOK(res1)) {
40643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
40644 }
40645 arg1 = reinterpret_cast< wxWindow * >(argp1);
40646 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
40647 if (!SWIG_IsOK(res2)) {
40648 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
40649 }
40650 {
40651 PyThreadState* __tstate = wxPyBeginAllowThreads();
40652 (arg1)->SetConstraints(arg2);
40653 wxPyEndAllowThreads(__tstate);
40654 if (PyErr_Occurred()) SWIG_fail;
40655 }
40656 resultobj = SWIG_Py_Void();
40657 return resultobj;
40658 fail:
40659 return NULL;
40660 }
40661
40662
40663 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40664 PyObject *resultobj = 0;
40665 wxWindow *arg1 = (wxWindow *) 0 ;
40666 wxLayoutConstraints *result = 0 ;
40667 void *argp1 = 0 ;
40668 int res1 = 0 ;
40669 PyObject *swig_obj[1] ;
40670
40671 if (!args) SWIG_fail;
40672 swig_obj[0] = args;
40673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40674 if (!SWIG_IsOK(res1)) {
40675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
40676 }
40677 arg1 = reinterpret_cast< wxWindow * >(argp1);
40678 {
40679 PyThreadState* __tstate = wxPyBeginAllowThreads();
40680 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
40681 wxPyEndAllowThreads(__tstate);
40682 if (PyErr_Occurred()) SWIG_fail;
40683 }
40684 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
40685 return resultobj;
40686 fail:
40687 return NULL;
40688 }
40689
40690
40691 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40692 PyObject *resultobj = 0;
40693 wxWindow *arg1 = (wxWindow *) 0 ;
40694 bool arg2 ;
40695 void *argp1 = 0 ;
40696 int res1 = 0 ;
40697 bool val2 ;
40698 int ecode2 = 0 ;
40699 PyObject * obj0 = 0 ;
40700 PyObject * obj1 = 0 ;
40701 char * kwnames[] = {
40702 (char *) "self",(char *) "autoLayout", NULL
40703 };
40704
40705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
40706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40707 if (!SWIG_IsOK(res1)) {
40708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
40709 }
40710 arg1 = reinterpret_cast< wxWindow * >(argp1);
40711 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40712 if (!SWIG_IsOK(ecode2)) {
40713 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
40714 }
40715 arg2 = static_cast< bool >(val2);
40716 {
40717 PyThreadState* __tstate = wxPyBeginAllowThreads();
40718 (arg1)->SetAutoLayout(arg2);
40719 wxPyEndAllowThreads(__tstate);
40720 if (PyErr_Occurred()) SWIG_fail;
40721 }
40722 resultobj = SWIG_Py_Void();
40723 return resultobj;
40724 fail:
40725 return NULL;
40726 }
40727
40728
40729 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40730 PyObject *resultobj = 0;
40731 wxWindow *arg1 = (wxWindow *) 0 ;
40732 bool result;
40733 void *argp1 = 0 ;
40734 int res1 = 0 ;
40735 PyObject *swig_obj[1] ;
40736
40737 if (!args) SWIG_fail;
40738 swig_obj[0] = args;
40739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40740 if (!SWIG_IsOK(res1)) {
40741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
40742 }
40743 arg1 = reinterpret_cast< wxWindow * >(argp1);
40744 {
40745 PyThreadState* __tstate = wxPyBeginAllowThreads();
40746 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
40747 wxPyEndAllowThreads(__tstate);
40748 if (PyErr_Occurred()) SWIG_fail;
40749 }
40750 {
40751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40752 }
40753 return resultobj;
40754 fail:
40755 return NULL;
40756 }
40757
40758
40759 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40760 PyObject *resultobj = 0;
40761 wxWindow *arg1 = (wxWindow *) 0 ;
40762 bool result;
40763 void *argp1 = 0 ;
40764 int res1 = 0 ;
40765 PyObject *swig_obj[1] ;
40766
40767 if (!args) SWIG_fail;
40768 swig_obj[0] = args;
40769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40770 if (!SWIG_IsOK(res1)) {
40771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
40772 }
40773 arg1 = reinterpret_cast< wxWindow * >(argp1);
40774 {
40775 PyThreadState* __tstate = wxPyBeginAllowThreads();
40776 result = (bool)(arg1)->Layout();
40777 wxPyEndAllowThreads(__tstate);
40778 if (PyErr_Occurred()) SWIG_fail;
40779 }
40780 {
40781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40782 }
40783 return resultobj;
40784 fail:
40785 return NULL;
40786 }
40787
40788
40789 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40790 PyObject *resultobj = 0;
40791 wxWindow *arg1 = (wxWindow *) 0 ;
40792 wxSizer *arg2 = (wxSizer *) 0 ;
40793 bool arg3 = (bool) true ;
40794 void *argp1 = 0 ;
40795 int res1 = 0 ;
40796 int res2 = 0 ;
40797 bool val3 ;
40798 int ecode3 = 0 ;
40799 PyObject * obj0 = 0 ;
40800 PyObject * obj1 = 0 ;
40801 PyObject * obj2 = 0 ;
40802 char * kwnames[] = {
40803 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40804 };
40805
40806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40808 if (!SWIG_IsOK(res1)) {
40809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
40810 }
40811 arg1 = reinterpret_cast< wxWindow * >(argp1);
40812 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40813 if (!SWIG_IsOK(res2)) {
40814 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
40815 }
40816 if (obj2) {
40817 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40818 if (!SWIG_IsOK(ecode3)) {
40819 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
40820 }
40821 arg3 = static_cast< bool >(val3);
40822 }
40823 {
40824 PyThreadState* __tstate = wxPyBeginAllowThreads();
40825 (arg1)->SetSizer(arg2,arg3);
40826 wxPyEndAllowThreads(__tstate);
40827 if (PyErr_Occurred()) SWIG_fail;
40828 }
40829 resultobj = SWIG_Py_Void();
40830 return resultobj;
40831 fail:
40832 return NULL;
40833 }
40834
40835
40836 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40837 PyObject *resultobj = 0;
40838 wxWindow *arg1 = (wxWindow *) 0 ;
40839 wxSizer *arg2 = (wxSizer *) 0 ;
40840 bool arg3 = (bool) true ;
40841 void *argp1 = 0 ;
40842 int res1 = 0 ;
40843 int res2 = 0 ;
40844 bool val3 ;
40845 int ecode3 = 0 ;
40846 PyObject * obj0 = 0 ;
40847 PyObject * obj1 = 0 ;
40848 PyObject * obj2 = 0 ;
40849 char * kwnames[] = {
40850 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40851 };
40852
40853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40855 if (!SWIG_IsOK(res1)) {
40856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
40857 }
40858 arg1 = reinterpret_cast< wxWindow * >(argp1);
40859 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40860 if (!SWIG_IsOK(res2)) {
40861 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
40862 }
40863 if (obj2) {
40864 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40865 if (!SWIG_IsOK(ecode3)) {
40866 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
40867 }
40868 arg3 = static_cast< bool >(val3);
40869 }
40870 {
40871 PyThreadState* __tstate = wxPyBeginAllowThreads();
40872 (arg1)->SetSizerAndFit(arg2,arg3);
40873 wxPyEndAllowThreads(__tstate);
40874 if (PyErr_Occurred()) SWIG_fail;
40875 }
40876 resultobj = SWIG_Py_Void();
40877 return resultobj;
40878 fail:
40879 return NULL;
40880 }
40881
40882
40883 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40884 PyObject *resultobj = 0;
40885 wxWindow *arg1 = (wxWindow *) 0 ;
40886 wxSizer *result = 0 ;
40887 void *argp1 = 0 ;
40888 int res1 = 0 ;
40889 PyObject *swig_obj[1] ;
40890
40891 if (!args) SWIG_fail;
40892 swig_obj[0] = args;
40893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40894 if (!SWIG_IsOK(res1)) {
40895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
40896 }
40897 arg1 = reinterpret_cast< wxWindow * >(argp1);
40898 {
40899 PyThreadState* __tstate = wxPyBeginAllowThreads();
40900 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
40901 wxPyEndAllowThreads(__tstate);
40902 if (PyErr_Occurred()) SWIG_fail;
40903 }
40904 {
40905 resultobj = wxPyMake_wxObject(result, (bool)0);
40906 }
40907 return resultobj;
40908 fail:
40909 return NULL;
40910 }
40911
40912
40913 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40914 PyObject *resultobj = 0;
40915 wxWindow *arg1 = (wxWindow *) 0 ;
40916 wxSizer *arg2 = (wxSizer *) 0 ;
40917 void *argp1 = 0 ;
40918 int res1 = 0 ;
40919 void *argp2 = 0 ;
40920 int res2 = 0 ;
40921 PyObject * obj0 = 0 ;
40922 PyObject * obj1 = 0 ;
40923 char * kwnames[] = {
40924 (char *) "self",(char *) "sizer", NULL
40925 };
40926
40927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
40928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40929 if (!SWIG_IsOK(res1)) {
40930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
40931 }
40932 arg1 = reinterpret_cast< wxWindow * >(argp1);
40933 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
40934 if (!SWIG_IsOK(res2)) {
40935 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
40936 }
40937 arg2 = reinterpret_cast< wxSizer * >(argp2);
40938 {
40939 PyThreadState* __tstate = wxPyBeginAllowThreads();
40940 (arg1)->SetContainingSizer(arg2);
40941 wxPyEndAllowThreads(__tstate);
40942 if (PyErr_Occurred()) SWIG_fail;
40943 }
40944 resultobj = SWIG_Py_Void();
40945 return resultobj;
40946 fail:
40947 return NULL;
40948 }
40949
40950
40951 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40952 PyObject *resultobj = 0;
40953 wxWindow *arg1 = (wxWindow *) 0 ;
40954 wxSizer *result = 0 ;
40955 void *argp1 = 0 ;
40956 int res1 = 0 ;
40957 PyObject *swig_obj[1] ;
40958
40959 if (!args) SWIG_fail;
40960 swig_obj[0] = args;
40961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40962 if (!SWIG_IsOK(res1)) {
40963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
40964 }
40965 arg1 = reinterpret_cast< wxWindow * >(argp1);
40966 {
40967 PyThreadState* __tstate = wxPyBeginAllowThreads();
40968 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
40969 wxPyEndAllowThreads(__tstate);
40970 if (PyErr_Occurred()) SWIG_fail;
40971 }
40972 {
40973 resultobj = wxPyMake_wxObject(result, (bool)0);
40974 }
40975 return resultobj;
40976 fail:
40977 return NULL;
40978 }
40979
40980
40981 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40982 PyObject *resultobj = 0;
40983 wxWindow *arg1 = (wxWindow *) 0 ;
40984 void *argp1 = 0 ;
40985 int res1 = 0 ;
40986 PyObject *swig_obj[1] ;
40987
40988 if (!args) SWIG_fail;
40989 swig_obj[0] = args;
40990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40991 if (!SWIG_IsOK(res1)) {
40992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
40993 }
40994 arg1 = reinterpret_cast< wxWindow * >(argp1);
40995 {
40996 PyThreadState* __tstate = wxPyBeginAllowThreads();
40997 (arg1)->InheritAttributes();
40998 wxPyEndAllowThreads(__tstate);
40999 if (PyErr_Occurred()) SWIG_fail;
41000 }
41001 resultobj = SWIG_Py_Void();
41002 return resultobj;
41003 fail:
41004 return NULL;
41005 }
41006
41007
41008 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41009 PyObject *resultobj = 0;
41010 wxWindow *arg1 = (wxWindow *) 0 ;
41011 bool result;
41012 void *argp1 = 0 ;
41013 int res1 = 0 ;
41014 PyObject *swig_obj[1] ;
41015
41016 if (!args) SWIG_fail;
41017 swig_obj[0] = args;
41018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41019 if (!SWIG_IsOK(res1)) {
41020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
41021 }
41022 arg1 = reinterpret_cast< wxWindow * >(argp1);
41023 {
41024 PyThreadState* __tstate = wxPyBeginAllowThreads();
41025 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
41026 wxPyEndAllowThreads(__tstate);
41027 if (PyErr_Occurred()) SWIG_fail;
41028 }
41029 {
41030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41031 }
41032 return resultobj;
41033 fail:
41034 return NULL;
41035 }
41036
41037
41038 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41039 PyObject *resultobj = 0;
41040 wxWindow *arg1 = (wxWindow *) 0 ;
41041 bool result;
41042 void *argp1 = 0 ;
41043 int res1 = 0 ;
41044 PyObject *swig_obj[1] ;
41045
41046 if (!args) SWIG_fail;
41047 swig_obj[0] = args;
41048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41049 if (!SWIG_IsOK(res1)) {
41050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41051 }
41052 arg1 = reinterpret_cast< wxWindow * >(argp1);
41053 {
41054 PyThreadState* __tstate = wxPyBeginAllowThreads();
41055 result = (bool)(arg1)->CanSetTransparent();
41056 wxPyEndAllowThreads(__tstate);
41057 if (PyErr_Occurred()) SWIG_fail;
41058 }
41059 {
41060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41061 }
41062 return resultobj;
41063 fail:
41064 return NULL;
41065 }
41066
41067
41068 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41069 PyObject *resultobj = 0;
41070 wxWindow *arg1 = (wxWindow *) 0 ;
41071 byte arg2 ;
41072 bool result;
41073 void *argp1 = 0 ;
41074 int res1 = 0 ;
41075 unsigned char val2 ;
41076 int ecode2 = 0 ;
41077 PyObject * obj0 = 0 ;
41078 PyObject * obj1 = 0 ;
41079 char * kwnames[] = {
41080 (char *) "self",(char *) "alpha", NULL
41081 };
41082
41083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
41084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41085 if (!SWIG_IsOK(res1)) {
41086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41087 }
41088 arg1 = reinterpret_cast< wxWindow * >(argp1);
41089 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
41090 if (!SWIG_IsOK(ecode2)) {
41091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
41092 }
41093 arg2 = static_cast< byte >(val2);
41094 {
41095 PyThreadState* __tstate = wxPyBeginAllowThreads();
41096 result = (bool)(arg1)->SetTransparent(arg2);
41097 wxPyEndAllowThreads(__tstate);
41098 if (PyErr_Occurred()) SWIG_fail;
41099 }
41100 {
41101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41102 }
41103 return resultobj;
41104 fail:
41105 return NULL;
41106 }
41107
41108
41109 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41110 PyObject *obj;
41111 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41112 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
41113 return SWIG_Py_Void();
41114 }
41115
41116 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41117 return SWIG_Python_InitShadowInstance(args);
41118 }
41119
41120 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41121 PyObject *resultobj = 0;
41122 long arg1 ;
41123 wxWindow *arg2 = (wxWindow *) NULL ;
41124 wxWindow *result = 0 ;
41125 long val1 ;
41126 int ecode1 = 0 ;
41127 void *argp2 = 0 ;
41128 int res2 = 0 ;
41129 PyObject * obj0 = 0 ;
41130 PyObject * obj1 = 0 ;
41131 char * kwnames[] = {
41132 (char *) "id",(char *) "parent", NULL
41133 };
41134
41135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
41136 ecode1 = SWIG_AsVal_long(obj0, &val1);
41137 if (!SWIG_IsOK(ecode1)) {
41138 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
41139 }
41140 arg1 = static_cast< long >(val1);
41141 if (obj1) {
41142 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41143 if (!SWIG_IsOK(res2)) {
41144 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
41145 }
41146 arg2 = reinterpret_cast< wxWindow * >(argp2);
41147 }
41148 {
41149 if (!wxPyCheckForApp()) SWIG_fail;
41150 PyThreadState* __tstate = wxPyBeginAllowThreads();
41151 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
41152 wxPyEndAllowThreads(__tstate);
41153 if (PyErr_Occurred()) SWIG_fail;
41154 }
41155 {
41156 resultobj = wxPyMake_wxObject(result, 0);
41157 }
41158 return resultobj;
41159 fail:
41160 return NULL;
41161 }
41162
41163
41164 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41165 PyObject *resultobj = 0;
41166 wxString *arg1 = 0 ;
41167 wxWindow *arg2 = (wxWindow *) NULL ;
41168 wxWindow *result = 0 ;
41169 bool temp1 = false ;
41170 void *argp2 = 0 ;
41171 int res2 = 0 ;
41172 PyObject * obj0 = 0 ;
41173 PyObject * obj1 = 0 ;
41174 char * kwnames[] = {
41175 (char *) "name",(char *) "parent", NULL
41176 };
41177
41178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
41179 {
41180 arg1 = wxString_in_helper(obj0);
41181 if (arg1 == NULL) SWIG_fail;
41182 temp1 = true;
41183 }
41184 if (obj1) {
41185 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41186 if (!SWIG_IsOK(res2)) {
41187 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
41188 }
41189 arg2 = reinterpret_cast< wxWindow * >(argp2);
41190 }
41191 {
41192 if (!wxPyCheckForApp()) SWIG_fail;
41193 PyThreadState* __tstate = wxPyBeginAllowThreads();
41194 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
41195 wxPyEndAllowThreads(__tstate);
41196 if (PyErr_Occurred()) SWIG_fail;
41197 }
41198 {
41199 resultobj = wxPyMake_wxObject(result, 0);
41200 }
41201 {
41202 if (temp1)
41203 delete arg1;
41204 }
41205 return resultobj;
41206 fail:
41207 {
41208 if (temp1)
41209 delete arg1;
41210 }
41211 return NULL;
41212 }
41213
41214
41215 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41216 PyObject *resultobj = 0;
41217 wxString *arg1 = 0 ;
41218 wxWindow *arg2 = (wxWindow *) NULL ;
41219 wxWindow *result = 0 ;
41220 bool temp1 = false ;
41221 void *argp2 = 0 ;
41222 int res2 = 0 ;
41223 PyObject * obj0 = 0 ;
41224 PyObject * obj1 = 0 ;
41225 char * kwnames[] = {
41226 (char *) "label",(char *) "parent", NULL
41227 };
41228
41229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41230 {
41231 arg1 = wxString_in_helper(obj0);
41232 if (arg1 == NULL) SWIG_fail;
41233 temp1 = true;
41234 }
41235 if (obj1) {
41236 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41237 if (!SWIG_IsOK(res2)) {
41238 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
41239 }
41240 arg2 = reinterpret_cast< wxWindow * >(argp2);
41241 }
41242 {
41243 if (!wxPyCheckForApp()) SWIG_fail;
41244 PyThreadState* __tstate = wxPyBeginAllowThreads();
41245 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
41246 wxPyEndAllowThreads(__tstate);
41247 if (PyErr_Occurred()) SWIG_fail;
41248 }
41249 {
41250 resultobj = wxPyMake_wxObject(result, 0);
41251 }
41252 {
41253 if (temp1)
41254 delete arg1;
41255 }
41256 return resultobj;
41257 fail:
41258 {
41259 if (temp1)
41260 delete arg1;
41261 }
41262 return NULL;
41263 }
41264
41265
41266 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41267 PyObject *resultobj = 0;
41268 wxWindow *arg1 = (wxWindow *) 0 ;
41269 unsigned long arg2 ;
41270 wxWindow *result = 0 ;
41271 void *argp1 = 0 ;
41272 int res1 = 0 ;
41273 unsigned long val2 ;
41274 int ecode2 = 0 ;
41275 PyObject * obj0 = 0 ;
41276 PyObject * obj1 = 0 ;
41277 char * kwnames[] = {
41278 (char *) "parent",(char *) "_hWnd", NULL
41279 };
41280
41281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
41282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41283 if (!SWIG_IsOK(res1)) {
41284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
41285 }
41286 arg1 = reinterpret_cast< wxWindow * >(argp1);
41287 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
41288 if (!SWIG_IsOK(ecode2)) {
41289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
41290 }
41291 arg2 = static_cast< unsigned long >(val2);
41292 {
41293 PyThreadState* __tstate = wxPyBeginAllowThreads();
41294 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
41295 wxPyEndAllowThreads(__tstate);
41296 if (PyErr_Occurred()) SWIG_fail;
41297 }
41298 {
41299 resultobj = wxPyMake_wxObject(result, 0);
41300 }
41301 return resultobj;
41302 fail:
41303 return NULL;
41304 }
41305
41306
41307 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41308 PyObject *resultobj = 0;
41309 PyObject *result = 0 ;
41310
41311 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
41312 {
41313 PyThreadState* __tstate = wxPyBeginAllowThreads();
41314 result = (PyObject *)GetTopLevelWindows();
41315 wxPyEndAllowThreads(__tstate);
41316 if (PyErr_Occurred()) SWIG_fail;
41317 }
41318 resultobj = result;
41319 return resultobj;
41320 fail:
41321 return NULL;
41322 }
41323
41324
41325 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41326 PyObject *resultobj = 0;
41327 wxValidator *result = 0 ;
41328
41329 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
41330 {
41331 PyThreadState* __tstate = wxPyBeginAllowThreads();
41332 result = (wxValidator *)new wxValidator();
41333 wxPyEndAllowThreads(__tstate);
41334 if (PyErr_Occurred()) SWIG_fail;
41335 }
41336 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
41337 return resultobj;
41338 fail:
41339 return NULL;
41340 }
41341
41342
41343 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41344 PyObject *resultobj = 0;
41345 wxValidator *arg1 = (wxValidator *) 0 ;
41346 wxValidator *result = 0 ;
41347 void *argp1 = 0 ;
41348 int res1 = 0 ;
41349 PyObject *swig_obj[1] ;
41350
41351 if (!args) SWIG_fail;
41352 swig_obj[0] = args;
41353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41354 if (!SWIG_IsOK(res1)) {
41355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
41356 }
41357 arg1 = reinterpret_cast< wxValidator * >(argp1);
41358 {
41359 PyThreadState* __tstate = wxPyBeginAllowThreads();
41360 result = (wxValidator *)(arg1)->Clone();
41361 wxPyEndAllowThreads(__tstate);
41362 if (PyErr_Occurred()) SWIG_fail;
41363 }
41364 {
41365 resultobj = wxPyMake_wxObject(result, 0);
41366 }
41367 return resultobj;
41368 fail:
41369 return NULL;
41370 }
41371
41372
41373 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41374 PyObject *resultobj = 0;
41375 wxValidator *arg1 = (wxValidator *) 0 ;
41376 wxWindow *arg2 = (wxWindow *) 0 ;
41377 bool result;
41378 void *argp1 = 0 ;
41379 int res1 = 0 ;
41380 void *argp2 = 0 ;
41381 int res2 = 0 ;
41382 PyObject * obj0 = 0 ;
41383 PyObject * obj1 = 0 ;
41384 char * kwnames[] = {
41385 (char *) "self",(char *) "parent", NULL
41386 };
41387
41388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
41389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41390 if (!SWIG_IsOK(res1)) {
41391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
41392 }
41393 arg1 = reinterpret_cast< wxValidator * >(argp1);
41394 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41395 if (!SWIG_IsOK(res2)) {
41396 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
41397 }
41398 arg2 = reinterpret_cast< wxWindow * >(argp2);
41399 {
41400 PyThreadState* __tstate = wxPyBeginAllowThreads();
41401 result = (bool)(arg1)->Validate(arg2);
41402 wxPyEndAllowThreads(__tstate);
41403 if (PyErr_Occurred()) SWIG_fail;
41404 }
41405 {
41406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41407 }
41408 return resultobj;
41409 fail:
41410 return NULL;
41411 }
41412
41413
41414 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41415 PyObject *resultobj = 0;
41416 wxValidator *arg1 = (wxValidator *) 0 ;
41417 bool result;
41418 void *argp1 = 0 ;
41419 int res1 = 0 ;
41420 PyObject *swig_obj[1] ;
41421
41422 if (!args) SWIG_fail;
41423 swig_obj[0] = args;
41424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41425 if (!SWIG_IsOK(res1)) {
41426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41427 }
41428 arg1 = reinterpret_cast< wxValidator * >(argp1);
41429 {
41430 PyThreadState* __tstate = wxPyBeginAllowThreads();
41431 result = (bool)(arg1)->TransferToWindow();
41432 wxPyEndAllowThreads(__tstate);
41433 if (PyErr_Occurred()) SWIG_fail;
41434 }
41435 {
41436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41437 }
41438 return resultobj;
41439 fail:
41440 return NULL;
41441 }
41442
41443
41444 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41445 PyObject *resultobj = 0;
41446 wxValidator *arg1 = (wxValidator *) 0 ;
41447 bool result;
41448 void *argp1 = 0 ;
41449 int res1 = 0 ;
41450 PyObject *swig_obj[1] ;
41451
41452 if (!args) SWIG_fail;
41453 swig_obj[0] = args;
41454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41455 if (!SWIG_IsOK(res1)) {
41456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41457 }
41458 arg1 = reinterpret_cast< wxValidator * >(argp1);
41459 {
41460 PyThreadState* __tstate = wxPyBeginAllowThreads();
41461 result = (bool)(arg1)->TransferFromWindow();
41462 wxPyEndAllowThreads(__tstate);
41463 if (PyErr_Occurred()) SWIG_fail;
41464 }
41465 {
41466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41467 }
41468 return resultobj;
41469 fail:
41470 return NULL;
41471 }
41472
41473
41474 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41475 PyObject *resultobj = 0;
41476 wxValidator *arg1 = (wxValidator *) 0 ;
41477 wxWindow *result = 0 ;
41478 void *argp1 = 0 ;
41479 int res1 = 0 ;
41480 PyObject *swig_obj[1] ;
41481
41482 if (!args) SWIG_fail;
41483 swig_obj[0] = args;
41484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41485 if (!SWIG_IsOK(res1)) {
41486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41487 }
41488 arg1 = reinterpret_cast< wxValidator * >(argp1);
41489 {
41490 PyThreadState* __tstate = wxPyBeginAllowThreads();
41491 result = (wxWindow *)(arg1)->GetWindow();
41492 wxPyEndAllowThreads(__tstate);
41493 if (PyErr_Occurred()) SWIG_fail;
41494 }
41495 {
41496 resultobj = wxPyMake_wxObject(result, 0);
41497 }
41498 return resultobj;
41499 fail:
41500 return NULL;
41501 }
41502
41503
41504 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41505 PyObject *resultobj = 0;
41506 wxValidator *arg1 = (wxValidator *) 0 ;
41507 wxWindow *arg2 = (wxWindow *) 0 ;
41508 void *argp1 = 0 ;
41509 int res1 = 0 ;
41510 void *argp2 = 0 ;
41511 int res2 = 0 ;
41512 PyObject * obj0 = 0 ;
41513 PyObject * obj1 = 0 ;
41514 char * kwnames[] = {
41515 (char *) "self",(char *) "window", NULL
41516 };
41517
41518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41520 if (!SWIG_IsOK(res1)) {
41521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41522 }
41523 arg1 = reinterpret_cast< wxValidator * >(argp1);
41524 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41525 if (!SWIG_IsOK(res2)) {
41526 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41527 }
41528 arg2 = reinterpret_cast< wxWindow * >(argp2);
41529 {
41530 PyThreadState* __tstate = wxPyBeginAllowThreads();
41531 (arg1)->SetWindow(arg2);
41532 wxPyEndAllowThreads(__tstate);
41533 if (PyErr_Occurred()) SWIG_fail;
41534 }
41535 resultobj = SWIG_Py_Void();
41536 return resultobj;
41537 fail:
41538 return NULL;
41539 }
41540
41541
41542 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41543 PyObject *resultobj = 0;
41544 bool result;
41545
41546 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
41547 {
41548 PyThreadState* __tstate = wxPyBeginAllowThreads();
41549 result = (bool)wxValidator::IsSilent();
41550 wxPyEndAllowThreads(__tstate);
41551 if (PyErr_Occurred()) SWIG_fail;
41552 }
41553 {
41554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41555 }
41556 return resultobj;
41557 fail:
41558 return NULL;
41559 }
41560
41561
41562 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41563 PyObject *resultobj = 0;
41564 int arg1 = (int) true ;
41565 int val1 ;
41566 int ecode1 = 0 ;
41567 PyObject * obj0 = 0 ;
41568 char * kwnames[] = {
41569 (char *) "doIt", NULL
41570 };
41571
41572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
41573 if (obj0) {
41574 ecode1 = SWIG_AsVal_int(obj0, &val1);
41575 if (!SWIG_IsOK(ecode1)) {
41576 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
41577 }
41578 arg1 = static_cast< int >(val1);
41579 }
41580 {
41581 PyThreadState* __tstate = wxPyBeginAllowThreads();
41582 wxValidator::SetBellOnError(arg1);
41583 wxPyEndAllowThreads(__tstate);
41584 if (PyErr_Occurred()) SWIG_fail;
41585 }
41586 resultobj = SWIG_Py_Void();
41587 return resultobj;
41588 fail:
41589 return NULL;
41590 }
41591
41592
41593 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41594 PyObject *obj;
41595 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41596 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
41597 return SWIG_Py_Void();
41598 }
41599
41600 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41601 return SWIG_Python_InitShadowInstance(args);
41602 }
41603
41604 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41605 PyObject *resultobj = 0;
41606 wxPyValidator *result = 0 ;
41607
41608 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
41609 {
41610 PyThreadState* __tstate = wxPyBeginAllowThreads();
41611 result = (wxPyValidator *)new wxPyValidator();
41612 wxPyEndAllowThreads(__tstate);
41613 if (PyErr_Occurred()) SWIG_fail;
41614 }
41615 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
41616 return resultobj;
41617 fail:
41618 return NULL;
41619 }
41620
41621
41622 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41623 PyObject *resultobj = 0;
41624 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
41625 PyObject *arg2 = (PyObject *) 0 ;
41626 PyObject *arg3 = (PyObject *) 0 ;
41627 int arg4 = (int) true ;
41628 void *argp1 = 0 ;
41629 int res1 = 0 ;
41630 int val4 ;
41631 int ecode4 = 0 ;
41632 PyObject * obj0 = 0 ;
41633 PyObject * obj1 = 0 ;
41634 PyObject * obj2 = 0 ;
41635 PyObject * obj3 = 0 ;
41636 char * kwnames[] = {
41637 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
41638 };
41639
41640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
41642 if (!SWIG_IsOK(res1)) {
41643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
41644 }
41645 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
41646 arg2 = obj1;
41647 arg3 = obj2;
41648 if (obj3) {
41649 ecode4 = SWIG_AsVal_int(obj3, &val4);
41650 if (!SWIG_IsOK(ecode4)) {
41651 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
41652 }
41653 arg4 = static_cast< int >(val4);
41654 }
41655 {
41656 PyThreadState* __tstate = wxPyBeginAllowThreads();
41657 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
41658 wxPyEndAllowThreads(__tstate);
41659 if (PyErr_Occurred()) SWIG_fail;
41660 }
41661 resultobj = SWIG_Py_Void();
41662 return resultobj;
41663 fail:
41664 return NULL;
41665 }
41666
41667
41668 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41669 PyObject *obj;
41670 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41671 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
41672 return SWIG_Py_Void();
41673 }
41674
41675 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41676 return SWIG_Python_InitShadowInstance(args);
41677 }
41678
41679 SWIGINTERN int DefaultValidator_set(PyObject *) {
41680 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
41681 return 1;
41682 }
41683
41684
41685 SWIGINTERN PyObject *DefaultValidator_get(void) {
41686 PyObject *pyobj = 0;
41687
41688 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
41689 return pyobj;
41690 }
41691
41692
41693 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41694 PyObject *resultobj = 0;
41695 wxString const &arg1_defvalue = wxPyEmptyString ;
41696 wxString *arg1 = (wxString *) &arg1_defvalue ;
41697 long arg2 = (long) 0 ;
41698 wxMenu *result = 0 ;
41699 bool temp1 = false ;
41700 long val2 ;
41701 int ecode2 = 0 ;
41702 PyObject * obj0 = 0 ;
41703 PyObject * obj1 = 0 ;
41704 char * kwnames[] = {
41705 (char *) "title",(char *) "style", NULL
41706 };
41707
41708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
41709 if (obj0) {
41710 {
41711 arg1 = wxString_in_helper(obj0);
41712 if (arg1 == NULL) SWIG_fail;
41713 temp1 = true;
41714 }
41715 }
41716 if (obj1) {
41717 ecode2 = SWIG_AsVal_long(obj1, &val2);
41718 if (!SWIG_IsOK(ecode2)) {
41719 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
41720 }
41721 arg2 = static_cast< long >(val2);
41722 }
41723 {
41724 if (!wxPyCheckForApp()) SWIG_fail;
41725 PyThreadState* __tstate = wxPyBeginAllowThreads();
41726 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
41727 wxPyEndAllowThreads(__tstate);
41728 if (PyErr_Occurred()) SWIG_fail;
41729 }
41730 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
41731 {
41732 if (temp1)
41733 delete arg1;
41734 }
41735 return resultobj;
41736 fail:
41737 {
41738 if (temp1)
41739 delete arg1;
41740 }
41741 return NULL;
41742 }
41743
41744
41745 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41746 PyObject *resultobj = 0;
41747 wxMenu *arg1 = (wxMenu *) 0 ;
41748 int arg2 ;
41749 wxString const &arg3_defvalue = wxPyEmptyString ;
41750 wxString *arg3 = (wxString *) &arg3_defvalue ;
41751 wxString const &arg4_defvalue = wxPyEmptyString ;
41752 wxString *arg4 = (wxString *) &arg4_defvalue ;
41753 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
41754 wxMenuItem *result = 0 ;
41755 void *argp1 = 0 ;
41756 int res1 = 0 ;
41757 int val2 ;
41758 int ecode2 = 0 ;
41759 bool temp3 = false ;
41760 bool temp4 = false ;
41761 int val5 ;
41762 int ecode5 = 0 ;
41763 PyObject * obj0 = 0 ;
41764 PyObject * obj1 = 0 ;
41765 PyObject * obj2 = 0 ;
41766 PyObject * obj3 = 0 ;
41767 PyObject * obj4 = 0 ;
41768 char * kwnames[] = {
41769 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
41770 };
41771
41772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
41773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41774 if (!SWIG_IsOK(res1)) {
41775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
41776 }
41777 arg1 = reinterpret_cast< wxMenu * >(argp1);
41778 ecode2 = SWIG_AsVal_int(obj1, &val2);
41779 if (!SWIG_IsOK(ecode2)) {
41780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
41781 }
41782 arg2 = static_cast< int >(val2);
41783 if (obj2) {
41784 {
41785 arg3 = wxString_in_helper(obj2);
41786 if (arg3 == NULL) SWIG_fail;
41787 temp3 = true;
41788 }
41789 }
41790 if (obj3) {
41791 {
41792 arg4 = wxString_in_helper(obj3);
41793 if (arg4 == NULL) SWIG_fail;
41794 temp4 = true;
41795 }
41796 }
41797 if (obj4) {
41798 ecode5 = SWIG_AsVal_int(obj4, &val5);
41799 if (!SWIG_IsOK(ecode5)) {
41800 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
41801 }
41802 arg5 = static_cast< wxItemKind >(val5);
41803 }
41804 {
41805 PyThreadState* __tstate = wxPyBeginAllowThreads();
41806 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
41807 wxPyEndAllowThreads(__tstate);
41808 if (PyErr_Occurred()) SWIG_fail;
41809 }
41810 {
41811 resultobj = wxPyMake_wxObject(result, (bool)0);
41812 }
41813 {
41814 if (temp3)
41815 delete arg3;
41816 }
41817 {
41818 if (temp4)
41819 delete arg4;
41820 }
41821 return resultobj;
41822 fail:
41823 {
41824 if (temp3)
41825 delete arg3;
41826 }
41827 {
41828 if (temp4)
41829 delete arg4;
41830 }
41831 return NULL;
41832 }
41833
41834
41835 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41836 PyObject *resultobj = 0;
41837 wxMenu *arg1 = (wxMenu *) 0 ;
41838 wxMenuItem *result = 0 ;
41839 void *argp1 = 0 ;
41840 int res1 = 0 ;
41841 PyObject *swig_obj[1] ;
41842
41843 if (!args) SWIG_fail;
41844 swig_obj[0] = args;
41845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41846 if (!SWIG_IsOK(res1)) {
41847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
41848 }
41849 arg1 = reinterpret_cast< wxMenu * >(argp1);
41850 {
41851 PyThreadState* __tstate = wxPyBeginAllowThreads();
41852 result = (wxMenuItem *)(arg1)->AppendSeparator();
41853 wxPyEndAllowThreads(__tstate);
41854 if (PyErr_Occurred()) SWIG_fail;
41855 }
41856 {
41857 resultobj = wxPyMake_wxObject(result, (bool)0);
41858 }
41859 return resultobj;
41860 fail:
41861 return NULL;
41862 }
41863
41864
41865 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41866 PyObject *resultobj = 0;
41867 wxMenu *arg1 = (wxMenu *) 0 ;
41868 int arg2 ;
41869 wxString *arg3 = 0 ;
41870 wxString const &arg4_defvalue = wxPyEmptyString ;
41871 wxString *arg4 = (wxString *) &arg4_defvalue ;
41872 wxMenuItem *result = 0 ;
41873 void *argp1 = 0 ;
41874 int res1 = 0 ;
41875 int val2 ;
41876 int ecode2 = 0 ;
41877 bool temp3 = false ;
41878 bool temp4 = false ;
41879 PyObject * obj0 = 0 ;
41880 PyObject * obj1 = 0 ;
41881 PyObject * obj2 = 0 ;
41882 PyObject * obj3 = 0 ;
41883 char * kwnames[] = {
41884 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
41885 };
41886
41887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41889 if (!SWIG_IsOK(res1)) {
41890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41891 }
41892 arg1 = reinterpret_cast< wxMenu * >(argp1);
41893 ecode2 = SWIG_AsVal_int(obj1, &val2);
41894 if (!SWIG_IsOK(ecode2)) {
41895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
41896 }
41897 arg2 = static_cast< int >(val2);
41898 {
41899 arg3 = wxString_in_helper(obj2);
41900 if (arg3 == NULL) SWIG_fail;
41901 temp3 = true;
41902 }
41903 if (obj3) {
41904 {
41905 arg4 = wxString_in_helper(obj3);
41906 if (arg4 == NULL) SWIG_fail;
41907 temp4 = true;
41908 }
41909 }
41910 {
41911 PyThreadState* __tstate = wxPyBeginAllowThreads();
41912 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
41913 wxPyEndAllowThreads(__tstate);
41914 if (PyErr_Occurred()) SWIG_fail;
41915 }
41916 {
41917 resultobj = wxPyMake_wxObject(result, (bool)0);
41918 }
41919 {
41920 if (temp3)
41921 delete arg3;
41922 }
41923 {
41924 if (temp4)
41925 delete arg4;
41926 }
41927 return resultobj;
41928 fail:
41929 {
41930 if (temp3)
41931 delete arg3;
41932 }
41933 {
41934 if (temp4)
41935 delete arg4;
41936 }
41937 return NULL;
41938 }
41939
41940
41941 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41942 PyObject *resultobj = 0;
41943 wxMenu *arg1 = (wxMenu *) 0 ;
41944 int arg2 ;
41945 wxString *arg3 = 0 ;
41946 wxString const &arg4_defvalue = wxPyEmptyString ;
41947 wxString *arg4 = (wxString *) &arg4_defvalue ;
41948 wxMenuItem *result = 0 ;
41949 void *argp1 = 0 ;
41950 int res1 = 0 ;
41951 int val2 ;
41952 int ecode2 = 0 ;
41953 bool temp3 = false ;
41954 bool temp4 = false ;
41955 PyObject * obj0 = 0 ;
41956 PyObject * obj1 = 0 ;
41957 PyObject * obj2 = 0 ;
41958 PyObject * obj3 = 0 ;
41959 char * kwnames[] = {
41960 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
41961 };
41962
41963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41965 if (!SWIG_IsOK(res1)) {
41966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41967 }
41968 arg1 = reinterpret_cast< wxMenu * >(argp1);
41969 ecode2 = SWIG_AsVal_int(obj1, &val2);
41970 if (!SWIG_IsOK(ecode2)) {
41971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
41972 }
41973 arg2 = static_cast< int >(val2);
41974 {
41975 arg3 = wxString_in_helper(obj2);
41976 if (arg3 == NULL) SWIG_fail;
41977 temp3 = true;
41978 }
41979 if (obj3) {
41980 {
41981 arg4 = wxString_in_helper(obj3);
41982 if (arg4 == NULL) SWIG_fail;
41983 temp4 = true;
41984 }
41985 }
41986 {
41987 PyThreadState* __tstate = wxPyBeginAllowThreads();
41988 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
41989 wxPyEndAllowThreads(__tstate);
41990 if (PyErr_Occurred()) SWIG_fail;
41991 }
41992 {
41993 resultobj = wxPyMake_wxObject(result, (bool)0);
41994 }
41995 {
41996 if (temp3)
41997 delete arg3;
41998 }
41999 {
42000 if (temp4)
42001 delete arg4;
42002 }
42003 return resultobj;
42004 fail:
42005 {
42006 if (temp3)
42007 delete arg3;
42008 }
42009 {
42010 if (temp4)
42011 delete arg4;
42012 }
42013 return NULL;
42014 }
42015
42016
42017 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42018 PyObject *resultobj = 0;
42019 wxMenu *arg1 = (wxMenu *) 0 ;
42020 int arg2 ;
42021 wxString *arg3 = 0 ;
42022 wxMenu *arg4 = (wxMenu *) 0 ;
42023 wxString const &arg5_defvalue = wxPyEmptyString ;
42024 wxString *arg5 = (wxString *) &arg5_defvalue ;
42025 wxMenuItem *result = 0 ;
42026 void *argp1 = 0 ;
42027 int res1 = 0 ;
42028 int val2 ;
42029 int ecode2 = 0 ;
42030 bool temp3 = false ;
42031 void *argp4 = 0 ;
42032 int res4 = 0 ;
42033 bool temp5 = false ;
42034 PyObject * obj0 = 0 ;
42035 PyObject * obj1 = 0 ;
42036 PyObject * obj2 = 0 ;
42037 PyObject * obj3 = 0 ;
42038 PyObject * obj4 = 0 ;
42039 char * kwnames[] = {
42040 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42041 };
42042
42043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42045 if (!SWIG_IsOK(res1)) {
42046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42047 }
42048 arg1 = reinterpret_cast< wxMenu * >(argp1);
42049 ecode2 = SWIG_AsVal_int(obj1, &val2);
42050 if (!SWIG_IsOK(ecode2)) {
42051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
42052 }
42053 arg2 = static_cast< int >(val2);
42054 {
42055 arg3 = wxString_in_helper(obj2);
42056 if (arg3 == NULL) SWIG_fail;
42057 temp3 = true;
42058 }
42059 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
42060 if (!SWIG_IsOK(res4)) {
42061 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
42062 }
42063 arg4 = reinterpret_cast< wxMenu * >(argp4);
42064 if (obj4) {
42065 {
42066 arg5 = wxString_in_helper(obj4);
42067 if (arg5 == NULL) SWIG_fail;
42068 temp5 = true;
42069 }
42070 }
42071 {
42072 PyThreadState* __tstate = wxPyBeginAllowThreads();
42073 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
42074 wxPyEndAllowThreads(__tstate);
42075 if (PyErr_Occurred()) SWIG_fail;
42076 }
42077 {
42078 resultobj = wxPyMake_wxObject(result, (bool)0);
42079 }
42080 {
42081 if (temp3)
42082 delete arg3;
42083 }
42084 {
42085 if (temp5)
42086 delete arg5;
42087 }
42088 return resultobj;
42089 fail:
42090 {
42091 if (temp3)
42092 delete arg3;
42093 }
42094 {
42095 if (temp5)
42096 delete arg5;
42097 }
42098 return NULL;
42099 }
42100
42101
42102 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42103 PyObject *resultobj = 0;
42104 wxMenu *arg1 = (wxMenu *) 0 ;
42105 wxMenu *arg2 = (wxMenu *) 0 ;
42106 wxString *arg3 = 0 ;
42107 wxString const &arg4_defvalue = wxPyEmptyString ;
42108 wxString *arg4 = (wxString *) &arg4_defvalue ;
42109 wxMenuItem *result = 0 ;
42110 void *argp1 = 0 ;
42111 int res1 = 0 ;
42112 void *argp2 = 0 ;
42113 int res2 = 0 ;
42114 bool temp3 = false ;
42115 bool temp4 = false ;
42116 PyObject * obj0 = 0 ;
42117 PyObject * obj1 = 0 ;
42118 PyObject * obj2 = 0 ;
42119 PyObject * obj3 = 0 ;
42120 char * kwnames[] = {
42121 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
42122 };
42123
42124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42126 if (!SWIG_IsOK(res1)) {
42127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42128 }
42129 arg1 = reinterpret_cast< wxMenu * >(argp1);
42130 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42131 if (!SWIG_IsOK(res2)) {
42132 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42133 }
42134 arg2 = reinterpret_cast< wxMenu * >(argp2);
42135 {
42136 arg3 = wxString_in_helper(obj2);
42137 if (arg3 == NULL) SWIG_fail;
42138 temp3 = true;
42139 }
42140 if (obj3) {
42141 {
42142 arg4 = wxString_in_helper(obj3);
42143 if (arg4 == NULL) SWIG_fail;
42144 temp4 = true;
42145 }
42146 }
42147 {
42148 PyThreadState* __tstate = wxPyBeginAllowThreads();
42149 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42150 wxPyEndAllowThreads(__tstate);
42151 if (PyErr_Occurred()) SWIG_fail;
42152 }
42153 {
42154 resultobj = wxPyMake_wxObject(result, (bool)0);
42155 }
42156 {
42157 if (temp3)
42158 delete arg3;
42159 }
42160 {
42161 if (temp4)
42162 delete arg4;
42163 }
42164 return resultobj;
42165 fail:
42166 {
42167 if (temp3)
42168 delete arg3;
42169 }
42170 {
42171 if (temp4)
42172 delete arg4;
42173 }
42174 return NULL;
42175 }
42176
42177
42178 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42179 PyObject *resultobj = 0;
42180 wxMenu *arg1 = (wxMenu *) 0 ;
42181 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42182 wxMenuItem *result = 0 ;
42183 void *argp1 = 0 ;
42184 int res1 = 0 ;
42185 int res2 = 0 ;
42186 PyObject * obj0 = 0 ;
42187 PyObject * obj1 = 0 ;
42188 char * kwnames[] = {
42189 (char *) "self",(char *) "item", NULL
42190 };
42191
42192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
42193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42194 if (!SWIG_IsOK(res1)) {
42195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42196 }
42197 arg1 = reinterpret_cast< wxMenu * >(argp1);
42198 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42199 if (!SWIG_IsOK(res2)) {
42200 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42201 }
42202 {
42203 PyThreadState* __tstate = wxPyBeginAllowThreads();
42204 result = (wxMenuItem *)(arg1)->Append(arg2);
42205 wxPyEndAllowThreads(__tstate);
42206 if (PyErr_Occurred()) SWIG_fail;
42207 }
42208 {
42209 resultobj = wxPyMake_wxObject(result, (bool)0);
42210 }
42211 return resultobj;
42212 fail:
42213 return NULL;
42214 }
42215
42216
42217 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42218 PyObject *resultobj = 0;
42219 wxMenu *arg1 = (wxMenu *) 0 ;
42220 size_t arg2 ;
42221 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
42222 wxMenuItem *result = 0 ;
42223 void *argp1 = 0 ;
42224 int res1 = 0 ;
42225 size_t val2 ;
42226 int ecode2 = 0 ;
42227 int res3 = 0 ;
42228 PyObject * obj0 = 0 ;
42229 PyObject * obj1 = 0 ;
42230 PyObject * obj2 = 0 ;
42231 char * kwnames[] = {
42232 (char *) "self",(char *) "pos",(char *) "item", NULL
42233 };
42234
42235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42237 if (!SWIG_IsOK(res1)) {
42238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42239 }
42240 arg1 = reinterpret_cast< wxMenu * >(argp1);
42241 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42242 if (!SWIG_IsOK(ecode2)) {
42243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
42244 }
42245 arg2 = static_cast< size_t >(val2);
42246 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42247 if (!SWIG_IsOK(res3)) {
42248 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
42249 }
42250 {
42251 PyThreadState* __tstate = wxPyBeginAllowThreads();
42252 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
42253 wxPyEndAllowThreads(__tstate);
42254 if (PyErr_Occurred()) SWIG_fail;
42255 }
42256 {
42257 resultobj = wxPyMake_wxObject(result, (bool)0);
42258 }
42259 return resultobj;
42260 fail:
42261 return NULL;
42262 }
42263
42264
42265 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42266 PyObject *resultobj = 0;
42267 wxMenu *arg1 = (wxMenu *) 0 ;
42268 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42269 wxMenuItem *result = 0 ;
42270 void *argp1 = 0 ;
42271 int res1 = 0 ;
42272 int res2 = 0 ;
42273 PyObject * obj0 = 0 ;
42274 PyObject * obj1 = 0 ;
42275 char * kwnames[] = {
42276 (char *) "self",(char *) "item", NULL
42277 };
42278
42279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
42280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42281 if (!SWIG_IsOK(res1)) {
42282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42283 }
42284 arg1 = reinterpret_cast< wxMenu * >(argp1);
42285 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42286 if (!SWIG_IsOK(res2)) {
42287 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42288 }
42289 {
42290 PyThreadState* __tstate = wxPyBeginAllowThreads();
42291 result = (wxMenuItem *)(arg1)->Prepend(arg2);
42292 wxPyEndAllowThreads(__tstate);
42293 if (PyErr_Occurred()) SWIG_fail;
42294 }
42295 {
42296 resultobj = wxPyMake_wxObject(result, (bool)0);
42297 }
42298 return resultobj;
42299 fail:
42300 return NULL;
42301 }
42302
42303
42304 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42305 PyObject *resultobj = 0;
42306 wxMenu *arg1 = (wxMenu *) 0 ;
42307 void *argp1 = 0 ;
42308 int res1 = 0 ;
42309 PyObject *swig_obj[1] ;
42310
42311 if (!args) SWIG_fail;
42312 swig_obj[0] = args;
42313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42314 if (!SWIG_IsOK(res1)) {
42315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
42316 }
42317 arg1 = reinterpret_cast< wxMenu * >(argp1);
42318 {
42319 PyThreadState* __tstate = wxPyBeginAllowThreads();
42320 (arg1)->Break();
42321 wxPyEndAllowThreads(__tstate);
42322 if (PyErr_Occurred()) SWIG_fail;
42323 }
42324 resultobj = SWIG_Py_Void();
42325 return resultobj;
42326 fail:
42327 return NULL;
42328 }
42329
42330
42331 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42332 PyObject *resultobj = 0;
42333 wxMenu *arg1 = (wxMenu *) 0 ;
42334 size_t arg2 ;
42335 int arg3 ;
42336 wxString const &arg4_defvalue = wxPyEmptyString ;
42337 wxString *arg4 = (wxString *) &arg4_defvalue ;
42338 wxString const &arg5_defvalue = wxPyEmptyString ;
42339 wxString *arg5 = (wxString *) &arg5_defvalue ;
42340 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
42341 wxMenuItem *result = 0 ;
42342 void *argp1 = 0 ;
42343 int res1 = 0 ;
42344 size_t val2 ;
42345 int ecode2 = 0 ;
42346 int val3 ;
42347 int ecode3 = 0 ;
42348 bool temp4 = false ;
42349 bool temp5 = false ;
42350 int val6 ;
42351 int ecode6 = 0 ;
42352 PyObject * obj0 = 0 ;
42353 PyObject * obj1 = 0 ;
42354 PyObject * obj2 = 0 ;
42355 PyObject * obj3 = 0 ;
42356 PyObject * obj4 = 0 ;
42357 PyObject * obj5 = 0 ;
42358 char * kwnames[] = {
42359 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42360 };
42361
42362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42364 if (!SWIG_IsOK(res1)) {
42365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
42366 }
42367 arg1 = reinterpret_cast< wxMenu * >(argp1);
42368 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42369 if (!SWIG_IsOK(ecode2)) {
42370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
42371 }
42372 arg2 = static_cast< size_t >(val2);
42373 ecode3 = SWIG_AsVal_int(obj2, &val3);
42374 if (!SWIG_IsOK(ecode3)) {
42375 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
42376 }
42377 arg3 = static_cast< int >(val3);
42378 if (obj3) {
42379 {
42380 arg4 = wxString_in_helper(obj3);
42381 if (arg4 == NULL) SWIG_fail;
42382 temp4 = true;
42383 }
42384 }
42385 if (obj4) {
42386 {
42387 arg5 = wxString_in_helper(obj4);
42388 if (arg5 == NULL) SWIG_fail;
42389 temp5 = true;
42390 }
42391 }
42392 if (obj5) {
42393 ecode6 = SWIG_AsVal_int(obj5, &val6);
42394 if (!SWIG_IsOK(ecode6)) {
42395 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
42396 }
42397 arg6 = static_cast< wxItemKind >(val6);
42398 }
42399 {
42400 PyThreadState* __tstate = wxPyBeginAllowThreads();
42401 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
42402 wxPyEndAllowThreads(__tstate);
42403 if (PyErr_Occurred()) SWIG_fail;
42404 }
42405 {
42406 resultobj = wxPyMake_wxObject(result, (bool)0);
42407 }
42408 {
42409 if (temp4)
42410 delete arg4;
42411 }
42412 {
42413 if (temp5)
42414 delete arg5;
42415 }
42416 return resultobj;
42417 fail:
42418 {
42419 if (temp4)
42420 delete arg4;
42421 }
42422 {
42423 if (temp5)
42424 delete arg5;
42425 }
42426 return NULL;
42427 }
42428
42429
42430 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42431 PyObject *resultobj = 0;
42432 wxMenu *arg1 = (wxMenu *) 0 ;
42433 size_t arg2 ;
42434 wxMenuItem *result = 0 ;
42435 void *argp1 = 0 ;
42436 int res1 = 0 ;
42437 size_t val2 ;
42438 int ecode2 = 0 ;
42439 PyObject * obj0 = 0 ;
42440 PyObject * obj1 = 0 ;
42441 char * kwnames[] = {
42442 (char *) "self",(char *) "pos", NULL
42443 };
42444
42445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
42446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42447 if (!SWIG_IsOK(res1)) {
42448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42449 }
42450 arg1 = reinterpret_cast< wxMenu * >(argp1);
42451 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42452 if (!SWIG_IsOK(ecode2)) {
42453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
42454 }
42455 arg2 = static_cast< size_t >(val2);
42456 {
42457 PyThreadState* __tstate = wxPyBeginAllowThreads();
42458 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
42459 wxPyEndAllowThreads(__tstate);
42460 if (PyErr_Occurred()) SWIG_fail;
42461 }
42462 {
42463 resultobj = wxPyMake_wxObject(result, (bool)0);
42464 }
42465 return resultobj;
42466 fail:
42467 return NULL;
42468 }
42469
42470
42471 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42472 PyObject *resultobj = 0;
42473 wxMenu *arg1 = (wxMenu *) 0 ;
42474 size_t arg2 ;
42475 int arg3 ;
42476 wxString *arg4 = 0 ;
42477 wxString const &arg5_defvalue = wxPyEmptyString ;
42478 wxString *arg5 = (wxString *) &arg5_defvalue ;
42479 wxMenuItem *result = 0 ;
42480 void *argp1 = 0 ;
42481 int res1 = 0 ;
42482 size_t val2 ;
42483 int ecode2 = 0 ;
42484 int val3 ;
42485 int ecode3 = 0 ;
42486 bool temp4 = false ;
42487 bool temp5 = false ;
42488 PyObject * obj0 = 0 ;
42489 PyObject * obj1 = 0 ;
42490 PyObject * obj2 = 0 ;
42491 PyObject * obj3 = 0 ;
42492 PyObject * obj4 = 0 ;
42493 char * kwnames[] = {
42494 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42495 };
42496
42497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42499 if (!SWIG_IsOK(res1)) {
42500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42501 }
42502 arg1 = reinterpret_cast< wxMenu * >(argp1);
42503 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42504 if (!SWIG_IsOK(ecode2)) {
42505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
42506 }
42507 arg2 = static_cast< size_t >(val2);
42508 ecode3 = SWIG_AsVal_int(obj2, &val3);
42509 if (!SWIG_IsOK(ecode3)) {
42510 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
42511 }
42512 arg3 = static_cast< int >(val3);
42513 {
42514 arg4 = wxString_in_helper(obj3);
42515 if (arg4 == NULL) SWIG_fail;
42516 temp4 = true;
42517 }
42518 if (obj4) {
42519 {
42520 arg5 = wxString_in_helper(obj4);
42521 if (arg5 == NULL) SWIG_fail;
42522 temp5 = true;
42523 }
42524 }
42525 {
42526 PyThreadState* __tstate = wxPyBeginAllowThreads();
42527 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42528 wxPyEndAllowThreads(__tstate);
42529 if (PyErr_Occurred()) SWIG_fail;
42530 }
42531 {
42532 resultobj = wxPyMake_wxObject(result, (bool)0);
42533 }
42534 {
42535 if (temp4)
42536 delete arg4;
42537 }
42538 {
42539 if (temp5)
42540 delete arg5;
42541 }
42542 return resultobj;
42543 fail:
42544 {
42545 if (temp4)
42546 delete arg4;
42547 }
42548 {
42549 if (temp5)
42550 delete arg5;
42551 }
42552 return NULL;
42553 }
42554
42555
42556 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42557 PyObject *resultobj = 0;
42558 wxMenu *arg1 = (wxMenu *) 0 ;
42559 size_t arg2 ;
42560 int arg3 ;
42561 wxString *arg4 = 0 ;
42562 wxString const &arg5_defvalue = wxPyEmptyString ;
42563 wxString *arg5 = (wxString *) &arg5_defvalue ;
42564 wxMenuItem *result = 0 ;
42565 void *argp1 = 0 ;
42566 int res1 = 0 ;
42567 size_t val2 ;
42568 int ecode2 = 0 ;
42569 int val3 ;
42570 int ecode3 = 0 ;
42571 bool temp4 = false ;
42572 bool temp5 = false ;
42573 PyObject * obj0 = 0 ;
42574 PyObject * obj1 = 0 ;
42575 PyObject * obj2 = 0 ;
42576 PyObject * obj3 = 0 ;
42577 PyObject * obj4 = 0 ;
42578 char * kwnames[] = {
42579 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42580 };
42581
42582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42584 if (!SWIG_IsOK(res1)) {
42585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42586 }
42587 arg1 = reinterpret_cast< wxMenu * >(argp1);
42588 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42589 if (!SWIG_IsOK(ecode2)) {
42590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
42591 }
42592 arg2 = static_cast< size_t >(val2);
42593 ecode3 = SWIG_AsVal_int(obj2, &val3);
42594 if (!SWIG_IsOK(ecode3)) {
42595 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
42596 }
42597 arg3 = static_cast< int >(val3);
42598 {
42599 arg4 = wxString_in_helper(obj3);
42600 if (arg4 == NULL) SWIG_fail;
42601 temp4 = true;
42602 }
42603 if (obj4) {
42604 {
42605 arg5 = wxString_in_helper(obj4);
42606 if (arg5 == NULL) SWIG_fail;
42607 temp5 = true;
42608 }
42609 }
42610 {
42611 PyThreadState* __tstate = wxPyBeginAllowThreads();
42612 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42613 wxPyEndAllowThreads(__tstate);
42614 if (PyErr_Occurred()) SWIG_fail;
42615 }
42616 {
42617 resultobj = wxPyMake_wxObject(result, (bool)0);
42618 }
42619 {
42620 if (temp4)
42621 delete arg4;
42622 }
42623 {
42624 if (temp5)
42625 delete arg5;
42626 }
42627 return resultobj;
42628 fail:
42629 {
42630 if (temp4)
42631 delete arg4;
42632 }
42633 {
42634 if (temp5)
42635 delete arg5;
42636 }
42637 return NULL;
42638 }
42639
42640
42641 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42642 PyObject *resultobj = 0;
42643 wxMenu *arg1 = (wxMenu *) 0 ;
42644 size_t arg2 ;
42645 int arg3 ;
42646 wxString *arg4 = 0 ;
42647 wxMenu *arg5 = (wxMenu *) 0 ;
42648 wxString const &arg6_defvalue = wxPyEmptyString ;
42649 wxString *arg6 = (wxString *) &arg6_defvalue ;
42650 wxMenuItem *result = 0 ;
42651 void *argp1 = 0 ;
42652 int res1 = 0 ;
42653 size_t val2 ;
42654 int ecode2 = 0 ;
42655 int val3 ;
42656 int ecode3 = 0 ;
42657 bool temp4 = false ;
42658 void *argp5 = 0 ;
42659 int res5 = 0 ;
42660 bool temp6 = false ;
42661 PyObject * obj0 = 0 ;
42662 PyObject * obj1 = 0 ;
42663 PyObject * obj2 = 0 ;
42664 PyObject * obj3 = 0 ;
42665 PyObject * obj4 = 0 ;
42666 PyObject * obj5 = 0 ;
42667 char * kwnames[] = {
42668 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42669 };
42670
42671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42673 if (!SWIG_IsOK(res1)) {
42674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42675 }
42676 arg1 = reinterpret_cast< wxMenu * >(argp1);
42677 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42678 if (!SWIG_IsOK(ecode2)) {
42679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
42680 }
42681 arg2 = static_cast< size_t >(val2);
42682 ecode3 = SWIG_AsVal_int(obj2, &val3);
42683 if (!SWIG_IsOK(ecode3)) {
42684 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
42685 }
42686 arg3 = static_cast< int >(val3);
42687 {
42688 arg4 = wxString_in_helper(obj3);
42689 if (arg4 == NULL) SWIG_fail;
42690 temp4 = true;
42691 }
42692 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
42693 if (!SWIG_IsOK(res5)) {
42694 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
42695 }
42696 arg5 = reinterpret_cast< wxMenu * >(argp5);
42697 if (obj5) {
42698 {
42699 arg6 = wxString_in_helper(obj5);
42700 if (arg6 == NULL) SWIG_fail;
42701 temp6 = true;
42702 }
42703 }
42704 {
42705 PyThreadState* __tstate = wxPyBeginAllowThreads();
42706 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
42707 wxPyEndAllowThreads(__tstate);
42708 if (PyErr_Occurred()) SWIG_fail;
42709 }
42710 {
42711 resultobj = wxPyMake_wxObject(result, (bool)0);
42712 }
42713 {
42714 if (temp4)
42715 delete arg4;
42716 }
42717 {
42718 if (temp6)
42719 delete arg6;
42720 }
42721 return resultobj;
42722 fail:
42723 {
42724 if (temp4)
42725 delete arg4;
42726 }
42727 {
42728 if (temp6)
42729 delete arg6;
42730 }
42731 return NULL;
42732 }
42733
42734
42735 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42736 PyObject *resultobj = 0;
42737 wxMenu *arg1 = (wxMenu *) 0 ;
42738 int arg2 ;
42739 wxString const &arg3_defvalue = wxPyEmptyString ;
42740 wxString *arg3 = (wxString *) &arg3_defvalue ;
42741 wxString const &arg4_defvalue = wxPyEmptyString ;
42742 wxString *arg4 = (wxString *) &arg4_defvalue ;
42743 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42744 wxMenuItem *result = 0 ;
42745 void *argp1 = 0 ;
42746 int res1 = 0 ;
42747 int val2 ;
42748 int ecode2 = 0 ;
42749 bool temp3 = false ;
42750 bool temp4 = false ;
42751 int val5 ;
42752 int ecode5 = 0 ;
42753 PyObject * obj0 = 0 ;
42754 PyObject * obj1 = 0 ;
42755 PyObject * obj2 = 0 ;
42756 PyObject * obj3 = 0 ;
42757 PyObject * obj4 = 0 ;
42758 char * kwnames[] = {
42759 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42760 };
42761
42762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42764 if (!SWIG_IsOK(res1)) {
42765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
42766 }
42767 arg1 = reinterpret_cast< wxMenu * >(argp1);
42768 ecode2 = SWIG_AsVal_int(obj1, &val2);
42769 if (!SWIG_IsOK(ecode2)) {
42770 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
42771 }
42772 arg2 = static_cast< int >(val2);
42773 if (obj2) {
42774 {
42775 arg3 = wxString_in_helper(obj2);
42776 if (arg3 == NULL) SWIG_fail;
42777 temp3 = true;
42778 }
42779 }
42780 if (obj3) {
42781 {
42782 arg4 = wxString_in_helper(obj3);
42783 if (arg4 == NULL) SWIG_fail;
42784 temp4 = true;
42785 }
42786 }
42787 if (obj4) {
42788 ecode5 = SWIG_AsVal_int(obj4, &val5);
42789 if (!SWIG_IsOK(ecode5)) {
42790 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
42791 }
42792 arg5 = static_cast< wxItemKind >(val5);
42793 }
42794 {
42795 PyThreadState* __tstate = wxPyBeginAllowThreads();
42796 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
42797 wxPyEndAllowThreads(__tstate);
42798 if (PyErr_Occurred()) SWIG_fail;
42799 }
42800 {
42801 resultobj = wxPyMake_wxObject(result, (bool)0);
42802 }
42803 {
42804 if (temp3)
42805 delete arg3;
42806 }
42807 {
42808 if (temp4)
42809 delete arg4;
42810 }
42811 return resultobj;
42812 fail:
42813 {
42814 if (temp3)
42815 delete arg3;
42816 }
42817 {
42818 if (temp4)
42819 delete arg4;
42820 }
42821 return NULL;
42822 }
42823
42824
42825 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42826 PyObject *resultobj = 0;
42827 wxMenu *arg1 = (wxMenu *) 0 ;
42828 wxMenuItem *result = 0 ;
42829 void *argp1 = 0 ;
42830 int res1 = 0 ;
42831 PyObject *swig_obj[1] ;
42832
42833 if (!args) SWIG_fail;
42834 swig_obj[0] = args;
42835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42836 if (!SWIG_IsOK(res1)) {
42837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42838 }
42839 arg1 = reinterpret_cast< wxMenu * >(argp1);
42840 {
42841 PyThreadState* __tstate = wxPyBeginAllowThreads();
42842 result = (wxMenuItem *)(arg1)->PrependSeparator();
42843 wxPyEndAllowThreads(__tstate);
42844 if (PyErr_Occurred()) SWIG_fail;
42845 }
42846 {
42847 resultobj = wxPyMake_wxObject(result, (bool)0);
42848 }
42849 return resultobj;
42850 fail:
42851 return NULL;
42852 }
42853
42854
42855 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42856 PyObject *resultobj = 0;
42857 wxMenu *arg1 = (wxMenu *) 0 ;
42858 int arg2 ;
42859 wxString *arg3 = 0 ;
42860 wxString const &arg4_defvalue = wxPyEmptyString ;
42861 wxString *arg4 = (wxString *) &arg4_defvalue ;
42862 wxMenuItem *result = 0 ;
42863 void *argp1 = 0 ;
42864 int res1 = 0 ;
42865 int val2 ;
42866 int ecode2 = 0 ;
42867 bool temp3 = false ;
42868 bool temp4 = false ;
42869 PyObject * obj0 = 0 ;
42870 PyObject * obj1 = 0 ;
42871 PyObject * obj2 = 0 ;
42872 PyObject * obj3 = 0 ;
42873 char * kwnames[] = {
42874 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42875 };
42876
42877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42879 if (!SWIG_IsOK(res1)) {
42880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42881 }
42882 arg1 = reinterpret_cast< wxMenu * >(argp1);
42883 ecode2 = SWIG_AsVal_int(obj1, &val2);
42884 if (!SWIG_IsOK(ecode2)) {
42885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
42886 }
42887 arg2 = static_cast< int >(val2);
42888 {
42889 arg3 = wxString_in_helper(obj2);
42890 if (arg3 == NULL) SWIG_fail;
42891 temp3 = true;
42892 }
42893 if (obj3) {
42894 {
42895 arg4 = wxString_in_helper(obj3);
42896 if (arg4 == NULL) SWIG_fail;
42897 temp4 = true;
42898 }
42899 }
42900 {
42901 PyThreadState* __tstate = wxPyBeginAllowThreads();
42902 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42903 wxPyEndAllowThreads(__tstate);
42904 if (PyErr_Occurred()) SWIG_fail;
42905 }
42906 {
42907 resultobj = wxPyMake_wxObject(result, (bool)0);
42908 }
42909 {
42910 if (temp3)
42911 delete arg3;
42912 }
42913 {
42914 if (temp4)
42915 delete arg4;
42916 }
42917 return resultobj;
42918 fail:
42919 {
42920 if (temp3)
42921 delete arg3;
42922 }
42923 {
42924 if (temp4)
42925 delete arg4;
42926 }
42927 return NULL;
42928 }
42929
42930
42931 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42932 PyObject *resultobj = 0;
42933 wxMenu *arg1 = (wxMenu *) 0 ;
42934 int arg2 ;
42935 wxString *arg3 = 0 ;
42936 wxString const &arg4_defvalue = wxPyEmptyString ;
42937 wxString *arg4 = (wxString *) &arg4_defvalue ;
42938 wxMenuItem *result = 0 ;
42939 void *argp1 = 0 ;
42940 int res1 = 0 ;
42941 int val2 ;
42942 int ecode2 = 0 ;
42943 bool temp3 = false ;
42944 bool temp4 = false ;
42945 PyObject * obj0 = 0 ;
42946 PyObject * obj1 = 0 ;
42947 PyObject * obj2 = 0 ;
42948 PyObject * obj3 = 0 ;
42949 char * kwnames[] = {
42950 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42951 };
42952
42953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42955 if (!SWIG_IsOK(res1)) {
42956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42957 }
42958 arg1 = reinterpret_cast< wxMenu * >(argp1);
42959 ecode2 = SWIG_AsVal_int(obj1, &val2);
42960 if (!SWIG_IsOK(ecode2)) {
42961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
42962 }
42963 arg2 = static_cast< int >(val2);
42964 {
42965 arg3 = wxString_in_helper(obj2);
42966 if (arg3 == NULL) SWIG_fail;
42967 temp3 = true;
42968 }
42969 if (obj3) {
42970 {
42971 arg4 = wxString_in_helper(obj3);
42972 if (arg4 == NULL) SWIG_fail;
42973 temp4 = true;
42974 }
42975 }
42976 {
42977 PyThreadState* __tstate = wxPyBeginAllowThreads();
42978 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42979 wxPyEndAllowThreads(__tstate);
42980 if (PyErr_Occurred()) SWIG_fail;
42981 }
42982 {
42983 resultobj = wxPyMake_wxObject(result, (bool)0);
42984 }
42985 {
42986 if (temp3)
42987 delete arg3;
42988 }
42989 {
42990 if (temp4)
42991 delete arg4;
42992 }
42993 return resultobj;
42994 fail:
42995 {
42996 if (temp3)
42997 delete arg3;
42998 }
42999 {
43000 if (temp4)
43001 delete arg4;
43002 }
43003 return NULL;
43004 }
43005
43006
43007 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43008 PyObject *resultobj = 0;
43009 wxMenu *arg1 = (wxMenu *) 0 ;
43010 int arg2 ;
43011 wxString *arg3 = 0 ;
43012 wxMenu *arg4 = (wxMenu *) 0 ;
43013 wxString const &arg5_defvalue = wxPyEmptyString ;
43014 wxString *arg5 = (wxString *) &arg5_defvalue ;
43015 wxMenuItem *result = 0 ;
43016 void *argp1 = 0 ;
43017 int res1 = 0 ;
43018 int val2 ;
43019 int ecode2 = 0 ;
43020 bool temp3 = false ;
43021 void *argp4 = 0 ;
43022 int res4 = 0 ;
43023 bool temp5 = false ;
43024 PyObject * obj0 = 0 ;
43025 PyObject * obj1 = 0 ;
43026 PyObject * obj2 = 0 ;
43027 PyObject * obj3 = 0 ;
43028 PyObject * obj4 = 0 ;
43029 char * kwnames[] = {
43030 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
43031 };
43032
43033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43035 if (!SWIG_IsOK(res1)) {
43036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
43037 }
43038 arg1 = reinterpret_cast< wxMenu * >(argp1);
43039 ecode2 = SWIG_AsVal_int(obj1, &val2);
43040 if (!SWIG_IsOK(ecode2)) {
43041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
43042 }
43043 arg2 = static_cast< int >(val2);
43044 {
43045 arg3 = wxString_in_helper(obj2);
43046 if (arg3 == NULL) SWIG_fail;
43047 temp3 = true;
43048 }
43049 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
43050 if (!SWIG_IsOK(res4)) {
43051 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
43052 }
43053 arg4 = reinterpret_cast< wxMenu * >(argp4);
43054 if (obj4) {
43055 {
43056 arg5 = wxString_in_helper(obj4);
43057 if (arg5 == NULL) SWIG_fail;
43058 temp5 = true;
43059 }
43060 }
43061 {
43062 PyThreadState* __tstate = wxPyBeginAllowThreads();
43063 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
43064 wxPyEndAllowThreads(__tstate);
43065 if (PyErr_Occurred()) SWIG_fail;
43066 }
43067 {
43068 resultobj = wxPyMake_wxObject(result, (bool)0);
43069 }
43070 {
43071 if (temp3)
43072 delete arg3;
43073 }
43074 {
43075 if (temp5)
43076 delete arg5;
43077 }
43078 return resultobj;
43079 fail:
43080 {
43081 if (temp3)
43082 delete arg3;
43083 }
43084 {
43085 if (temp5)
43086 delete arg5;
43087 }
43088 return NULL;
43089 }
43090
43091
43092 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43093 PyObject *resultobj = 0;
43094 wxMenu *arg1 = (wxMenu *) 0 ;
43095 int arg2 ;
43096 wxMenuItem *result = 0 ;
43097 void *argp1 = 0 ;
43098 int res1 = 0 ;
43099 int val2 ;
43100 int ecode2 = 0 ;
43101 PyObject * obj0 = 0 ;
43102 PyObject * obj1 = 0 ;
43103 char * kwnames[] = {
43104 (char *) "self",(char *) "id", NULL
43105 };
43106
43107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
43108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43109 if (!SWIG_IsOK(res1)) {
43110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
43111 }
43112 arg1 = reinterpret_cast< wxMenu * >(argp1);
43113 ecode2 = SWIG_AsVal_int(obj1, &val2);
43114 if (!SWIG_IsOK(ecode2)) {
43115 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
43116 }
43117 arg2 = static_cast< int >(val2);
43118 {
43119 PyThreadState* __tstate = wxPyBeginAllowThreads();
43120 result = (wxMenuItem *)(arg1)->Remove(arg2);
43121 wxPyEndAllowThreads(__tstate);
43122 if (PyErr_Occurred()) SWIG_fail;
43123 }
43124 {
43125 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43126 }
43127 return resultobj;
43128 fail:
43129 return NULL;
43130 }
43131
43132
43133 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43134 PyObject *resultobj = 0;
43135 wxMenu *arg1 = (wxMenu *) 0 ;
43136 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43137 wxMenuItem *result = 0 ;
43138 void *argp1 = 0 ;
43139 int res1 = 0 ;
43140 void *argp2 = 0 ;
43141 int res2 = 0 ;
43142 PyObject * obj0 = 0 ;
43143 PyObject * obj1 = 0 ;
43144 char * kwnames[] = {
43145 (char *) "self",(char *) "item", NULL
43146 };
43147
43148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
43149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43150 if (!SWIG_IsOK(res1)) {
43151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43152 }
43153 arg1 = reinterpret_cast< wxMenu * >(argp1);
43154 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43155 if (!SWIG_IsOK(res2)) {
43156 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43157 }
43158 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43159 {
43160 PyThreadState* __tstate = wxPyBeginAllowThreads();
43161 result = (wxMenuItem *)(arg1)->Remove(arg2);
43162 wxPyEndAllowThreads(__tstate);
43163 if (PyErr_Occurred()) SWIG_fail;
43164 }
43165 {
43166 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43167 }
43168 return resultobj;
43169 fail:
43170 return NULL;
43171 }
43172
43173
43174 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43175 PyObject *resultobj = 0;
43176 wxMenu *arg1 = (wxMenu *) 0 ;
43177 int arg2 ;
43178 bool result;
43179 void *argp1 = 0 ;
43180 int res1 = 0 ;
43181 int val2 ;
43182 int ecode2 = 0 ;
43183 PyObject * obj0 = 0 ;
43184 PyObject * obj1 = 0 ;
43185 char * kwnames[] = {
43186 (char *) "self",(char *) "id", NULL
43187 };
43188
43189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
43190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43191 if (!SWIG_IsOK(res1)) {
43192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
43193 }
43194 arg1 = reinterpret_cast< wxMenu * >(argp1);
43195 ecode2 = SWIG_AsVal_int(obj1, &val2);
43196 if (!SWIG_IsOK(ecode2)) {
43197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
43198 }
43199 arg2 = static_cast< int >(val2);
43200 {
43201 PyThreadState* __tstate = wxPyBeginAllowThreads();
43202 result = (bool)(arg1)->Delete(arg2);
43203 wxPyEndAllowThreads(__tstate);
43204 if (PyErr_Occurred()) SWIG_fail;
43205 }
43206 {
43207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43208 }
43209 return resultobj;
43210 fail:
43211 return NULL;
43212 }
43213
43214
43215 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43216 PyObject *resultobj = 0;
43217 wxMenu *arg1 = (wxMenu *) 0 ;
43218 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43219 bool result;
43220 void *argp1 = 0 ;
43221 int res1 = 0 ;
43222 void *argp2 = 0 ;
43223 int res2 = 0 ;
43224 PyObject * obj0 = 0 ;
43225 PyObject * obj1 = 0 ;
43226 char * kwnames[] = {
43227 (char *) "self",(char *) "item", NULL
43228 };
43229
43230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
43231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43232 if (!SWIG_IsOK(res1)) {
43233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43234 }
43235 arg1 = reinterpret_cast< wxMenu * >(argp1);
43236 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43237 if (!SWIG_IsOK(res2)) {
43238 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43239 }
43240 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43241 {
43242 PyThreadState* __tstate = wxPyBeginAllowThreads();
43243 result = (bool)(arg1)->Delete(arg2);
43244 wxPyEndAllowThreads(__tstate);
43245 if (PyErr_Occurred()) SWIG_fail;
43246 }
43247 {
43248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43249 }
43250 return resultobj;
43251 fail:
43252 return NULL;
43253 }
43254
43255
43256 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43257 PyObject *resultobj = 0;
43258 wxMenu *arg1 = (wxMenu *) 0 ;
43259 void *argp1 = 0 ;
43260 int res1 = 0 ;
43261 PyObject *swig_obj[1] ;
43262
43263 if (!args) SWIG_fail;
43264 swig_obj[0] = args;
43265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43266 if (!SWIG_IsOK(res1)) {
43267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
43268 }
43269 arg1 = reinterpret_cast< wxMenu * >(argp1);
43270 {
43271 PyThreadState* __tstate = wxPyBeginAllowThreads();
43272 wxMenu_Destroy(arg1);
43273 wxPyEndAllowThreads(__tstate);
43274 if (PyErr_Occurred()) SWIG_fail;
43275 }
43276 resultobj = SWIG_Py_Void();
43277 return resultobj;
43278 fail:
43279 return NULL;
43280 }
43281
43282
43283 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43284 PyObject *resultobj = 0;
43285 wxMenu *arg1 = (wxMenu *) 0 ;
43286 int arg2 ;
43287 bool result;
43288 void *argp1 = 0 ;
43289 int res1 = 0 ;
43290 int val2 ;
43291 int ecode2 = 0 ;
43292 PyObject * obj0 = 0 ;
43293 PyObject * obj1 = 0 ;
43294 char * kwnames[] = {
43295 (char *) "self",(char *) "id", NULL
43296 };
43297
43298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
43299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43300 if (!SWIG_IsOK(res1)) {
43301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
43302 }
43303 arg1 = reinterpret_cast< wxMenu * >(argp1);
43304 ecode2 = SWIG_AsVal_int(obj1, &val2);
43305 if (!SWIG_IsOK(ecode2)) {
43306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
43307 }
43308 arg2 = static_cast< int >(val2);
43309 {
43310 PyThreadState* __tstate = wxPyBeginAllowThreads();
43311 result = (bool)(arg1)->Destroy(arg2);
43312 wxPyEndAllowThreads(__tstate);
43313 if (PyErr_Occurred()) SWIG_fail;
43314 }
43315 {
43316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43317 }
43318 return resultobj;
43319 fail:
43320 return NULL;
43321 }
43322
43323
43324 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43325 PyObject *resultobj = 0;
43326 wxMenu *arg1 = (wxMenu *) 0 ;
43327 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43328 bool result;
43329 void *argp1 = 0 ;
43330 int res1 = 0 ;
43331 void *argp2 = 0 ;
43332 int res2 = 0 ;
43333 PyObject * obj0 = 0 ;
43334 PyObject * obj1 = 0 ;
43335 char * kwnames[] = {
43336 (char *) "self",(char *) "item", NULL
43337 };
43338
43339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
43340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43341 if (!SWIG_IsOK(res1)) {
43342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43343 }
43344 arg1 = reinterpret_cast< wxMenu * >(argp1);
43345 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43346 if (!SWIG_IsOK(res2)) {
43347 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43348 }
43349 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43350 {
43351 PyThreadState* __tstate = wxPyBeginAllowThreads();
43352 result = (bool)(arg1)->Destroy(arg2);
43353 wxPyEndAllowThreads(__tstate);
43354 if (PyErr_Occurred()) SWIG_fail;
43355 }
43356 {
43357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43358 }
43359 return resultobj;
43360 fail:
43361 return NULL;
43362 }
43363
43364
43365 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43366 PyObject *resultobj = 0;
43367 wxMenu *arg1 = (wxMenu *) 0 ;
43368 size_t result;
43369 void *argp1 = 0 ;
43370 int res1 = 0 ;
43371 PyObject *swig_obj[1] ;
43372
43373 if (!args) SWIG_fail;
43374 swig_obj[0] = args;
43375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43376 if (!SWIG_IsOK(res1)) {
43377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
43378 }
43379 arg1 = reinterpret_cast< wxMenu * >(argp1);
43380 {
43381 PyThreadState* __tstate = wxPyBeginAllowThreads();
43382 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
43383 wxPyEndAllowThreads(__tstate);
43384 if (PyErr_Occurred()) SWIG_fail;
43385 }
43386 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
43387 return resultobj;
43388 fail:
43389 return NULL;
43390 }
43391
43392
43393 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43394 PyObject *resultobj = 0;
43395 wxMenu *arg1 = (wxMenu *) 0 ;
43396 PyObject *result = 0 ;
43397 void *argp1 = 0 ;
43398 int res1 = 0 ;
43399 PyObject *swig_obj[1] ;
43400
43401 if (!args) SWIG_fail;
43402 swig_obj[0] = args;
43403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43404 if (!SWIG_IsOK(res1)) {
43405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
43406 }
43407 arg1 = reinterpret_cast< wxMenu * >(argp1);
43408 {
43409 PyThreadState* __tstate = wxPyBeginAllowThreads();
43410 result = (PyObject *)wxMenu_GetMenuItems(arg1);
43411 wxPyEndAllowThreads(__tstate);
43412 if (PyErr_Occurred()) SWIG_fail;
43413 }
43414 resultobj = result;
43415 return resultobj;
43416 fail:
43417 return NULL;
43418 }
43419
43420
43421 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43422 PyObject *resultobj = 0;
43423 wxMenu *arg1 = (wxMenu *) 0 ;
43424 wxString *arg2 = 0 ;
43425 int result;
43426 void *argp1 = 0 ;
43427 int res1 = 0 ;
43428 bool temp2 = false ;
43429 PyObject * obj0 = 0 ;
43430 PyObject * obj1 = 0 ;
43431 char * kwnames[] = {
43432 (char *) "self",(char *) "item", NULL
43433 };
43434
43435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
43436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43437 if (!SWIG_IsOK(res1)) {
43438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
43439 }
43440 arg1 = reinterpret_cast< wxMenu * >(argp1);
43441 {
43442 arg2 = wxString_in_helper(obj1);
43443 if (arg2 == NULL) SWIG_fail;
43444 temp2 = true;
43445 }
43446 {
43447 PyThreadState* __tstate = wxPyBeginAllowThreads();
43448 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
43449 wxPyEndAllowThreads(__tstate);
43450 if (PyErr_Occurred()) SWIG_fail;
43451 }
43452 resultobj = SWIG_From_int(static_cast< int >(result));
43453 {
43454 if (temp2)
43455 delete arg2;
43456 }
43457 return resultobj;
43458 fail:
43459 {
43460 if (temp2)
43461 delete arg2;
43462 }
43463 return NULL;
43464 }
43465
43466
43467 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43468 PyObject *resultobj = 0;
43469 wxMenu *arg1 = (wxMenu *) 0 ;
43470 int arg2 ;
43471 wxMenuItem *result = 0 ;
43472 void *argp1 = 0 ;
43473 int res1 = 0 ;
43474 int val2 ;
43475 int ecode2 = 0 ;
43476 PyObject * obj0 = 0 ;
43477 PyObject * obj1 = 0 ;
43478 char * kwnames[] = {
43479 (char *) "self",(char *) "id", NULL
43480 };
43481
43482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
43483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43484 if (!SWIG_IsOK(res1)) {
43485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
43486 }
43487 arg1 = reinterpret_cast< wxMenu * >(argp1);
43488 ecode2 = SWIG_AsVal_int(obj1, &val2);
43489 if (!SWIG_IsOK(ecode2)) {
43490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
43491 }
43492 arg2 = static_cast< int >(val2);
43493 {
43494 PyThreadState* __tstate = wxPyBeginAllowThreads();
43495 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
43496 wxPyEndAllowThreads(__tstate);
43497 if (PyErr_Occurred()) SWIG_fail;
43498 }
43499 {
43500 resultobj = wxPyMake_wxObject(result, (bool)0);
43501 }
43502 return resultobj;
43503 fail:
43504 return NULL;
43505 }
43506
43507
43508 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43509 PyObject *resultobj = 0;
43510 wxMenu *arg1 = (wxMenu *) 0 ;
43511 size_t arg2 ;
43512 wxMenuItem *result = 0 ;
43513 void *argp1 = 0 ;
43514 int res1 = 0 ;
43515 size_t val2 ;
43516 int ecode2 = 0 ;
43517 PyObject * obj0 = 0 ;
43518 PyObject * obj1 = 0 ;
43519 char * kwnames[] = {
43520 (char *) "self",(char *) "position", NULL
43521 };
43522
43523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
43524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43525 if (!SWIG_IsOK(res1)) {
43526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
43527 }
43528 arg1 = reinterpret_cast< wxMenu * >(argp1);
43529 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43530 if (!SWIG_IsOK(ecode2)) {
43531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
43532 }
43533 arg2 = static_cast< size_t >(val2);
43534 {
43535 PyThreadState* __tstate = wxPyBeginAllowThreads();
43536 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
43537 wxPyEndAllowThreads(__tstate);
43538 if (PyErr_Occurred()) SWIG_fail;
43539 }
43540 {
43541 resultobj = wxPyMake_wxObject(result, (bool)0);
43542 }
43543 return resultobj;
43544 fail:
43545 return NULL;
43546 }
43547
43548
43549 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43550 PyObject *resultobj = 0;
43551 wxMenu *arg1 = (wxMenu *) 0 ;
43552 int arg2 ;
43553 bool arg3 ;
43554 void *argp1 = 0 ;
43555 int res1 = 0 ;
43556 int val2 ;
43557 int ecode2 = 0 ;
43558 bool val3 ;
43559 int ecode3 = 0 ;
43560 PyObject * obj0 = 0 ;
43561 PyObject * obj1 = 0 ;
43562 PyObject * obj2 = 0 ;
43563 char * kwnames[] = {
43564 (char *) "self",(char *) "id",(char *) "enable", NULL
43565 };
43566
43567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43569 if (!SWIG_IsOK(res1)) {
43570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
43571 }
43572 arg1 = reinterpret_cast< wxMenu * >(argp1);
43573 ecode2 = SWIG_AsVal_int(obj1, &val2);
43574 if (!SWIG_IsOK(ecode2)) {
43575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
43576 }
43577 arg2 = static_cast< int >(val2);
43578 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43579 if (!SWIG_IsOK(ecode3)) {
43580 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
43581 }
43582 arg3 = static_cast< bool >(val3);
43583 {
43584 PyThreadState* __tstate = wxPyBeginAllowThreads();
43585 (arg1)->Enable(arg2,arg3);
43586 wxPyEndAllowThreads(__tstate);
43587 if (PyErr_Occurred()) SWIG_fail;
43588 }
43589 resultobj = SWIG_Py_Void();
43590 return resultobj;
43591 fail:
43592 return NULL;
43593 }
43594
43595
43596 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43597 PyObject *resultobj = 0;
43598 wxMenu *arg1 = (wxMenu *) 0 ;
43599 int arg2 ;
43600 bool result;
43601 void *argp1 = 0 ;
43602 int res1 = 0 ;
43603 int val2 ;
43604 int ecode2 = 0 ;
43605 PyObject * obj0 = 0 ;
43606 PyObject * obj1 = 0 ;
43607 char * kwnames[] = {
43608 (char *) "self",(char *) "id", NULL
43609 };
43610
43611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
43612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43613 if (!SWIG_IsOK(res1)) {
43614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
43615 }
43616 arg1 = reinterpret_cast< wxMenu * >(argp1);
43617 ecode2 = SWIG_AsVal_int(obj1, &val2);
43618 if (!SWIG_IsOK(ecode2)) {
43619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
43620 }
43621 arg2 = static_cast< int >(val2);
43622 {
43623 PyThreadState* __tstate = wxPyBeginAllowThreads();
43624 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
43625 wxPyEndAllowThreads(__tstate);
43626 if (PyErr_Occurred()) SWIG_fail;
43627 }
43628 {
43629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43630 }
43631 return resultobj;
43632 fail:
43633 return NULL;
43634 }
43635
43636
43637 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43638 PyObject *resultobj = 0;
43639 wxMenu *arg1 = (wxMenu *) 0 ;
43640 int arg2 ;
43641 bool arg3 ;
43642 void *argp1 = 0 ;
43643 int res1 = 0 ;
43644 int val2 ;
43645 int ecode2 = 0 ;
43646 bool val3 ;
43647 int ecode3 = 0 ;
43648 PyObject * obj0 = 0 ;
43649 PyObject * obj1 = 0 ;
43650 PyObject * obj2 = 0 ;
43651 char * kwnames[] = {
43652 (char *) "self",(char *) "id",(char *) "check", NULL
43653 };
43654
43655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43657 if (!SWIG_IsOK(res1)) {
43658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
43659 }
43660 arg1 = reinterpret_cast< wxMenu * >(argp1);
43661 ecode2 = SWIG_AsVal_int(obj1, &val2);
43662 if (!SWIG_IsOK(ecode2)) {
43663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
43664 }
43665 arg2 = static_cast< int >(val2);
43666 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43667 if (!SWIG_IsOK(ecode3)) {
43668 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
43669 }
43670 arg3 = static_cast< bool >(val3);
43671 {
43672 PyThreadState* __tstate = wxPyBeginAllowThreads();
43673 (arg1)->Check(arg2,arg3);
43674 wxPyEndAllowThreads(__tstate);
43675 if (PyErr_Occurred()) SWIG_fail;
43676 }
43677 resultobj = SWIG_Py_Void();
43678 return resultobj;
43679 fail:
43680 return NULL;
43681 }
43682
43683
43684 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43685 PyObject *resultobj = 0;
43686 wxMenu *arg1 = (wxMenu *) 0 ;
43687 int arg2 ;
43688 bool result;
43689 void *argp1 = 0 ;
43690 int res1 = 0 ;
43691 int val2 ;
43692 int ecode2 = 0 ;
43693 PyObject * obj0 = 0 ;
43694 PyObject * obj1 = 0 ;
43695 char * kwnames[] = {
43696 (char *) "self",(char *) "id", NULL
43697 };
43698
43699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
43700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43701 if (!SWIG_IsOK(res1)) {
43702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
43703 }
43704 arg1 = reinterpret_cast< wxMenu * >(argp1);
43705 ecode2 = SWIG_AsVal_int(obj1, &val2);
43706 if (!SWIG_IsOK(ecode2)) {
43707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
43708 }
43709 arg2 = static_cast< int >(val2);
43710 {
43711 PyThreadState* __tstate = wxPyBeginAllowThreads();
43712 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
43713 wxPyEndAllowThreads(__tstate);
43714 if (PyErr_Occurred()) SWIG_fail;
43715 }
43716 {
43717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43718 }
43719 return resultobj;
43720 fail:
43721 return NULL;
43722 }
43723
43724
43725 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43726 PyObject *resultobj = 0;
43727 wxMenu *arg1 = (wxMenu *) 0 ;
43728 int arg2 ;
43729 wxString *arg3 = 0 ;
43730 void *argp1 = 0 ;
43731 int res1 = 0 ;
43732 int val2 ;
43733 int ecode2 = 0 ;
43734 bool temp3 = false ;
43735 PyObject * obj0 = 0 ;
43736 PyObject * obj1 = 0 ;
43737 PyObject * obj2 = 0 ;
43738 char * kwnames[] = {
43739 (char *) "self",(char *) "id",(char *) "label", NULL
43740 };
43741
43742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43744 if (!SWIG_IsOK(res1)) {
43745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
43746 }
43747 arg1 = reinterpret_cast< wxMenu * >(argp1);
43748 ecode2 = SWIG_AsVal_int(obj1, &val2);
43749 if (!SWIG_IsOK(ecode2)) {
43750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
43751 }
43752 arg2 = static_cast< int >(val2);
43753 {
43754 arg3 = wxString_in_helper(obj2);
43755 if (arg3 == NULL) SWIG_fail;
43756 temp3 = true;
43757 }
43758 {
43759 PyThreadState* __tstate = wxPyBeginAllowThreads();
43760 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
43761 wxPyEndAllowThreads(__tstate);
43762 if (PyErr_Occurred()) SWIG_fail;
43763 }
43764 resultobj = SWIG_Py_Void();
43765 {
43766 if (temp3)
43767 delete arg3;
43768 }
43769 return resultobj;
43770 fail:
43771 {
43772 if (temp3)
43773 delete arg3;
43774 }
43775 return NULL;
43776 }
43777
43778
43779 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43780 PyObject *resultobj = 0;
43781 wxMenu *arg1 = (wxMenu *) 0 ;
43782 int arg2 ;
43783 wxString result;
43784 void *argp1 = 0 ;
43785 int res1 = 0 ;
43786 int val2 ;
43787 int ecode2 = 0 ;
43788 PyObject * obj0 = 0 ;
43789 PyObject * obj1 = 0 ;
43790 char * kwnames[] = {
43791 (char *) "self",(char *) "id", NULL
43792 };
43793
43794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
43795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43796 if (!SWIG_IsOK(res1)) {
43797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
43798 }
43799 arg1 = reinterpret_cast< wxMenu * >(argp1);
43800 ecode2 = SWIG_AsVal_int(obj1, &val2);
43801 if (!SWIG_IsOK(ecode2)) {
43802 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
43803 }
43804 arg2 = static_cast< int >(val2);
43805 {
43806 PyThreadState* __tstate = wxPyBeginAllowThreads();
43807 result = ((wxMenu const *)arg1)->GetLabel(arg2);
43808 wxPyEndAllowThreads(__tstate);
43809 if (PyErr_Occurred()) SWIG_fail;
43810 }
43811 {
43812 #if wxUSE_UNICODE
43813 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43814 #else
43815 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43816 #endif
43817 }
43818 return resultobj;
43819 fail:
43820 return NULL;
43821 }
43822
43823
43824 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43825 PyObject *resultobj = 0;
43826 wxMenu *arg1 = (wxMenu *) 0 ;
43827 int arg2 ;
43828 wxString *arg3 = 0 ;
43829 void *argp1 = 0 ;
43830 int res1 = 0 ;
43831 int val2 ;
43832 int ecode2 = 0 ;
43833 bool temp3 = false ;
43834 PyObject * obj0 = 0 ;
43835 PyObject * obj1 = 0 ;
43836 PyObject * obj2 = 0 ;
43837 char * kwnames[] = {
43838 (char *) "self",(char *) "id",(char *) "helpString", NULL
43839 };
43840
43841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43843 if (!SWIG_IsOK(res1)) {
43844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
43845 }
43846 arg1 = reinterpret_cast< wxMenu * >(argp1);
43847 ecode2 = SWIG_AsVal_int(obj1, &val2);
43848 if (!SWIG_IsOK(ecode2)) {
43849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
43850 }
43851 arg2 = static_cast< int >(val2);
43852 {
43853 arg3 = wxString_in_helper(obj2);
43854 if (arg3 == NULL) SWIG_fail;
43855 temp3 = true;
43856 }
43857 {
43858 PyThreadState* __tstate = wxPyBeginAllowThreads();
43859 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
43860 wxPyEndAllowThreads(__tstate);
43861 if (PyErr_Occurred()) SWIG_fail;
43862 }
43863 resultobj = SWIG_Py_Void();
43864 {
43865 if (temp3)
43866 delete arg3;
43867 }
43868 return resultobj;
43869 fail:
43870 {
43871 if (temp3)
43872 delete arg3;
43873 }
43874 return NULL;
43875 }
43876
43877
43878 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43879 PyObject *resultobj = 0;
43880 wxMenu *arg1 = (wxMenu *) 0 ;
43881 int arg2 ;
43882 wxString result;
43883 void *argp1 = 0 ;
43884 int res1 = 0 ;
43885 int val2 ;
43886 int ecode2 = 0 ;
43887 PyObject * obj0 = 0 ;
43888 PyObject * obj1 = 0 ;
43889 char * kwnames[] = {
43890 (char *) "self",(char *) "id", NULL
43891 };
43892
43893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
43894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43895 if (!SWIG_IsOK(res1)) {
43896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
43897 }
43898 arg1 = reinterpret_cast< wxMenu * >(argp1);
43899 ecode2 = SWIG_AsVal_int(obj1, &val2);
43900 if (!SWIG_IsOK(ecode2)) {
43901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
43902 }
43903 arg2 = static_cast< int >(val2);
43904 {
43905 PyThreadState* __tstate = wxPyBeginAllowThreads();
43906 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
43907 wxPyEndAllowThreads(__tstate);
43908 if (PyErr_Occurred()) SWIG_fail;
43909 }
43910 {
43911 #if wxUSE_UNICODE
43912 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43913 #else
43914 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43915 #endif
43916 }
43917 return resultobj;
43918 fail:
43919 return NULL;
43920 }
43921
43922
43923 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43924 PyObject *resultobj = 0;
43925 wxMenu *arg1 = (wxMenu *) 0 ;
43926 wxString *arg2 = 0 ;
43927 void *argp1 = 0 ;
43928 int res1 = 0 ;
43929 bool temp2 = false ;
43930 PyObject * obj0 = 0 ;
43931 PyObject * obj1 = 0 ;
43932 char * kwnames[] = {
43933 (char *) "self",(char *) "title", NULL
43934 };
43935
43936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
43937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43938 if (!SWIG_IsOK(res1)) {
43939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
43940 }
43941 arg1 = reinterpret_cast< wxMenu * >(argp1);
43942 {
43943 arg2 = wxString_in_helper(obj1);
43944 if (arg2 == NULL) SWIG_fail;
43945 temp2 = true;
43946 }
43947 {
43948 PyThreadState* __tstate = wxPyBeginAllowThreads();
43949 (arg1)->SetTitle((wxString const &)*arg2);
43950 wxPyEndAllowThreads(__tstate);
43951 if (PyErr_Occurred()) SWIG_fail;
43952 }
43953 resultobj = SWIG_Py_Void();
43954 {
43955 if (temp2)
43956 delete arg2;
43957 }
43958 return resultobj;
43959 fail:
43960 {
43961 if (temp2)
43962 delete arg2;
43963 }
43964 return NULL;
43965 }
43966
43967
43968 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43969 PyObject *resultobj = 0;
43970 wxMenu *arg1 = (wxMenu *) 0 ;
43971 wxString result;
43972 void *argp1 = 0 ;
43973 int res1 = 0 ;
43974 PyObject *swig_obj[1] ;
43975
43976 if (!args) SWIG_fail;
43977 swig_obj[0] = args;
43978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43979 if (!SWIG_IsOK(res1)) {
43980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
43981 }
43982 arg1 = reinterpret_cast< wxMenu * >(argp1);
43983 {
43984 PyThreadState* __tstate = wxPyBeginAllowThreads();
43985 result = ((wxMenu const *)arg1)->GetTitle();
43986 wxPyEndAllowThreads(__tstate);
43987 if (PyErr_Occurred()) SWIG_fail;
43988 }
43989 {
43990 #if wxUSE_UNICODE
43991 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43992 #else
43993 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43994 #endif
43995 }
43996 return resultobj;
43997 fail:
43998 return NULL;
43999 }
44000
44001
44002 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44003 PyObject *resultobj = 0;
44004 wxMenu *arg1 = (wxMenu *) 0 ;
44005 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
44006 void *argp1 = 0 ;
44007 int res1 = 0 ;
44008 void *argp2 = 0 ;
44009 int res2 = 0 ;
44010 PyObject * obj0 = 0 ;
44011 PyObject * obj1 = 0 ;
44012 char * kwnames[] = {
44013 (char *) "self",(char *) "handler", NULL
44014 };
44015
44016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
44017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44018 if (!SWIG_IsOK(res1)) {
44019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
44020 }
44021 arg1 = reinterpret_cast< wxMenu * >(argp1);
44022 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44023 if (!SWIG_IsOK(res2)) {
44024 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44025 }
44026 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44027 {
44028 PyThreadState* __tstate = wxPyBeginAllowThreads();
44029 (arg1)->SetEventHandler(arg2);
44030 wxPyEndAllowThreads(__tstate);
44031 if (PyErr_Occurred()) SWIG_fail;
44032 }
44033 resultobj = SWIG_Py_Void();
44034 return resultobj;
44035 fail:
44036 return NULL;
44037 }
44038
44039
44040 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44041 PyObject *resultobj = 0;
44042 wxMenu *arg1 = (wxMenu *) 0 ;
44043 wxEvtHandler *result = 0 ;
44044 void *argp1 = 0 ;
44045 int res1 = 0 ;
44046 PyObject *swig_obj[1] ;
44047
44048 if (!args) SWIG_fail;
44049 swig_obj[0] = args;
44050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44051 if (!SWIG_IsOK(res1)) {
44052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
44053 }
44054 arg1 = reinterpret_cast< wxMenu * >(argp1);
44055 {
44056 PyThreadState* __tstate = wxPyBeginAllowThreads();
44057 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
44058 wxPyEndAllowThreads(__tstate);
44059 if (PyErr_Occurred()) SWIG_fail;
44060 }
44061 {
44062 resultobj = wxPyMake_wxObject(result, 0);
44063 }
44064 return resultobj;
44065 fail:
44066 return NULL;
44067 }
44068
44069
44070 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44071 PyObject *resultobj = 0;
44072 wxMenu *arg1 = (wxMenu *) 0 ;
44073 wxWindow *arg2 = (wxWindow *) 0 ;
44074 void *argp1 = 0 ;
44075 int res1 = 0 ;
44076 void *argp2 = 0 ;
44077 int res2 = 0 ;
44078 PyObject * obj0 = 0 ;
44079 PyObject * obj1 = 0 ;
44080 char * kwnames[] = {
44081 (char *) "self",(char *) "win", NULL
44082 };
44083
44084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
44085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44086 if (!SWIG_IsOK(res1)) {
44087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
44088 }
44089 arg1 = reinterpret_cast< wxMenu * >(argp1);
44090 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44091 if (!SWIG_IsOK(res2)) {
44092 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
44093 }
44094 arg2 = reinterpret_cast< wxWindow * >(argp2);
44095 {
44096 PyThreadState* __tstate = wxPyBeginAllowThreads();
44097 (arg1)->SetInvokingWindow(arg2);
44098 wxPyEndAllowThreads(__tstate);
44099 if (PyErr_Occurred()) SWIG_fail;
44100 }
44101 resultobj = SWIG_Py_Void();
44102 return resultobj;
44103 fail:
44104 return NULL;
44105 }
44106
44107
44108 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44109 PyObject *resultobj = 0;
44110 wxMenu *arg1 = (wxMenu *) 0 ;
44111 wxWindow *result = 0 ;
44112 void *argp1 = 0 ;
44113 int res1 = 0 ;
44114 PyObject *swig_obj[1] ;
44115
44116 if (!args) SWIG_fail;
44117 swig_obj[0] = args;
44118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44119 if (!SWIG_IsOK(res1)) {
44120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
44121 }
44122 arg1 = reinterpret_cast< wxMenu * >(argp1);
44123 {
44124 PyThreadState* __tstate = wxPyBeginAllowThreads();
44125 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
44126 wxPyEndAllowThreads(__tstate);
44127 if (PyErr_Occurred()) SWIG_fail;
44128 }
44129 {
44130 resultobj = wxPyMake_wxObject(result, 0);
44131 }
44132 return resultobj;
44133 fail:
44134 return NULL;
44135 }
44136
44137
44138 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44139 PyObject *resultobj = 0;
44140 wxMenu *arg1 = (wxMenu *) 0 ;
44141 long result;
44142 void *argp1 = 0 ;
44143 int res1 = 0 ;
44144 PyObject *swig_obj[1] ;
44145
44146 if (!args) SWIG_fail;
44147 swig_obj[0] = args;
44148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44149 if (!SWIG_IsOK(res1)) {
44150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44151 }
44152 arg1 = reinterpret_cast< wxMenu * >(argp1);
44153 {
44154 PyThreadState* __tstate = wxPyBeginAllowThreads();
44155 result = (long)((wxMenu const *)arg1)->GetStyle();
44156 wxPyEndAllowThreads(__tstate);
44157 if (PyErr_Occurred()) SWIG_fail;
44158 }
44159 resultobj = SWIG_From_long(static_cast< long >(result));
44160 return resultobj;
44161 fail:
44162 return NULL;
44163 }
44164
44165
44166 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44167 PyObject *resultobj = 0;
44168 wxMenu *arg1 = (wxMenu *) 0 ;
44169 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
44170 void *argp1 = 0 ;
44171 int res1 = 0 ;
44172 void *argp2 = 0 ;
44173 int res2 = 0 ;
44174 PyObject * obj0 = 0 ;
44175 PyObject * obj1 = 0 ;
44176 char * kwnames[] = {
44177 (char *) "self",(char *) "source", NULL
44178 };
44179
44180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
44181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44182 if (!SWIG_IsOK(res1)) {
44183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
44184 }
44185 arg1 = reinterpret_cast< wxMenu * >(argp1);
44186 if (obj1) {
44187 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44188 if (!SWIG_IsOK(res2)) {
44189 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44190 }
44191 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44192 }
44193 {
44194 PyThreadState* __tstate = wxPyBeginAllowThreads();
44195 (arg1)->UpdateUI(arg2);
44196 wxPyEndAllowThreads(__tstate);
44197 if (PyErr_Occurred()) SWIG_fail;
44198 }
44199 resultobj = SWIG_Py_Void();
44200 return resultobj;
44201 fail:
44202 return NULL;
44203 }
44204
44205
44206 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44207 PyObject *resultobj = 0;
44208 wxMenu *arg1 = (wxMenu *) 0 ;
44209 wxMenuBar *result = 0 ;
44210 void *argp1 = 0 ;
44211 int res1 = 0 ;
44212 PyObject *swig_obj[1] ;
44213
44214 if (!args) SWIG_fail;
44215 swig_obj[0] = args;
44216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44217 if (!SWIG_IsOK(res1)) {
44218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
44219 }
44220 arg1 = reinterpret_cast< wxMenu * >(argp1);
44221 {
44222 PyThreadState* __tstate = wxPyBeginAllowThreads();
44223 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
44224 wxPyEndAllowThreads(__tstate);
44225 if (PyErr_Occurred()) SWIG_fail;
44226 }
44227 {
44228 resultobj = wxPyMake_wxObject(result, (bool)0);
44229 }
44230 return resultobj;
44231 fail:
44232 return NULL;
44233 }
44234
44235
44236 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44237 PyObject *resultobj = 0;
44238 wxMenu *arg1 = (wxMenu *) 0 ;
44239 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
44240 void *argp1 = 0 ;
44241 int res1 = 0 ;
44242 void *argp2 = 0 ;
44243 int res2 = 0 ;
44244 PyObject * obj0 = 0 ;
44245 PyObject * obj1 = 0 ;
44246 char * kwnames[] = {
44247 (char *) "self",(char *) "menubar", NULL
44248 };
44249
44250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
44251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44252 if (!SWIG_IsOK(res1)) {
44253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
44254 }
44255 arg1 = reinterpret_cast< wxMenu * >(argp1);
44256 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
44257 if (!SWIG_IsOK(res2)) {
44258 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
44259 }
44260 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
44261 {
44262 PyThreadState* __tstate = wxPyBeginAllowThreads();
44263 (arg1)->Attach(arg2);
44264 wxPyEndAllowThreads(__tstate);
44265 if (PyErr_Occurred()) SWIG_fail;
44266 }
44267 resultobj = SWIG_Py_Void();
44268 return resultobj;
44269 fail:
44270 return NULL;
44271 }
44272
44273
44274 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44275 PyObject *resultobj = 0;
44276 wxMenu *arg1 = (wxMenu *) 0 ;
44277 void *argp1 = 0 ;
44278 int res1 = 0 ;
44279 PyObject *swig_obj[1] ;
44280
44281 if (!args) SWIG_fail;
44282 swig_obj[0] = args;
44283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44284 if (!SWIG_IsOK(res1)) {
44285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
44286 }
44287 arg1 = reinterpret_cast< wxMenu * >(argp1);
44288 {
44289 PyThreadState* __tstate = wxPyBeginAllowThreads();
44290 (arg1)->Detach();
44291 wxPyEndAllowThreads(__tstate);
44292 if (PyErr_Occurred()) SWIG_fail;
44293 }
44294 resultobj = SWIG_Py_Void();
44295 return resultobj;
44296 fail:
44297 return NULL;
44298 }
44299
44300
44301 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44302 PyObject *resultobj = 0;
44303 wxMenu *arg1 = (wxMenu *) 0 ;
44304 bool result;
44305 void *argp1 = 0 ;
44306 int res1 = 0 ;
44307 PyObject *swig_obj[1] ;
44308
44309 if (!args) SWIG_fail;
44310 swig_obj[0] = args;
44311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44312 if (!SWIG_IsOK(res1)) {
44313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
44314 }
44315 arg1 = reinterpret_cast< wxMenu * >(argp1);
44316 {
44317 PyThreadState* __tstate = wxPyBeginAllowThreads();
44318 result = (bool)((wxMenu const *)arg1)->IsAttached();
44319 wxPyEndAllowThreads(__tstate);
44320 if (PyErr_Occurred()) SWIG_fail;
44321 }
44322 {
44323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44324 }
44325 return resultobj;
44326 fail:
44327 return NULL;
44328 }
44329
44330
44331 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44332 PyObject *resultobj = 0;
44333 wxMenu *arg1 = (wxMenu *) 0 ;
44334 wxMenu *arg2 = (wxMenu *) 0 ;
44335 void *argp1 = 0 ;
44336 int res1 = 0 ;
44337 void *argp2 = 0 ;
44338 int res2 = 0 ;
44339 PyObject * obj0 = 0 ;
44340 PyObject * obj1 = 0 ;
44341 char * kwnames[] = {
44342 (char *) "self",(char *) "parent", NULL
44343 };
44344
44345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
44346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44347 if (!SWIG_IsOK(res1)) {
44348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
44349 }
44350 arg1 = reinterpret_cast< wxMenu * >(argp1);
44351 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44352 if (!SWIG_IsOK(res2)) {
44353 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
44354 }
44355 arg2 = reinterpret_cast< wxMenu * >(argp2);
44356 {
44357 PyThreadState* __tstate = wxPyBeginAllowThreads();
44358 (arg1)->SetParent(arg2);
44359 wxPyEndAllowThreads(__tstate);
44360 if (PyErr_Occurred()) SWIG_fail;
44361 }
44362 resultobj = SWIG_Py_Void();
44363 return resultobj;
44364 fail:
44365 return NULL;
44366 }
44367
44368
44369 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44370 PyObject *resultobj = 0;
44371 wxMenu *arg1 = (wxMenu *) 0 ;
44372 wxMenu *result = 0 ;
44373 void *argp1 = 0 ;
44374 int res1 = 0 ;
44375 PyObject *swig_obj[1] ;
44376
44377 if (!args) SWIG_fail;
44378 swig_obj[0] = args;
44379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44380 if (!SWIG_IsOK(res1)) {
44381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
44382 }
44383 arg1 = reinterpret_cast< wxMenu * >(argp1);
44384 {
44385 PyThreadState* __tstate = wxPyBeginAllowThreads();
44386 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
44387 wxPyEndAllowThreads(__tstate);
44388 if (PyErr_Occurred()) SWIG_fail;
44389 }
44390 {
44391 resultobj = wxPyMake_wxObject(result, 0);
44392 }
44393 return resultobj;
44394 fail:
44395 return NULL;
44396 }
44397
44398
44399 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44400 PyObject *obj;
44401 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44402 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
44403 return SWIG_Py_Void();
44404 }
44405
44406 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44407 return SWIG_Python_InitShadowInstance(args);
44408 }
44409
44410 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44411 PyObject *resultobj = 0;
44412 long arg1 = (long) 0 ;
44413 wxMenuBar *result = 0 ;
44414 long val1 ;
44415 int ecode1 = 0 ;
44416 PyObject * obj0 = 0 ;
44417 char * kwnames[] = {
44418 (char *) "style", NULL
44419 };
44420
44421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
44422 if (obj0) {
44423 ecode1 = SWIG_AsVal_long(obj0, &val1);
44424 if (!SWIG_IsOK(ecode1)) {
44425 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
44426 }
44427 arg1 = static_cast< long >(val1);
44428 }
44429 {
44430 if (!wxPyCheckForApp()) SWIG_fail;
44431 PyThreadState* __tstate = wxPyBeginAllowThreads();
44432 result = (wxMenuBar *)new wxMenuBar(arg1);
44433 wxPyEndAllowThreads(__tstate);
44434 if (PyErr_Occurred()) SWIG_fail;
44435 }
44436 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
44437 return resultobj;
44438 fail:
44439 return NULL;
44440 }
44441
44442
44443 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44444 PyObject *resultobj = 0;
44445 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44446 wxMenu *arg2 = (wxMenu *) 0 ;
44447 wxString *arg3 = 0 ;
44448 bool result;
44449 void *argp1 = 0 ;
44450 int res1 = 0 ;
44451 void *argp2 = 0 ;
44452 int res2 = 0 ;
44453 bool temp3 = false ;
44454 PyObject * obj0 = 0 ;
44455 PyObject * obj1 = 0 ;
44456 PyObject * obj2 = 0 ;
44457 char * kwnames[] = {
44458 (char *) "self",(char *) "menu",(char *) "title", NULL
44459 };
44460
44461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44463 if (!SWIG_IsOK(res1)) {
44464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44465 }
44466 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44467 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44468 if (!SWIG_IsOK(res2)) {
44469 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
44470 }
44471 arg2 = reinterpret_cast< wxMenu * >(argp2);
44472 {
44473 arg3 = wxString_in_helper(obj2);
44474 if (arg3 == NULL) SWIG_fail;
44475 temp3 = true;
44476 }
44477 {
44478 PyThreadState* __tstate = wxPyBeginAllowThreads();
44479 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
44480 wxPyEndAllowThreads(__tstate);
44481 if (PyErr_Occurred()) SWIG_fail;
44482 }
44483 {
44484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44485 }
44486 {
44487 if (temp3)
44488 delete arg3;
44489 }
44490 return resultobj;
44491 fail:
44492 {
44493 if (temp3)
44494 delete arg3;
44495 }
44496 return NULL;
44497 }
44498
44499
44500 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44501 PyObject *resultobj = 0;
44502 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44503 size_t arg2 ;
44504 wxMenu *arg3 = (wxMenu *) 0 ;
44505 wxString *arg4 = 0 ;
44506 bool result;
44507 void *argp1 = 0 ;
44508 int res1 = 0 ;
44509 size_t val2 ;
44510 int ecode2 = 0 ;
44511 void *argp3 = 0 ;
44512 int res3 = 0 ;
44513 bool temp4 = false ;
44514 PyObject * obj0 = 0 ;
44515 PyObject * obj1 = 0 ;
44516 PyObject * obj2 = 0 ;
44517 PyObject * obj3 = 0 ;
44518 char * kwnames[] = {
44519 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44520 };
44521
44522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44524 if (!SWIG_IsOK(res1)) {
44525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44526 }
44527 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44528 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44529 if (!SWIG_IsOK(ecode2)) {
44530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
44531 }
44532 arg2 = static_cast< size_t >(val2);
44533 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44534 if (!SWIG_IsOK(res3)) {
44535 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
44536 }
44537 arg3 = reinterpret_cast< wxMenu * >(argp3);
44538 {
44539 arg4 = wxString_in_helper(obj3);
44540 if (arg4 == NULL) SWIG_fail;
44541 temp4 = true;
44542 }
44543 {
44544 PyThreadState* __tstate = wxPyBeginAllowThreads();
44545 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
44546 wxPyEndAllowThreads(__tstate);
44547 if (PyErr_Occurred()) SWIG_fail;
44548 }
44549 {
44550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44551 }
44552 {
44553 if (temp4)
44554 delete arg4;
44555 }
44556 return resultobj;
44557 fail:
44558 {
44559 if (temp4)
44560 delete arg4;
44561 }
44562 return NULL;
44563 }
44564
44565
44566 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44567 PyObject *resultobj = 0;
44568 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44569 size_t result;
44570 void *argp1 = 0 ;
44571 int res1 = 0 ;
44572 PyObject *swig_obj[1] ;
44573
44574 if (!args) SWIG_fail;
44575 swig_obj[0] = args;
44576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44577 if (!SWIG_IsOK(res1)) {
44578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44579 }
44580 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44581 {
44582 PyThreadState* __tstate = wxPyBeginAllowThreads();
44583 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
44584 wxPyEndAllowThreads(__tstate);
44585 if (PyErr_Occurred()) SWIG_fail;
44586 }
44587 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
44588 return resultobj;
44589 fail:
44590 return NULL;
44591 }
44592
44593
44594 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44595 PyObject *resultobj = 0;
44596 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44597 size_t arg2 ;
44598 wxMenu *result = 0 ;
44599 void *argp1 = 0 ;
44600 int res1 = 0 ;
44601 size_t val2 ;
44602 int ecode2 = 0 ;
44603 PyObject * obj0 = 0 ;
44604 PyObject * obj1 = 0 ;
44605 char * kwnames[] = {
44606 (char *) "self",(char *) "pos", NULL
44607 };
44608
44609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44611 if (!SWIG_IsOK(res1)) {
44612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44613 }
44614 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44615 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44616 if (!SWIG_IsOK(ecode2)) {
44617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
44618 }
44619 arg2 = static_cast< size_t >(val2);
44620 {
44621 PyThreadState* __tstate = wxPyBeginAllowThreads();
44622 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
44623 wxPyEndAllowThreads(__tstate);
44624 if (PyErr_Occurred()) SWIG_fail;
44625 }
44626 {
44627 resultobj = wxPyMake_wxObject(result, 0);
44628 }
44629 return resultobj;
44630 fail:
44631 return NULL;
44632 }
44633
44634
44635 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44636 PyObject *resultobj = 0;
44637 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44638 size_t arg2 ;
44639 wxMenu *arg3 = (wxMenu *) 0 ;
44640 wxString *arg4 = 0 ;
44641 wxMenu *result = 0 ;
44642 void *argp1 = 0 ;
44643 int res1 = 0 ;
44644 size_t val2 ;
44645 int ecode2 = 0 ;
44646 void *argp3 = 0 ;
44647 int res3 = 0 ;
44648 bool temp4 = false ;
44649 PyObject * obj0 = 0 ;
44650 PyObject * obj1 = 0 ;
44651 PyObject * obj2 = 0 ;
44652 PyObject * obj3 = 0 ;
44653 char * kwnames[] = {
44654 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44655 };
44656
44657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44659 if (!SWIG_IsOK(res1)) {
44660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44661 }
44662 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44663 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44664 if (!SWIG_IsOK(ecode2)) {
44665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
44666 }
44667 arg2 = static_cast< size_t >(val2);
44668 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44669 if (!SWIG_IsOK(res3)) {
44670 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
44671 }
44672 arg3 = reinterpret_cast< wxMenu * >(argp3);
44673 {
44674 arg4 = wxString_in_helper(obj3);
44675 if (arg4 == NULL) SWIG_fail;
44676 temp4 = true;
44677 }
44678 {
44679 PyThreadState* __tstate = wxPyBeginAllowThreads();
44680 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
44681 wxPyEndAllowThreads(__tstate);
44682 if (PyErr_Occurred()) SWIG_fail;
44683 }
44684 {
44685 resultobj = wxPyMake_wxObject(result, 0);
44686 }
44687 {
44688 if (temp4)
44689 delete arg4;
44690 }
44691 return resultobj;
44692 fail:
44693 {
44694 if (temp4)
44695 delete arg4;
44696 }
44697 return NULL;
44698 }
44699
44700
44701 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44702 PyObject *resultobj = 0;
44703 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44704 size_t arg2 ;
44705 wxMenu *result = 0 ;
44706 void *argp1 = 0 ;
44707 int res1 = 0 ;
44708 size_t val2 ;
44709 int ecode2 = 0 ;
44710 PyObject * obj0 = 0 ;
44711 PyObject * obj1 = 0 ;
44712 char * kwnames[] = {
44713 (char *) "self",(char *) "pos", NULL
44714 };
44715
44716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
44717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44718 if (!SWIG_IsOK(res1)) {
44719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44720 }
44721 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44722 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44723 if (!SWIG_IsOK(ecode2)) {
44724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
44725 }
44726 arg2 = static_cast< size_t >(val2);
44727 {
44728 PyThreadState* __tstate = wxPyBeginAllowThreads();
44729 result = (wxMenu *)(arg1)->Remove(arg2);
44730 wxPyEndAllowThreads(__tstate);
44731 if (PyErr_Occurred()) SWIG_fail;
44732 }
44733 {
44734 resultobj = wxPyMake_wxObject(result, 0);
44735 }
44736 return resultobj;
44737 fail:
44738 return NULL;
44739 }
44740
44741
44742 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44743 PyObject *resultobj = 0;
44744 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44745 size_t arg2 ;
44746 bool arg3 ;
44747 void *argp1 = 0 ;
44748 int res1 = 0 ;
44749 size_t val2 ;
44750 int ecode2 = 0 ;
44751 bool val3 ;
44752 int ecode3 = 0 ;
44753 PyObject * obj0 = 0 ;
44754 PyObject * obj1 = 0 ;
44755 PyObject * obj2 = 0 ;
44756 char * kwnames[] = {
44757 (char *) "self",(char *) "pos",(char *) "enable", NULL
44758 };
44759
44760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44762 if (!SWIG_IsOK(res1)) {
44763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44764 }
44765 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44766 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44767 if (!SWIG_IsOK(ecode2)) {
44768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
44769 }
44770 arg2 = static_cast< size_t >(val2);
44771 ecode3 = SWIG_AsVal_bool(obj2, &val3);
44772 if (!SWIG_IsOK(ecode3)) {
44773 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
44774 }
44775 arg3 = static_cast< bool >(val3);
44776 {
44777 PyThreadState* __tstate = wxPyBeginAllowThreads();
44778 (arg1)->EnableTop(arg2,arg3);
44779 wxPyEndAllowThreads(__tstate);
44780 if (PyErr_Occurred()) SWIG_fail;
44781 }
44782 resultobj = SWIG_Py_Void();
44783 return resultobj;
44784 fail:
44785 return NULL;
44786 }
44787
44788
44789 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44790 PyObject *resultobj = 0;
44791 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44792 size_t arg2 ;
44793 bool result;
44794 void *argp1 = 0 ;
44795 int res1 = 0 ;
44796 size_t val2 ;
44797 int ecode2 = 0 ;
44798 PyObject * obj0 = 0 ;
44799 PyObject * obj1 = 0 ;
44800 char * kwnames[] = {
44801 (char *) "self",(char *) "pos", NULL
44802 };
44803
44804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
44805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44806 if (!SWIG_IsOK(res1)) {
44807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44808 }
44809 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44810 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44811 if (!SWIG_IsOK(ecode2)) {
44812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
44813 }
44814 arg2 = static_cast< size_t >(val2);
44815 {
44816 PyThreadState* __tstate = wxPyBeginAllowThreads();
44817 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
44818 wxPyEndAllowThreads(__tstate);
44819 if (PyErr_Occurred()) SWIG_fail;
44820 }
44821 {
44822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44823 }
44824 return resultobj;
44825 fail:
44826 return NULL;
44827 }
44828
44829
44830 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44831 PyObject *resultobj = 0;
44832 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44833 size_t arg2 ;
44834 wxString *arg3 = 0 ;
44835 void *argp1 = 0 ;
44836 int res1 = 0 ;
44837 size_t val2 ;
44838 int ecode2 = 0 ;
44839 bool temp3 = false ;
44840 PyObject * obj0 = 0 ;
44841 PyObject * obj1 = 0 ;
44842 PyObject * obj2 = 0 ;
44843 char * kwnames[] = {
44844 (char *) "self",(char *) "pos",(char *) "label", NULL
44845 };
44846
44847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44849 if (!SWIG_IsOK(res1)) {
44850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44851 }
44852 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44853 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44854 if (!SWIG_IsOK(ecode2)) {
44855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
44856 }
44857 arg2 = static_cast< size_t >(val2);
44858 {
44859 arg3 = wxString_in_helper(obj2);
44860 if (arg3 == NULL) SWIG_fail;
44861 temp3 = true;
44862 }
44863 {
44864 PyThreadState* __tstate = wxPyBeginAllowThreads();
44865 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
44866 wxPyEndAllowThreads(__tstate);
44867 if (PyErr_Occurred()) SWIG_fail;
44868 }
44869 resultobj = SWIG_Py_Void();
44870 {
44871 if (temp3)
44872 delete arg3;
44873 }
44874 return resultobj;
44875 fail:
44876 {
44877 if (temp3)
44878 delete arg3;
44879 }
44880 return NULL;
44881 }
44882
44883
44884 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44885 PyObject *resultobj = 0;
44886 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44887 size_t arg2 ;
44888 wxString result;
44889 void *argp1 = 0 ;
44890 int res1 = 0 ;
44891 size_t val2 ;
44892 int ecode2 = 0 ;
44893 PyObject * obj0 = 0 ;
44894 PyObject * obj1 = 0 ;
44895 char * kwnames[] = {
44896 (char *) "self",(char *) "pos", NULL
44897 };
44898
44899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
44900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44901 if (!SWIG_IsOK(res1)) {
44902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44903 }
44904 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44905 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44906 if (!SWIG_IsOK(ecode2)) {
44907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
44908 }
44909 arg2 = static_cast< size_t >(val2);
44910 {
44911 PyThreadState* __tstate = wxPyBeginAllowThreads();
44912 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
44913 wxPyEndAllowThreads(__tstate);
44914 if (PyErr_Occurred()) SWIG_fail;
44915 }
44916 {
44917 #if wxUSE_UNICODE
44918 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44919 #else
44920 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44921 #endif
44922 }
44923 return resultobj;
44924 fail:
44925 return NULL;
44926 }
44927
44928
44929 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44930 PyObject *resultobj = 0;
44931 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44932 wxString *arg2 = 0 ;
44933 wxString *arg3 = 0 ;
44934 int result;
44935 void *argp1 = 0 ;
44936 int res1 = 0 ;
44937 bool temp2 = false ;
44938 bool temp3 = false ;
44939 PyObject * obj0 = 0 ;
44940 PyObject * obj1 = 0 ;
44941 PyObject * obj2 = 0 ;
44942 char * kwnames[] = {
44943 (char *) "self",(char *) "menu",(char *) "item", NULL
44944 };
44945
44946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44948 if (!SWIG_IsOK(res1)) {
44949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44950 }
44951 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44952 {
44953 arg2 = wxString_in_helper(obj1);
44954 if (arg2 == NULL) SWIG_fail;
44955 temp2 = true;
44956 }
44957 {
44958 arg3 = wxString_in_helper(obj2);
44959 if (arg3 == NULL) SWIG_fail;
44960 temp3 = true;
44961 }
44962 {
44963 PyThreadState* __tstate = wxPyBeginAllowThreads();
44964 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
44965 wxPyEndAllowThreads(__tstate);
44966 if (PyErr_Occurred()) SWIG_fail;
44967 }
44968 resultobj = SWIG_From_int(static_cast< int >(result));
44969 {
44970 if (temp2)
44971 delete arg2;
44972 }
44973 {
44974 if (temp3)
44975 delete arg3;
44976 }
44977 return resultobj;
44978 fail:
44979 {
44980 if (temp2)
44981 delete arg2;
44982 }
44983 {
44984 if (temp3)
44985 delete arg3;
44986 }
44987 return NULL;
44988 }
44989
44990
44991 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44992 PyObject *resultobj = 0;
44993 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44994 int arg2 ;
44995 wxMenuItem *result = 0 ;
44996 void *argp1 = 0 ;
44997 int res1 = 0 ;
44998 int val2 ;
44999 int ecode2 = 0 ;
45000 PyObject * obj0 = 0 ;
45001 PyObject * obj1 = 0 ;
45002 char * kwnames[] = {
45003 (char *) "self",(char *) "id", NULL
45004 };
45005
45006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
45007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45008 if (!SWIG_IsOK(res1)) {
45009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45010 }
45011 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45012 ecode2 = SWIG_AsVal_int(obj1, &val2);
45013 if (!SWIG_IsOK(ecode2)) {
45014 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
45015 }
45016 arg2 = static_cast< int >(val2);
45017 {
45018 PyThreadState* __tstate = wxPyBeginAllowThreads();
45019 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
45020 wxPyEndAllowThreads(__tstate);
45021 if (PyErr_Occurred()) SWIG_fail;
45022 }
45023 {
45024 resultobj = wxPyMake_wxObject(result, (bool)0);
45025 }
45026 return resultobj;
45027 fail:
45028 return NULL;
45029 }
45030
45031
45032 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45033 PyObject *resultobj = 0;
45034 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45035 wxString *arg2 = 0 ;
45036 int result;
45037 void *argp1 = 0 ;
45038 int res1 = 0 ;
45039 bool temp2 = false ;
45040 PyObject * obj0 = 0 ;
45041 PyObject * obj1 = 0 ;
45042 char * kwnames[] = {
45043 (char *) "self",(char *) "title", NULL
45044 };
45045
45046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45048 if (!SWIG_IsOK(res1)) {
45049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45050 }
45051 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45052 {
45053 arg2 = wxString_in_helper(obj1);
45054 if (arg2 == NULL) SWIG_fail;
45055 temp2 = true;
45056 }
45057 {
45058 PyThreadState* __tstate = wxPyBeginAllowThreads();
45059 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
45060 wxPyEndAllowThreads(__tstate);
45061 if (PyErr_Occurred()) SWIG_fail;
45062 }
45063 resultobj = SWIG_From_int(static_cast< int >(result));
45064 {
45065 if (temp2)
45066 delete arg2;
45067 }
45068 return resultobj;
45069 fail:
45070 {
45071 if (temp2)
45072 delete arg2;
45073 }
45074 return NULL;
45075 }
45076
45077
45078 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45079 PyObject *resultobj = 0;
45080 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45081 int arg2 ;
45082 bool arg3 ;
45083 void *argp1 = 0 ;
45084 int res1 = 0 ;
45085 int val2 ;
45086 int ecode2 = 0 ;
45087 bool val3 ;
45088 int ecode3 = 0 ;
45089 PyObject * obj0 = 0 ;
45090 PyObject * obj1 = 0 ;
45091 PyObject * obj2 = 0 ;
45092 char * kwnames[] = {
45093 (char *) "self",(char *) "id",(char *) "enable", NULL
45094 };
45095
45096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45098 if (!SWIG_IsOK(res1)) {
45099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45100 }
45101 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45102 ecode2 = SWIG_AsVal_int(obj1, &val2);
45103 if (!SWIG_IsOK(ecode2)) {
45104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
45105 }
45106 arg2 = static_cast< int >(val2);
45107 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45108 if (!SWIG_IsOK(ecode3)) {
45109 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
45110 }
45111 arg3 = static_cast< bool >(val3);
45112 {
45113 PyThreadState* __tstate = wxPyBeginAllowThreads();
45114 (arg1)->Enable(arg2,arg3);
45115 wxPyEndAllowThreads(__tstate);
45116 if (PyErr_Occurred()) SWIG_fail;
45117 }
45118 resultobj = SWIG_Py_Void();
45119 return resultobj;
45120 fail:
45121 return NULL;
45122 }
45123
45124
45125 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45126 PyObject *resultobj = 0;
45127 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45128 int arg2 ;
45129 bool arg3 ;
45130 void *argp1 = 0 ;
45131 int res1 = 0 ;
45132 int val2 ;
45133 int ecode2 = 0 ;
45134 bool val3 ;
45135 int ecode3 = 0 ;
45136 PyObject * obj0 = 0 ;
45137 PyObject * obj1 = 0 ;
45138 PyObject * obj2 = 0 ;
45139 char * kwnames[] = {
45140 (char *) "self",(char *) "id",(char *) "check", NULL
45141 };
45142
45143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45145 if (!SWIG_IsOK(res1)) {
45146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45147 }
45148 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45149 ecode2 = SWIG_AsVal_int(obj1, &val2);
45150 if (!SWIG_IsOK(ecode2)) {
45151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
45152 }
45153 arg2 = static_cast< int >(val2);
45154 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45155 if (!SWIG_IsOK(ecode3)) {
45156 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
45157 }
45158 arg3 = static_cast< bool >(val3);
45159 {
45160 PyThreadState* __tstate = wxPyBeginAllowThreads();
45161 (arg1)->Check(arg2,arg3);
45162 wxPyEndAllowThreads(__tstate);
45163 if (PyErr_Occurred()) SWIG_fail;
45164 }
45165 resultobj = SWIG_Py_Void();
45166 return resultobj;
45167 fail:
45168 return NULL;
45169 }
45170
45171
45172 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45173 PyObject *resultobj = 0;
45174 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45175 int arg2 ;
45176 bool result;
45177 void *argp1 = 0 ;
45178 int res1 = 0 ;
45179 int val2 ;
45180 int ecode2 = 0 ;
45181 PyObject * obj0 = 0 ;
45182 PyObject * obj1 = 0 ;
45183 char * kwnames[] = {
45184 (char *) "self",(char *) "id", NULL
45185 };
45186
45187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
45188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45189 if (!SWIG_IsOK(res1)) {
45190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45191 }
45192 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45193 ecode2 = SWIG_AsVal_int(obj1, &val2);
45194 if (!SWIG_IsOK(ecode2)) {
45195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
45196 }
45197 arg2 = static_cast< int >(val2);
45198 {
45199 PyThreadState* __tstate = wxPyBeginAllowThreads();
45200 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
45201 wxPyEndAllowThreads(__tstate);
45202 if (PyErr_Occurred()) SWIG_fail;
45203 }
45204 {
45205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45206 }
45207 return resultobj;
45208 fail:
45209 return NULL;
45210 }
45211
45212
45213 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45214 PyObject *resultobj = 0;
45215 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45216 int arg2 ;
45217 bool result;
45218 void *argp1 = 0 ;
45219 int res1 = 0 ;
45220 int val2 ;
45221 int ecode2 = 0 ;
45222 PyObject * obj0 = 0 ;
45223 PyObject * obj1 = 0 ;
45224 char * kwnames[] = {
45225 (char *) "self",(char *) "id", NULL
45226 };
45227
45228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
45229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45230 if (!SWIG_IsOK(res1)) {
45231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45232 }
45233 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45234 ecode2 = SWIG_AsVal_int(obj1, &val2);
45235 if (!SWIG_IsOK(ecode2)) {
45236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
45237 }
45238 arg2 = static_cast< int >(val2);
45239 {
45240 PyThreadState* __tstate = wxPyBeginAllowThreads();
45241 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
45242 wxPyEndAllowThreads(__tstate);
45243 if (PyErr_Occurred()) SWIG_fail;
45244 }
45245 {
45246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45247 }
45248 return resultobj;
45249 fail:
45250 return NULL;
45251 }
45252
45253
45254 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45255 PyObject *resultobj = 0;
45256 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45257 int arg2 ;
45258 wxString *arg3 = 0 ;
45259 void *argp1 = 0 ;
45260 int res1 = 0 ;
45261 int val2 ;
45262 int ecode2 = 0 ;
45263 bool temp3 = false ;
45264 PyObject * obj0 = 0 ;
45265 PyObject * obj1 = 0 ;
45266 PyObject * obj2 = 0 ;
45267 char * kwnames[] = {
45268 (char *) "self",(char *) "id",(char *) "label", NULL
45269 };
45270
45271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45273 if (!SWIG_IsOK(res1)) {
45274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45275 }
45276 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45277 ecode2 = SWIG_AsVal_int(obj1, &val2);
45278 if (!SWIG_IsOK(ecode2)) {
45279 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
45280 }
45281 arg2 = static_cast< int >(val2);
45282 {
45283 arg3 = wxString_in_helper(obj2);
45284 if (arg3 == NULL) SWIG_fail;
45285 temp3 = true;
45286 }
45287 {
45288 PyThreadState* __tstate = wxPyBeginAllowThreads();
45289 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
45290 wxPyEndAllowThreads(__tstate);
45291 if (PyErr_Occurred()) SWIG_fail;
45292 }
45293 resultobj = SWIG_Py_Void();
45294 {
45295 if (temp3)
45296 delete arg3;
45297 }
45298 return resultobj;
45299 fail:
45300 {
45301 if (temp3)
45302 delete arg3;
45303 }
45304 return NULL;
45305 }
45306
45307
45308 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45309 PyObject *resultobj = 0;
45310 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45311 int arg2 ;
45312 wxString result;
45313 void *argp1 = 0 ;
45314 int res1 = 0 ;
45315 int val2 ;
45316 int ecode2 = 0 ;
45317 PyObject * obj0 = 0 ;
45318 PyObject * obj1 = 0 ;
45319 char * kwnames[] = {
45320 (char *) "self",(char *) "id", NULL
45321 };
45322
45323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
45324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45325 if (!SWIG_IsOK(res1)) {
45326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45327 }
45328 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45329 ecode2 = SWIG_AsVal_int(obj1, &val2);
45330 if (!SWIG_IsOK(ecode2)) {
45331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
45332 }
45333 arg2 = static_cast< int >(val2);
45334 {
45335 PyThreadState* __tstate = wxPyBeginAllowThreads();
45336 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
45337 wxPyEndAllowThreads(__tstate);
45338 if (PyErr_Occurred()) SWIG_fail;
45339 }
45340 {
45341 #if wxUSE_UNICODE
45342 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45343 #else
45344 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45345 #endif
45346 }
45347 return resultobj;
45348 fail:
45349 return NULL;
45350 }
45351
45352
45353 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45354 PyObject *resultobj = 0;
45355 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45356 int arg2 ;
45357 wxString *arg3 = 0 ;
45358 void *argp1 = 0 ;
45359 int res1 = 0 ;
45360 int val2 ;
45361 int ecode2 = 0 ;
45362 bool temp3 = false ;
45363 PyObject * obj0 = 0 ;
45364 PyObject * obj1 = 0 ;
45365 PyObject * obj2 = 0 ;
45366 char * kwnames[] = {
45367 (char *) "self",(char *) "id",(char *) "helpString", NULL
45368 };
45369
45370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45372 if (!SWIG_IsOK(res1)) {
45373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45374 }
45375 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45376 ecode2 = SWIG_AsVal_int(obj1, &val2);
45377 if (!SWIG_IsOK(ecode2)) {
45378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
45379 }
45380 arg2 = static_cast< int >(val2);
45381 {
45382 arg3 = wxString_in_helper(obj2);
45383 if (arg3 == NULL) SWIG_fail;
45384 temp3 = true;
45385 }
45386 {
45387 PyThreadState* __tstate = wxPyBeginAllowThreads();
45388 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
45389 wxPyEndAllowThreads(__tstate);
45390 if (PyErr_Occurred()) SWIG_fail;
45391 }
45392 resultobj = SWIG_Py_Void();
45393 {
45394 if (temp3)
45395 delete arg3;
45396 }
45397 return resultobj;
45398 fail:
45399 {
45400 if (temp3)
45401 delete arg3;
45402 }
45403 return NULL;
45404 }
45405
45406
45407 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45408 PyObject *resultobj = 0;
45409 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45410 int arg2 ;
45411 wxString result;
45412 void *argp1 = 0 ;
45413 int res1 = 0 ;
45414 int val2 ;
45415 int ecode2 = 0 ;
45416 PyObject * obj0 = 0 ;
45417 PyObject * obj1 = 0 ;
45418 char * kwnames[] = {
45419 (char *) "self",(char *) "id", NULL
45420 };
45421
45422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
45423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45424 if (!SWIG_IsOK(res1)) {
45425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45426 }
45427 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45428 ecode2 = SWIG_AsVal_int(obj1, &val2);
45429 if (!SWIG_IsOK(ecode2)) {
45430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
45431 }
45432 arg2 = static_cast< int >(val2);
45433 {
45434 PyThreadState* __tstate = wxPyBeginAllowThreads();
45435 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
45436 wxPyEndAllowThreads(__tstate);
45437 if (PyErr_Occurred()) SWIG_fail;
45438 }
45439 {
45440 #if wxUSE_UNICODE
45441 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45442 #else
45443 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45444 #endif
45445 }
45446 return resultobj;
45447 fail:
45448 return NULL;
45449 }
45450
45451
45452 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45453 PyObject *resultobj = 0;
45454 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45455 wxFrame *result = 0 ;
45456 void *argp1 = 0 ;
45457 int res1 = 0 ;
45458 PyObject *swig_obj[1] ;
45459
45460 if (!args) SWIG_fail;
45461 swig_obj[0] = args;
45462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45463 if (!SWIG_IsOK(res1)) {
45464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45465 }
45466 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45467 {
45468 PyThreadState* __tstate = wxPyBeginAllowThreads();
45469 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
45470 wxPyEndAllowThreads(__tstate);
45471 if (PyErr_Occurred()) SWIG_fail;
45472 }
45473 {
45474 resultobj = wxPyMake_wxObject(result, (bool)0);
45475 }
45476 return resultobj;
45477 fail:
45478 return NULL;
45479 }
45480
45481
45482 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45483 PyObject *resultobj = 0;
45484 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45485 bool result;
45486 void *argp1 = 0 ;
45487 int res1 = 0 ;
45488 PyObject *swig_obj[1] ;
45489
45490 if (!args) SWIG_fail;
45491 swig_obj[0] = args;
45492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45493 if (!SWIG_IsOK(res1)) {
45494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45495 }
45496 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45497 {
45498 PyThreadState* __tstate = wxPyBeginAllowThreads();
45499 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
45500 wxPyEndAllowThreads(__tstate);
45501 if (PyErr_Occurred()) SWIG_fail;
45502 }
45503 {
45504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45505 }
45506 return resultobj;
45507 fail:
45508 return NULL;
45509 }
45510
45511
45512 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45513 PyObject *resultobj = 0;
45514 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45515 wxFrame *arg2 = (wxFrame *) 0 ;
45516 void *argp1 = 0 ;
45517 int res1 = 0 ;
45518 void *argp2 = 0 ;
45519 int res2 = 0 ;
45520 PyObject * obj0 = 0 ;
45521 PyObject * obj1 = 0 ;
45522 char * kwnames[] = {
45523 (char *) "self",(char *) "frame", NULL
45524 };
45525
45526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
45527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45528 if (!SWIG_IsOK(res1)) {
45529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45530 }
45531 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45532 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
45533 if (!SWIG_IsOK(res2)) {
45534 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
45535 }
45536 arg2 = reinterpret_cast< wxFrame * >(argp2);
45537 {
45538 PyThreadState* __tstate = wxPyBeginAllowThreads();
45539 (arg1)->Attach(arg2);
45540 wxPyEndAllowThreads(__tstate);
45541 if (PyErr_Occurred()) SWIG_fail;
45542 }
45543 resultobj = SWIG_Py_Void();
45544 return resultobj;
45545 fail:
45546 return NULL;
45547 }
45548
45549
45550 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45551 PyObject *resultobj = 0;
45552 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45553 void *argp1 = 0 ;
45554 int res1 = 0 ;
45555 PyObject *swig_obj[1] ;
45556
45557 if (!args) SWIG_fail;
45558 swig_obj[0] = args;
45559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45560 if (!SWIG_IsOK(res1)) {
45561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45562 }
45563 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45564 {
45565 PyThreadState* __tstate = wxPyBeginAllowThreads();
45566 (arg1)->Detach();
45567 wxPyEndAllowThreads(__tstate);
45568 if (PyErr_Occurred()) SWIG_fail;
45569 }
45570 resultobj = SWIG_Py_Void();
45571 return resultobj;
45572 fail:
45573 return NULL;
45574 }
45575
45576
45577 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45578 PyObject *resultobj = 0;
45579 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45580 void *argp1 = 0 ;
45581 int res1 = 0 ;
45582 PyObject *swig_obj[1] ;
45583
45584 if (!args) SWIG_fail;
45585 swig_obj[0] = args;
45586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45587 if (!SWIG_IsOK(res1)) {
45588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45589 }
45590 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45591 {
45592 PyThreadState* __tstate = wxPyBeginAllowThreads();
45593 (arg1)->UpdateMenus();
45594 wxPyEndAllowThreads(__tstate);
45595 if (PyErr_Occurred()) SWIG_fail;
45596 }
45597 resultobj = SWIG_Py_Void();
45598 return resultobj;
45599 fail:
45600 return NULL;
45601 }
45602
45603
45604 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45605 PyObject *resultobj = 0;
45606 bool arg1 ;
45607 bool val1 ;
45608 int ecode1 = 0 ;
45609 PyObject * obj0 = 0 ;
45610 char * kwnames[] = {
45611 (char *) "enable", NULL
45612 };
45613
45614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
45615 ecode1 = SWIG_AsVal_bool(obj0, &val1);
45616 if (!SWIG_IsOK(ecode1)) {
45617 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
45618 }
45619 arg1 = static_cast< bool >(val1);
45620 {
45621 PyThreadState* __tstate = wxPyBeginAllowThreads();
45622 wxMenuBar_SetAutoWindowMenu(arg1);
45623 wxPyEndAllowThreads(__tstate);
45624 if (PyErr_Occurred()) SWIG_fail;
45625 }
45626 resultobj = SWIG_Py_Void();
45627 return resultobj;
45628 fail:
45629 return NULL;
45630 }
45631
45632
45633 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45634 PyObject *resultobj = 0;
45635 bool result;
45636
45637 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
45638 {
45639 PyThreadState* __tstate = wxPyBeginAllowThreads();
45640 result = (bool)wxMenuBar_GetAutoWindowMenu();
45641 wxPyEndAllowThreads(__tstate);
45642 if (PyErr_Occurred()) SWIG_fail;
45643 }
45644 {
45645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45646 }
45647 return resultobj;
45648 fail:
45649 return NULL;
45650 }
45651
45652
45653 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45654 PyObject *obj;
45655 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45656 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
45657 return SWIG_Py_Void();
45658 }
45659
45660 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45661 return SWIG_Python_InitShadowInstance(args);
45662 }
45663
45664 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45665 PyObject *resultobj = 0;
45666 wxMenu *arg1 = (wxMenu *) NULL ;
45667 int arg2 = (int) wxID_ANY ;
45668 wxString const &arg3_defvalue = wxPyEmptyString ;
45669 wxString *arg3 = (wxString *) &arg3_defvalue ;
45670 wxString const &arg4_defvalue = wxPyEmptyString ;
45671 wxString *arg4 = (wxString *) &arg4_defvalue ;
45672 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
45673 wxMenu *arg6 = (wxMenu *) NULL ;
45674 wxMenuItem *result = 0 ;
45675 void *argp1 = 0 ;
45676 int res1 = 0 ;
45677 int val2 ;
45678 int ecode2 = 0 ;
45679 bool temp3 = false ;
45680 bool temp4 = false ;
45681 int val5 ;
45682 int ecode5 = 0 ;
45683 void *argp6 = 0 ;
45684 int res6 = 0 ;
45685 PyObject * obj0 = 0 ;
45686 PyObject * obj1 = 0 ;
45687 PyObject * obj2 = 0 ;
45688 PyObject * obj3 = 0 ;
45689 PyObject * obj4 = 0 ;
45690 PyObject * obj5 = 0 ;
45691 char * kwnames[] = {
45692 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
45693 };
45694
45695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45696 if (obj0) {
45697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45698 if (!SWIG_IsOK(res1)) {
45699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
45700 }
45701 arg1 = reinterpret_cast< wxMenu * >(argp1);
45702 }
45703 if (obj1) {
45704 ecode2 = SWIG_AsVal_int(obj1, &val2);
45705 if (!SWIG_IsOK(ecode2)) {
45706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
45707 }
45708 arg2 = static_cast< int >(val2);
45709 }
45710 if (obj2) {
45711 {
45712 arg3 = wxString_in_helper(obj2);
45713 if (arg3 == NULL) SWIG_fail;
45714 temp3 = true;
45715 }
45716 }
45717 if (obj3) {
45718 {
45719 arg4 = wxString_in_helper(obj3);
45720 if (arg4 == NULL) SWIG_fail;
45721 temp4 = true;
45722 }
45723 }
45724 if (obj4) {
45725 ecode5 = SWIG_AsVal_int(obj4, &val5);
45726 if (!SWIG_IsOK(ecode5)) {
45727 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
45728 }
45729 arg5 = static_cast< wxItemKind >(val5);
45730 }
45731 if (obj5) {
45732 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
45733 if (!SWIG_IsOK(res6)) {
45734 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
45735 }
45736 arg6 = reinterpret_cast< wxMenu * >(argp6);
45737 }
45738 {
45739 PyThreadState* __tstate = wxPyBeginAllowThreads();
45740 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
45741 wxPyEndAllowThreads(__tstate);
45742 if (PyErr_Occurred()) SWIG_fail;
45743 }
45744 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_NEW | 0 );
45745 {
45746 if (temp3)
45747 delete arg3;
45748 }
45749 {
45750 if (temp4)
45751 delete arg4;
45752 }
45753 return resultobj;
45754 fail:
45755 {
45756 if (temp3)
45757 delete arg3;
45758 }
45759 {
45760 if (temp4)
45761 delete arg4;
45762 }
45763 return NULL;
45764 }
45765
45766
45767 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45768 PyObject *resultobj = 0;
45769 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45770 void *argp1 = 0 ;
45771 int res1 = 0 ;
45772 PyObject *swig_obj[1] ;
45773
45774 if (!args) SWIG_fail;
45775 swig_obj[0] = args;
45776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
45777 if (!SWIG_IsOK(res1)) {
45778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45779 }
45780 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45781 {
45782 PyThreadState* __tstate = wxPyBeginAllowThreads();
45783 delete arg1;
45784
45785 wxPyEndAllowThreads(__tstate);
45786 if (PyErr_Occurred()) SWIG_fail;
45787 }
45788 resultobj = SWIG_Py_Void();
45789 return resultobj;
45790 fail:
45791 return NULL;
45792 }
45793
45794
45795 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45796 PyObject *resultobj = 0;
45797 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45798 wxMenu *result = 0 ;
45799 void *argp1 = 0 ;
45800 int res1 = 0 ;
45801 PyObject *swig_obj[1] ;
45802
45803 if (!args) SWIG_fail;
45804 swig_obj[0] = args;
45805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45806 if (!SWIG_IsOK(res1)) {
45807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45808 }
45809 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45810 {
45811 PyThreadState* __tstate = wxPyBeginAllowThreads();
45812 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
45813 wxPyEndAllowThreads(__tstate);
45814 if (PyErr_Occurred()) SWIG_fail;
45815 }
45816 {
45817 resultobj = wxPyMake_wxObject(result, 0);
45818 }
45819 return resultobj;
45820 fail:
45821 return NULL;
45822 }
45823
45824
45825 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45826 PyObject *resultobj = 0;
45827 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45828 wxMenu *arg2 = (wxMenu *) 0 ;
45829 void *argp1 = 0 ;
45830 int res1 = 0 ;
45831 void *argp2 = 0 ;
45832 int res2 = 0 ;
45833 PyObject * obj0 = 0 ;
45834 PyObject * obj1 = 0 ;
45835 char * kwnames[] = {
45836 (char *) "self",(char *) "menu", NULL
45837 };
45838
45839 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45840 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45841 if (!SWIG_IsOK(res1)) {
45842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45843 }
45844 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45845 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
45846 if (!SWIG_IsOK(res2)) {
45847 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
45848 }
45849 arg2 = reinterpret_cast< wxMenu * >(argp2);
45850 {
45851 PyThreadState* __tstate = wxPyBeginAllowThreads();
45852 (arg1)->SetMenu(arg2);
45853 wxPyEndAllowThreads(__tstate);
45854 if (PyErr_Occurred()) SWIG_fail;
45855 }
45856 resultobj = SWIG_Py_Void();
45857 return resultobj;
45858 fail:
45859 return NULL;
45860 }
45861
45862
45863 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45864 PyObject *resultobj = 0;
45865 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45866 int arg2 ;
45867 void *argp1 = 0 ;
45868 int res1 = 0 ;
45869 int val2 ;
45870 int ecode2 = 0 ;
45871 PyObject * obj0 = 0 ;
45872 PyObject * obj1 = 0 ;
45873 char * kwnames[] = {
45874 (char *) "self",(char *) "id", NULL
45875 };
45876
45877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
45878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45879 if (!SWIG_IsOK(res1)) {
45880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45881 }
45882 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45883 ecode2 = SWIG_AsVal_int(obj1, &val2);
45884 if (!SWIG_IsOK(ecode2)) {
45885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
45886 }
45887 arg2 = static_cast< int >(val2);
45888 {
45889 PyThreadState* __tstate = wxPyBeginAllowThreads();
45890 (arg1)->SetId(arg2);
45891 wxPyEndAllowThreads(__tstate);
45892 if (PyErr_Occurred()) SWIG_fail;
45893 }
45894 resultobj = SWIG_Py_Void();
45895 return resultobj;
45896 fail:
45897 return NULL;
45898 }
45899
45900
45901 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45902 PyObject *resultobj = 0;
45903 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45904 int result;
45905 void *argp1 = 0 ;
45906 int res1 = 0 ;
45907 PyObject *swig_obj[1] ;
45908
45909 if (!args) SWIG_fail;
45910 swig_obj[0] = args;
45911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45912 if (!SWIG_IsOK(res1)) {
45913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45914 }
45915 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45916 {
45917 PyThreadState* __tstate = wxPyBeginAllowThreads();
45918 result = (int)((wxMenuItem const *)arg1)->GetId();
45919 wxPyEndAllowThreads(__tstate);
45920 if (PyErr_Occurred()) SWIG_fail;
45921 }
45922 resultobj = SWIG_From_int(static_cast< int >(result));
45923 return resultobj;
45924 fail:
45925 return NULL;
45926 }
45927
45928
45929 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45930 PyObject *resultobj = 0;
45931 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45932 bool result;
45933 void *argp1 = 0 ;
45934 int res1 = 0 ;
45935 PyObject *swig_obj[1] ;
45936
45937 if (!args) SWIG_fail;
45938 swig_obj[0] = args;
45939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45940 if (!SWIG_IsOK(res1)) {
45941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45942 }
45943 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45944 {
45945 PyThreadState* __tstate = wxPyBeginAllowThreads();
45946 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
45947 wxPyEndAllowThreads(__tstate);
45948 if (PyErr_Occurred()) SWIG_fail;
45949 }
45950 {
45951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45952 }
45953 return resultobj;
45954 fail:
45955 return NULL;
45956 }
45957
45958
45959 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45960 PyObject *resultobj = 0;
45961 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45962 wxString *arg2 = 0 ;
45963 void *argp1 = 0 ;
45964 int res1 = 0 ;
45965 bool temp2 = false ;
45966 PyObject * obj0 = 0 ;
45967 PyObject * obj1 = 0 ;
45968 char * kwnames[] = {
45969 (char *) "self",(char *) "str", NULL
45970 };
45971
45972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
45973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45974 if (!SWIG_IsOK(res1)) {
45975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45976 }
45977 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45978 {
45979 arg2 = wxString_in_helper(obj1);
45980 if (arg2 == NULL) SWIG_fail;
45981 temp2 = true;
45982 }
45983 {
45984 PyThreadState* __tstate = wxPyBeginAllowThreads();
45985 (arg1)->SetText((wxString const &)*arg2);
45986 wxPyEndAllowThreads(__tstate);
45987 if (PyErr_Occurred()) SWIG_fail;
45988 }
45989 resultobj = SWIG_Py_Void();
45990 {
45991 if (temp2)
45992 delete arg2;
45993 }
45994 return resultobj;
45995 fail:
45996 {
45997 if (temp2)
45998 delete arg2;
45999 }
46000 return NULL;
46001 }
46002
46003
46004 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46005 PyObject *resultobj = 0;
46006 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46007 wxString result;
46008 void *argp1 = 0 ;
46009 int res1 = 0 ;
46010 PyObject *swig_obj[1] ;
46011
46012 if (!args) SWIG_fail;
46013 swig_obj[0] = args;
46014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46015 if (!SWIG_IsOK(res1)) {
46016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46017 }
46018 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46019 {
46020 PyThreadState* __tstate = wxPyBeginAllowThreads();
46021 result = ((wxMenuItem const *)arg1)->GetLabel();
46022 wxPyEndAllowThreads(__tstate);
46023 if (PyErr_Occurred()) SWIG_fail;
46024 }
46025 {
46026 #if wxUSE_UNICODE
46027 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46028 #else
46029 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46030 #endif
46031 }
46032 return resultobj;
46033 fail:
46034 return NULL;
46035 }
46036
46037
46038 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46039 PyObject *resultobj = 0;
46040 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46041 wxString *result = 0 ;
46042 void *argp1 = 0 ;
46043 int res1 = 0 ;
46044 PyObject *swig_obj[1] ;
46045
46046 if (!args) SWIG_fail;
46047 swig_obj[0] = args;
46048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46049 if (!SWIG_IsOK(res1)) {
46050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46051 }
46052 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46053 {
46054 PyThreadState* __tstate = wxPyBeginAllowThreads();
46055 {
46056 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
46057 result = (wxString *) &_result_ref;
46058 }
46059 wxPyEndAllowThreads(__tstate);
46060 if (PyErr_Occurred()) SWIG_fail;
46061 }
46062 {
46063 #if wxUSE_UNICODE
46064 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46065 #else
46066 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46067 #endif
46068 }
46069 return resultobj;
46070 fail:
46071 return NULL;
46072 }
46073
46074
46075 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46076 PyObject *resultobj = 0;
46077 wxString *arg1 = 0 ;
46078 wxString result;
46079 bool temp1 = false ;
46080 PyObject * obj0 = 0 ;
46081 char * kwnames[] = {
46082 (char *) "text", NULL
46083 };
46084
46085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
46086 {
46087 arg1 = wxString_in_helper(obj0);
46088 if (arg1 == NULL) SWIG_fail;
46089 temp1 = true;
46090 }
46091 {
46092 PyThreadState* __tstate = wxPyBeginAllowThreads();
46093 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
46094 wxPyEndAllowThreads(__tstate);
46095 if (PyErr_Occurred()) SWIG_fail;
46096 }
46097 {
46098 #if wxUSE_UNICODE
46099 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46100 #else
46101 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46102 #endif
46103 }
46104 {
46105 if (temp1)
46106 delete arg1;
46107 }
46108 return resultobj;
46109 fail:
46110 {
46111 if (temp1)
46112 delete arg1;
46113 }
46114 return NULL;
46115 }
46116
46117
46118 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46119 PyObject *resultobj = 0;
46120 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46121 wxItemKind result;
46122 void *argp1 = 0 ;
46123 int res1 = 0 ;
46124 PyObject *swig_obj[1] ;
46125
46126 if (!args) SWIG_fail;
46127 swig_obj[0] = args;
46128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46129 if (!SWIG_IsOK(res1)) {
46130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46131 }
46132 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46133 {
46134 PyThreadState* __tstate = wxPyBeginAllowThreads();
46135 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
46136 wxPyEndAllowThreads(__tstate);
46137 if (PyErr_Occurred()) SWIG_fail;
46138 }
46139 resultobj = SWIG_From_int(static_cast< int >(result));
46140 return resultobj;
46141 fail:
46142 return NULL;
46143 }
46144
46145
46146 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46147 PyObject *resultobj = 0;
46148 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46149 wxItemKind arg2 ;
46150 void *argp1 = 0 ;
46151 int res1 = 0 ;
46152 int val2 ;
46153 int ecode2 = 0 ;
46154 PyObject * obj0 = 0 ;
46155 PyObject * obj1 = 0 ;
46156 char * kwnames[] = {
46157 (char *) "self",(char *) "kind", NULL
46158 };
46159
46160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
46161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46162 if (!SWIG_IsOK(res1)) {
46163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46164 }
46165 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46166 ecode2 = SWIG_AsVal_int(obj1, &val2);
46167 if (!SWIG_IsOK(ecode2)) {
46168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
46169 }
46170 arg2 = static_cast< wxItemKind >(val2);
46171 {
46172 PyThreadState* __tstate = wxPyBeginAllowThreads();
46173 (arg1)->SetKind(arg2);
46174 wxPyEndAllowThreads(__tstate);
46175 if (PyErr_Occurred()) SWIG_fail;
46176 }
46177 resultobj = SWIG_Py_Void();
46178 return resultobj;
46179 fail:
46180 return NULL;
46181 }
46182
46183
46184 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46185 PyObject *resultobj = 0;
46186 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46187 bool arg2 ;
46188 void *argp1 = 0 ;
46189 int res1 = 0 ;
46190 bool val2 ;
46191 int ecode2 = 0 ;
46192 PyObject * obj0 = 0 ;
46193 PyObject * obj1 = 0 ;
46194 char * kwnames[] = {
46195 (char *) "self",(char *) "checkable", NULL
46196 };
46197
46198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
46199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46200 if (!SWIG_IsOK(res1)) {
46201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46202 }
46203 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46204 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46205 if (!SWIG_IsOK(ecode2)) {
46206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
46207 }
46208 arg2 = static_cast< bool >(val2);
46209 {
46210 PyThreadState* __tstate = wxPyBeginAllowThreads();
46211 (arg1)->SetCheckable(arg2);
46212 wxPyEndAllowThreads(__tstate);
46213 if (PyErr_Occurred()) SWIG_fail;
46214 }
46215 resultobj = SWIG_Py_Void();
46216 return resultobj;
46217 fail:
46218 return NULL;
46219 }
46220
46221
46222 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46223 PyObject *resultobj = 0;
46224 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46225 bool result;
46226 void *argp1 = 0 ;
46227 int res1 = 0 ;
46228 PyObject *swig_obj[1] ;
46229
46230 if (!args) SWIG_fail;
46231 swig_obj[0] = args;
46232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46233 if (!SWIG_IsOK(res1)) {
46234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46235 }
46236 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46237 {
46238 PyThreadState* __tstate = wxPyBeginAllowThreads();
46239 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
46240 wxPyEndAllowThreads(__tstate);
46241 if (PyErr_Occurred()) SWIG_fail;
46242 }
46243 {
46244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46245 }
46246 return resultobj;
46247 fail:
46248 return NULL;
46249 }
46250
46251
46252 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46253 PyObject *resultobj = 0;
46254 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46255 bool result;
46256 void *argp1 = 0 ;
46257 int res1 = 0 ;
46258 PyObject *swig_obj[1] ;
46259
46260 if (!args) SWIG_fail;
46261 swig_obj[0] = args;
46262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46263 if (!SWIG_IsOK(res1)) {
46264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46265 }
46266 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46267 {
46268 PyThreadState* __tstate = wxPyBeginAllowThreads();
46269 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
46270 wxPyEndAllowThreads(__tstate);
46271 if (PyErr_Occurred()) SWIG_fail;
46272 }
46273 {
46274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46275 }
46276 return resultobj;
46277 fail:
46278 return NULL;
46279 }
46280
46281
46282 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46283 PyObject *resultobj = 0;
46284 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46285 wxMenu *arg2 = (wxMenu *) 0 ;
46286 void *argp1 = 0 ;
46287 int res1 = 0 ;
46288 void *argp2 = 0 ;
46289 int res2 = 0 ;
46290 PyObject * obj0 = 0 ;
46291 PyObject * obj1 = 0 ;
46292 char * kwnames[] = {
46293 (char *) "self",(char *) "menu", NULL
46294 };
46295
46296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
46297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46298 if (!SWIG_IsOK(res1)) {
46299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46300 }
46301 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46302 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
46303 if (!SWIG_IsOK(res2)) {
46304 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
46305 }
46306 arg2 = reinterpret_cast< wxMenu * >(argp2);
46307 {
46308 PyThreadState* __tstate = wxPyBeginAllowThreads();
46309 (arg1)->SetSubMenu(arg2);
46310 wxPyEndAllowThreads(__tstate);
46311 if (PyErr_Occurred()) SWIG_fail;
46312 }
46313 resultobj = SWIG_Py_Void();
46314 return resultobj;
46315 fail:
46316 return NULL;
46317 }
46318
46319
46320 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46321 PyObject *resultobj = 0;
46322 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46323 wxMenu *result = 0 ;
46324 void *argp1 = 0 ;
46325 int res1 = 0 ;
46326 PyObject *swig_obj[1] ;
46327
46328 if (!args) SWIG_fail;
46329 swig_obj[0] = args;
46330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46331 if (!SWIG_IsOK(res1)) {
46332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46333 }
46334 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46335 {
46336 PyThreadState* __tstate = wxPyBeginAllowThreads();
46337 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
46338 wxPyEndAllowThreads(__tstate);
46339 if (PyErr_Occurred()) SWIG_fail;
46340 }
46341 {
46342 resultobj = wxPyMake_wxObject(result, 0);
46343 }
46344 return resultobj;
46345 fail:
46346 return NULL;
46347 }
46348
46349
46350 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46351 PyObject *resultobj = 0;
46352 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46353 bool arg2 = (bool) true ;
46354 void *argp1 = 0 ;
46355 int res1 = 0 ;
46356 bool val2 ;
46357 int ecode2 = 0 ;
46358 PyObject * obj0 = 0 ;
46359 PyObject * obj1 = 0 ;
46360 char * kwnames[] = {
46361 (char *) "self",(char *) "enable", NULL
46362 };
46363
46364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
46365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46366 if (!SWIG_IsOK(res1)) {
46367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46368 }
46369 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46370 if (obj1) {
46371 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46372 if (!SWIG_IsOK(ecode2)) {
46373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
46374 }
46375 arg2 = static_cast< bool >(val2);
46376 }
46377 {
46378 PyThreadState* __tstate = wxPyBeginAllowThreads();
46379 (arg1)->Enable(arg2);
46380 wxPyEndAllowThreads(__tstate);
46381 if (PyErr_Occurred()) SWIG_fail;
46382 }
46383 resultobj = SWIG_Py_Void();
46384 return resultobj;
46385 fail:
46386 return NULL;
46387 }
46388
46389
46390 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46391 PyObject *resultobj = 0;
46392 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46393 bool result;
46394 void *argp1 = 0 ;
46395 int res1 = 0 ;
46396 PyObject *swig_obj[1] ;
46397
46398 if (!args) SWIG_fail;
46399 swig_obj[0] = args;
46400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46401 if (!SWIG_IsOK(res1)) {
46402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46403 }
46404 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46405 {
46406 PyThreadState* __tstate = wxPyBeginAllowThreads();
46407 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
46408 wxPyEndAllowThreads(__tstate);
46409 if (PyErr_Occurred()) SWIG_fail;
46410 }
46411 {
46412 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46413 }
46414 return resultobj;
46415 fail:
46416 return NULL;
46417 }
46418
46419
46420 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46421 PyObject *resultobj = 0;
46422 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46423 bool arg2 = (bool) true ;
46424 void *argp1 = 0 ;
46425 int res1 = 0 ;
46426 bool val2 ;
46427 int ecode2 = 0 ;
46428 PyObject * obj0 = 0 ;
46429 PyObject * obj1 = 0 ;
46430 char * kwnames[] = {
46431 (char *) "self",(char *) "check", NULL
46432 };
46433
46434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
46435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46436 if (!SWIG_IsOK(res1)) {
46437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46438 }
46439 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46440 if (obj1) {
46441 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46442 if (!SWIG_IsOK(ecode2)) {
46443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
46444 }
46445 arg2 = static_cast< bool >(val2);
46446 }
46447 {
46448 PyThreadState* __tstate = wxPyBeginAllowThreads();
46449 (arg1)->Check(arg2);
46450 wxPyEndAllowThreads(__tstate);
46451 if (PyErr_Occurred()) SWIG_fail;
46452 }
46453 resultobj = SWIG_Py_Void();
46454 return resultobj;
46455 fail:
46456 return NULL;
46457 }
46458
46459
46460 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46461 PyObject *resultobj = 0;
46462 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46463 bool result;
46464 void *argp1 = 0 ;
46465 int res1 = 0 ;
46466 PyObject *swig_obj[1] ;
46467
46468 if (!args) SWIG_fail;
46469 swig_obj[0] = args;
46470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46471 if (!SWIG_IsOK(res1)) {
46472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46473 }
46474 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46475 {
46476 PyThreadState* __tstate = wxPyBeginAllowThreads();
46477 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
46478 wxPyEndAllowThreads(__tstate);
46479 if (PyErr_Occurred()) SWIG_fail;
46480 }
46481 {
46482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46483 }
46484 return resultobj;
46485 fail:
46486 return NULL;
46487 }
46488
46489
46490 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46491 PyObject *resultobj = 0;
46492 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46493 void *argp1 = 0 ;
46494 int res1 = 0 ;
46495 PyObject *swig_obj[1] ;
46496
46497 if (!args) SWIG_fail;
46498 swig_obj[0] = args;
46499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46500 if (!SWIG_IsOK(res1)) {
46501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46502 }
46503 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46504 {
46505 PyThreadState* __tstate = wxPyBeginAllowThreads();
46506 (arg1)->Toggle();
46507 wxPyEndAllowThreads(__tstate);
46508 if (PyErr_Occurred()) SWIG_fail;
46509 }
46510 resultobj = SWIG_Py_Void();
46511 return resultobj;
46512 fail:
46513 return NULL;
46514 }
46515
46516
46517 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46518 PyObject *resultobj = 0;
46519 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46520 wxString *arg2 = 0 ;
46521 void *argp1 = 0 ;
46522 int res1 = 0 ;
46523 bool temp2 = false ;
46524 PyObject * obj0 = 0 ;
46525 PyObject * obj1 = 0 ;
46526 char * kwnames[] = {
46527 (char *) "self",(char *) "str", NULL
46528 };
46529
46530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
46531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46532 if (!SWIG_IsOK(res1)) {
46533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46534 }
46535 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46536 {
46537 arg2 = wxString_in_helper(obj1);
46538 if (arg2 == NULL) SWIG_fail;
46539 temp2 = true;
46540 }
46541 {
46542 PyThreadState* __tstate = wxPyBeginAllowThreads();
46543 (arg1)->SetHelp((wxString const &)*arg2);
46544 wxPyEndAllowThreads(__tstate);
46545 if (PyErr_Occurred()) SWIG_fail;
46546 }
46547 resultobj = SWIG_Py_Void();
46548 {
46549 if (temp2)
46550 delete arg2;
46551 }
46552 return resultobj;
46553 fail:
46554 {
46555 if (temp2)
46556 delete arg2;
46557 }
46558 return NULL;
46559 }
46560
46561
46562 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46563 PyObject *resultobj = 0;
46564 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46565 wxString *result = 0 ;
46566 void *argp1 = 0 ;
46567 int res1 = 0 ;
46568 PyObject *swig_obj[1] ;
46569
46570 if (!args) SWIG_fail;
46571 swig_obj[0] = args;
46572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46573 if (!SWIG_IsOK(res1)) {
46574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46575 }
46576 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46577 {
46578 PyThreadState* __tstate = wxPyBeginAllowThreads();
46579 {
46580 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
46581 result = (wxString *) &_result_ref;
46582 }
46583 wxPyEndAllowThreads(__tstate);
46584 if (PyErr_Occurred()) SWIG_fail;
46585 }
46586 {
46587 #if wxUSE_UNICODE
46588 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46589 #else
46590 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46591 #endif
46592 }
46593 return resultobj;
46594 fail:
46595 return NULL;
46596 }
46597
46598
46599 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46600 PyObject *resultobj = 0;
46601 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46602 wxAcceleratorEntry *result = 0 ;
46603 void *argp1 = 0 ;
46604 int res1 = 0 ;
46605 PyObject *swig_obj[1] ;
46606
46607 if (!args) SWIG_fail;
46608 swig_obj[0] = args;
46609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46610 if (!SWIG_IsOK(res1)) {
46611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46612 }
46613 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46614 {
46615 PyThreadState* __tstate = wxPyBeginAllowThreads();
46616 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
46617 wxPyEndAllowThreads(__tstate);
46618 if (PyErr_Occurred()) SWIG_fail;
46619 }
46620 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46621 return resultobj;
46622 fail:
46623 return NULL;
46624 }
46625
46626
46627 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46628 PyObject *resultobj = 0;
46629 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46630 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
46631 void *argp1 = 0 ;
46632 int res1 = 0 ;
46633 void *argp2 = 0 ;
46634 int res2 = 0 ;
46635 PyObject * obj0 = 0 ;
46636 PyObject * obj1 = 0 ;
46637 char * kwnames[] = {
46638 (char *) "self",(char *) "accel", NULL
46639 };
46640
46641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
46642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46643 if (!SWIG_IsOK(res1)) {
46644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46645 }
46646 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46647 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46648 if (!SWIG_IsOK(res2)) {
46649 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
46650 }
46651 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
46652 {
46653 PyThreadState* __tstate = wxPyBeginAllowThreads();
46654 (arg1)->SetAccel(arg2);
46655 wxPyEndAllowThreads(__tstate);
46656 if (PyErr_Occurred()) SWIG_fail;
46657 }
46658 resultobj = SWIG_Py_Void();
46659 return resultobj;
46660 fail:
46661 return NULL;
46662 }
46663
46664
46665 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46666 PyObject *resultobj = 0;
46667 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46668 wxBitmap *arg2 = 0 ;
46669 void *argp1 = 0 ;
46670 int res1 = 0 ;
46671 void *argp2 = 0 ;
46672 int res2 = 0 ;
46673 PyObject * obj0 = 0 ;
46674 PyObject * obj1 = 0 ;
46675 char * kwnames[] = {
46676 (char *) "self",(char *) "bitmap", NULL
46677 };
46678
46679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
46680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46681 if (!SWIG_IsOK(res1)) {
46682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46683 }
46684 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46685 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46686 if (!SWIG_IsOK(res2)) {
46687 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46688 }
46689 if (!argp2) {
46690 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46691 }
46692 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46693 {
46694 PyThreadState* __tstate = wxPyBeginAllowThreads();
46695 (arg1)->SetBitmap((wxBitmap const &)*arg2);
46696 wxPyEndAllowThreads(__tstate);
46697 if (PyErr_Occurred()) SWIG_fail;
46698 }
46699 resultobj = SWIG_Py_Void();
46700 return resultobj;
46701 fail:
46702 return NULL;
46703 }
46704
46705
46706 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46707 PyObject *resultobj = 0;
46708 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46709 wxBitmap *result = 0 ;
46710 void *argp1 = 0 ;
46711 int res1 = 0 ;
46712 PyObject *swig_obj[1] ;
46713
46714 if (!args) SWIG_fail;
46715 swig_obj[0] = args;
46716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46717 if (!SWIG_IsOK(res1)) {
46718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46719 }
46720 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46721 {
46722 PyThreadState* __tstate = wxPyBeginAllowThreads();
46723 {
46724 wxBitmap const &_result_ref = (arg1)->GetBitmap();
46725 result = (wxBitmap *) &_result_ref;
46726 }
46727 wxPyEndAllowThreads(__tstate);
46728 if (PyErr_Occurred()) SWIG_fail;
46729 }
46730 {
46731 wxBitmap* resultptr = new wxBitmap(*result);
46732 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
46733 }
46734 return resultobj;
46735 fail:
46736 return NULL;
46737 }
46738
46739
46740 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46741 PyObject *resultobj = 0;
46742 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46743 wxFont *arg2 = 0 ;
46744 void *argp1 = 0 ;
46745 int res1 = 0 ;
46746 void *argp2 = 0 ;
46747 int res2 = 0 ;
46748 PyObject * obj0 = 0 ;
46749 PyObject * obj1 = 0 ;
46750 char * kwnames[] = {
46751 (char *) "self",(char *) "font", NULL
46752 };
46753
46754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
46755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46756 if (!SWIG_IsOK(res1)) {
46757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46758 }
46759 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46760 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
46761 if (!SWIG_IsOK(res2)) {
46762 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46763 }
46764 if (!argp2) {
46765 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46766 }
46767 arg2 = reinterpret_cast< wxFont * >(argp2);
46768 {
46769 PyThreadState* __tstate = wxPyBeginAllowThreads();
46770 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
46771 wxPyEndAllowThreads(__tstate);
46772 if (PyErr_Occurred()) SWIG_fail;
46773 }
46774 resultobj = SWIG_Py_Void();
46775 return resultobj;
46776 fail:
46777 return NULL;
46778 }
46779
46780
46781 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46782 PyObject *resultobj = 0;
46783 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46784 wxFont result;
46785 void *argp1 = 0 ;
46786 int res1 = 0 ;
46787 PyObject *swig_obj[1] ;
46788
46789 if (!args) SWIG_fail;
46790 swig_obj[0] = args;
46791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46792 if (!SWIG_IsOK(res1)) {
46793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46794 }
46795 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46796 {
46797 PyThreadState* __tstate = wxPyBeginAllowThreads();
46798 result = wxMenuItem_GetFont(arg1);
46799 wxPyEndAllowThreads(__tstate);
46800 if (PyErr_Occurred()) SWIG_fail;
46801 }
46802 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
46803 return resultobj;
46804 fail:
46805 return NULL;
46806 }
46807
46808
46809 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46810 PyObject *resultobj = 0;
46811 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46812 wxColour *arg2 = 0 ;
46813 void *argp1 = 0 ;
46814 int res1 = 0 ;
46815 wxColour temp2 ;
46816 PyObject * obj0 = 0 ;
46817 PyObject * obj1 = 0 ;
46818 char * kwnames[] = {
46819 (char *) "self",(char *) "colText", NULL
46820 };
46821
46822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
46823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46824 if (!SWIG_IsOK(res1)) {
46825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46826 }
46827 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46828 {
46829 arg2 = &temp2;
46830 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
46831 }
46832 {
46833 PyThreadState* __tstate = wxPyBeginAllowThreads();
46834 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
46835 wxPyEndAllowThreads(__tstate);
46836 if (PyErr_Occurred()) SWIG_fail;
46837 }
46838 resultobj = SWIG_Py_Void();
46839 return resultobj;
46840 fail:
46841 return NULL;
46842 }
46843
46844
46845 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46846 PyObject *resultobj = 0;
46847 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46848 wxColour result;
46849 void *argp1 = 0 ;
46850 int res1 = 0 ;
46851 PyObject *swig_obj[1] ;
46852
46853 if (!args) SWIG_fail;
46854 swig_obj[0] = args;
46855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46856 if (!SWIG_IsOK(res1)) {
46857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46858 }
46859 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46860 {
46861 PyThreadState* __tstate = wxPyBeginAllowThreads();
46862 result = wxMenuItem_GetTextColour(arg1);
46863 wxPyEndAllowThreads(__tstate);
46864 if (PyErr_Occurred()) SWIG_fail;
46865 }
46866 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
46867 return resultobj;
46868 fail:
46869 return NULL;
46870 }
46871
46872
46873 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46874 PyObject *resultobj = 0;
46875 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46876 wxColour *arg2 = 0 ;
46877 void *argp1 = 0 ;
46878 int res1 = 0 ;
46879 wxColour temp2 ;
46880 PyObject * obj0 = 0 ;
46881 PyObject * obj1 = 0 ;
46882 char * kwnames[] = {
46883 (char *) "self",(char *) "colBack", NULL
46884 };
46885
46886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
46887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46888 if (!SWIG_IsOK(res1)) {
46889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46890 }
46891 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46892 {
46893 arg2 = &temp2;
46894 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
46895 }
46896 {
46897 PyThreadState* __tstate = wxPyBeginAllowThreads();
46898 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
46899 wxPyEndAllowThreads(__tstate);
46900 if (PyErr_Occurred()) SWIG_fail;
46901 }
46902 resultobj = SWIG_Py_Void();
46903 return resultobj;
46904 fail:
46905 return NULL;
46906 }
46907
46908
46909 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46910 PyObject *resultobj = 0;
46911 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46912 wxColour result;
46913 void *argp1 = 0 ;
46914 int res1 = 0 ;
46915 PyObject *swig_obj[1] ;
46916
46917 if (!args) SWIG_fail;
46918 swig_obj[0] = args;
46919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46920 if (!SWIG_IsOK(res1)) {
46921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46922 }
46923 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46924 {
46925 PyThreadState* __tstate = wxPyBeginAllowThreads();
46926 result = wxMenuItem_GetBackgroundColour(arg1);
46927 wxPyEndAllowThreads(__tstate);
46928 if (PyErr_Occurred()) SWIG_fail;
46929 }
46930 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
46931 return resultobj;
46932 fail:
46933 return NULL;
46934 }
46935
46936
46937 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46938 PyObject *resultobj = 0;
46939 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46940 wxBitmap *arg2 = 0 ;
46941 wxBitmap const &arg3_defvalue = wxNullBitmap ;
46942 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
46943 void *argp1 = 0 ;
46944 int res1 = 0 ;
46945 void *argp2 = 0 ;
46946 int res2 = 0 ;
46947 void *argp3 = 0 ;
46948 int res3 = 0 ;
46949 PyObject * obj0 = 0 ;
46950 PyObject * obj1 = 0 ;
46951 PyObject * obj2 = 0 ;
46952 char * kwnames[] = {
46953 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
46954 };
46955
46956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46958 if (!SWIG_IsOK(res1)) {
46959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46960 }
46961 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46962 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46963 if (!SWIG_IsOK(res2)) {
46964 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46965 }
46966 if (!argp2) {
46967 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46968 }
46969 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46970 if (obj2) {
46971 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
46972 if (!SWIG_IsOK(res3)) {
46973 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
46974 }
46975 if (!argp3) {
46976 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
46977 }
46978 arg3 = reinterpret_cast< wxBitmap * >(argp3);
46979 }
46980 {
46981 PyThreadState* __tstate = wxPyBeginAllowThreads();
46982 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
46983 wxPyEndAllowThreads(__tstate);
46984 if (PyErr_Occurred()) SWIG_fail;
46985 }
46986 resultobj = SWIG_Py_Void();
46987 return resultobj;
46988 fail:
46989 return NULL;
46990 }
46991
46992
46993 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46994 PyObject *resultobj = 0;
46995 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46996 wxBitmap *arg2 = 0 ;
46997 void *argp1 = 0 ;
46998 int res1 = 0 ;
46999 void *argp2 = 0 ;
47000 int res2 = 0 ;
47001 PyObject * obj0 = 0 ;
47002 PyObject * obj1 = 0 ;
47003 char * kwnames[] = {
47004 (char *) "self",(char *) "bmpDisabled", NULL
47005 };
47006
47007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
47008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47009 if (!SWIG_IsOK(res1)) {
47010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47011 }
47012 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47013 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47014 if (!SWIG_IsOK(res2)) {
47015 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47016 }
47017 if (!argp2) {
47018 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47019 }
47020 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47021 {
47022 PyThreadState* __tstate = wxPyBeginAllowThreads();
47023 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
47024 wxPyEndAllowThreads(__tstate);
47025 if (PyErr_Occurred()) SWIG_fail;
47026 }
47027 resultobj = SWIG_Py_Void();
47028 return resultobj;
47029 fail:
47030 return NULL;
47031 }
47032
47033
47034 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47035 PyObject *resultobj = 0;
47036 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47037 wxBitmap *result = 0 ;
47038 void *argp1 = 0 ;
47039 int res1 = 0 ;
47040 PyObject *swig_obj[1] ;
47041
47042 if (!args) SWIG_fail;
47043 swig_obj[0] = args;
47044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47045 if (!SWIG_IsOK(res1)) {
47046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47047 }
47048 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47049 {
47050 PyThreadState* __tstate = wxPyBeginAllowThreads();
47051 {
47052 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
47053 result = (wxBitmap *) &_result_ref;
47054 }
47055 wxPyEndAllowThreads(__tstate);
47056 if (PyErr_Occurred()) SWIG_fail;
47057 }
47058 {
47059 wxBitmap* resultptr = new wxBitmap(*result);
47060 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
47061 }
47062 return resultobj;
47063 fail:
47064 return NULL;
47065 }
47066
47067
47068 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47069 PyObject *resultobj = 0;
47070 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47071 int arg2 ;
47072 void *argp1 = 0 ;
47073 int res1 = 0 ;
47074 int val2 ;
47075 int ecode2 = 0 ;
47076 PyObject * obj0 = 0 ;
47077 PyObject * obj1 = 0 ;
47078 char * kwnames[] = {
47079 (char *) "self",(char *) "nWidth", NULL
47080 };
47081
47082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
47083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47084 if (!SWIG_IsOK(res1)) {
47085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47086 }
47087 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47088 ecode2 = SWIG_AsVal_int(obj1, &val2);
47089 if (!SWIG_IsOK(ecode2)) {
47090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
47091 }
47092 arg2 = static_cast< int >(val2);
47093 {
47094 PyThreadState* __tstate = wxPyBeginAllowThreads();
47095 wxMenuItem_SetMarginWidth(arg1,arg2);
47096 wxPyEndAllowThreads(__tstate);
47097 if (PyErr_Occurred()) SWIG_fail;
47098 }
47099 resultobj = SWIG_Py_Void();
47100 return resultobj;
47101 fail:
47102 return NULL;
47103 }
47104
47105
47106 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47107 PyObject *resultobj = 0;
47108 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47109 int result;
47110 void *argp1 = 0 ;
47111 int res1 = 0 ;
47112 PyObject *swig_obj[1] ;
47113
47114 if (!args) SWIG_fail;
47115 swig_obj[0] = args;
47116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47117 if (!SWIG_IsOK(res1)) {
47118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47119 }
47120 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47121 {
47122 PyThreadState* __tstate = wxPyBeginAllowThreads();
47123 result = (int)wxMenuItem_GetMarginWidth(arg1);
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_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47135 PyObject *resultobj = 0;
47136 int result;
47137
47138 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
47139 {
47140 PyThreadState* __tstate = wxPyBeginAllowThreads();
47141 result = (int)wxMenuItem_GetDefaultMarginWidth();
47142 wxPyEndAllowThreads(__tstate);
47143 if (PyErr_Occurred()) SWIG_fail;
47144 }
47145 resultobj = SWIG_From_int(static_cast< int >(result));
47146 return resultobj;
47147 fail:
47148 return NULL;
47149 }
47150
47151
47152 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47153 PyObject *resultobj = 0;
47154 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47155 bool result;
47156 void *argp1 = 0 ;
47157 int res1 = 0 ;
47158 PyObject *swig_obj[1] ;
47159
47160 if (!args) SWIG_fail;
47161 swig_obj[0] = args;
47162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47163 if (!SWIG_IsOK(res1)) {
47164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47165 }
47166 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47167 {
47168 PyThreadState* __tstate = wxPyBeginAllowThreads();
47169 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
47170 wxPyEndAllowThreads(__tstate);
47171 if (PyErr_Occurred()) SWIG_fail;
47172 }
47173 {
47174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47175 }
47176 return resultobj;
47177 fail:
47178 return NULL;
47179 }
47180
47181
47182 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47183 PyObject *resultobj = 0;
47184 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47185 bool arg2 = (bool) true ;
47186 void *argp1 = 0 ;
47187 int res1 = 0 ;
47188 bool val2 ;
47189 int ecode2 = 0 ;
47190 PyObject * obj0 = 0 ;
47191 PyObject * obj1 = 0 ;
47192 char * kwnames[] = {
47193 (char *) "self",(char *) "ownerDrawn", NULL
47194 };
47195
47196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
47197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47198 if (!SWIG_IsOK(res1)) {
47199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47200 }
47201 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47202 if (obj1) {
47203 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47204 if (!SWIG_IsOK(ecode2)) {
47205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
47206 }
47207 arg2 = static_cast< bool >(val2);
47208 }
47209 {
47210 PyThreadState* __tstate = wxPyBeginAllowThreads();
47211 wxMenuItem_SetOwnerDrawn(arg1,arg2);
47212 wxPyEndAllowThreads(__tstate);
47213 if (PyErr_Occurred()) SWIG_fail;
47214 }
47215 resultobj = SWIG_Py_Void();
47216 return resultobj;
47217 fail:
47218 return NULL;
47219 }
47220
47221
47222 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47223 PyObject *resultobj = 0;
47224 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47225 void *argp1 = 0 ;
47226 int res1 = 0 ;
47227 PyObject *swig_obj[1] ;
47228
47229 if (!args) SWIG_fail;
47230 swig_obj[0] = args;
47231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47232 if (!SWIG_IsOK(res1)) {
47233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47234 }
47235 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47236 {
47237 PyThreadState* __tstate = wxPyBeginAllowThreads();
47238 wxMenuItem_ResetOwnerDrawn(arg1);
47239 wxPyEndAllowThreads(__tstate);
47240 if (PyErr_Occurred()) SWIG_fail;
47241 }
47242 resultobj = SWIG_Py_Void();
47243 return resultobj;
47244 fail:
47245 return NULL;
47246 }
47247
47248
47249 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47250 PyObject *obj;
47251 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47252 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
47253 return SWIG_Py_Void();
47254 }
47255
47256 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47257 return SWIG_Python_InitShadowInstance(args);
47258 }
47259
47260 SWIGINTERN int ControlNameStr_set(PyObject *) {
47261 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
47262 return 1;
47263 }
47264
47265
47266 SWIGINTERN PyObject *ControlNameStr_get(void) {
47267 PyObject *pyobj = 0;
47268
47269 {
47270 #if wxUSE_UNICODE
47271 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47272 #else
47273 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47274 #endif
47275 }
47276 return pyobj;
47277 }
47278
47279
47280 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47281 PyObject *resultobj = 0;
47282 wxWindow *arg1 = (wxWindow *) 0 ;
47283 int arg2 = (int) -1 ;
47284 wxPoint const &arg3_defvalue = wxDefaultPosition ;
47285 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
47286 wxSize const &arg4_defvalue = wxDefaultSize ;
47287 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
47288 long arg5 = (long) 0 ;
47289 wxValidator const &arg6_defvalue = wxDefaultValidator ;
47290 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
47291 wxString const &arg7_defvalue = wxPyControlNameStr ;
47292 wxString *arg7 = (wxString *) &arg7_defvalue ;
47293 wxControl *result = 0 ;
47294 void *argp1 = 0 ;
47295 int res1 = 0 ;
47296 int val2 ;
47297 int ecode2 = 0 ;
47298 wxPoint temp3 ;
47299 wxSize temp4 ;
47300 long val5 ;
47301 int ecode5 = 0 ;
47302 void *argp6 = 0 ;
47303 int res6 = 0 ;
47304 bool temp7 = false ;
47305 PyObject * obj0 = 0 ;
47306 PyObject * obj1 = 0 ;
47307 PyObject * obj2 = 0 ;
47308 PyObject * obj3 = 0 ;
47309 PyObject * obj4 = 0 ;
47310 PyObject * obj5 = 0 ;
47311 PyObject * obj6 = 0 ;
47312 char * kwnames[] = {
47313 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47314 };
47315
47316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
47318 if (!SWIG_IsOK(res1)) {
47319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
47320 }
47321 arg1 = reinterpret_cast< wxWindow * >(argp1);
47322 if (obj1) {
47323 ecode2 = SWIG_AsVal_int(obj1, &val2);
47324 if (!SWIG_IsOK(ecode2)) {
47325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
47326 }
47327 arg2 = static_cast< int >(val2);
47328 }
47329 if (obj2) {
47330 {
47331 arg3 = &temp3;
47332 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
47333 }
47334 }
47335 if (obj3) {
47336 {
47337 arg4 = &temp4;
47338 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
47339 }
47340 }
47341 if (obj4) {
47342 ecode5 = SWIG_AsVal_long(obj4, &val5);
47343 if (!SWIG_IsOK(ecode5)) {
47344 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
47345 }
47346 arg5 = static_cast< long >(val5);
47347 }
47348 if (obj5) {
47349 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
47350 if (!SWIG_IsOK(res6)) {
47351 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47352 }
47353 if (!argp6) {
47354 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47355 }
47356 arg6 = reinterpret_cast< wxValidator * >(argp6);
47357 }
47358 if (obj6) {
47359 {
47360 arg7 = wxString_in_helper(obj6);
47361 if (arg7 == NULL) SWIG_fail;
47362 temp7 = true;
47363 }
47364 }
47365 {
47366 if (!wxPyCheckForApp()) SWIG_fail;
47367 PyThreadState* __tstate = wxPyBeginAllowThreads();
47368 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
47369 wxPyEndAllowThreads(__tstate);
47370 if (PyErr_Occurred()) SWIG_fail;
47371 }
47372 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
47373 {
47374 if (temp7)
47375 delete arg7;
47376 }
47377 return resultobj;
47378 fail:
47379 {
47380 if (temp7)
47381 delete arg7;
47382 }
47383 return NULL;
47384 }
47385
47386
47387 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47388 PyObject *resultobj = 0;
47389 wxControl *result = 0 ;
47390
47391 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
47392 {
47393 if (!wxPyCheckForApp()) SWIG_fail;
47394 PyThreadState* __tstate = wxPyBeginAllowThreads();
47395 result = (wxControl *)new wxControl();
47396 wxPyEndAllowThreads(__tstate);
47397 if (PyErr_Occurred()) SWIG_fail;
47398 }
47399 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
47400 return resultobj;
47401 fail:
47402 return NULL;
47403 }
47404
47405
47406 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47407 PyObject *resultobj = 0;
47408 wxControl *arg1 = (wxControl *) 0 ;
47409 wxWindow *arg2 = (wxWindow *) 0 ;
47410 int arg3 = (int) -1 ;
47411 wxPoint const &arg4_defvalue = wxDefaultPosition ;
47412 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
47413 wxSize const &arg5_defvalue = wxDefaultSize ;
47414 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
47415 long arg6 = (long) 0 ;
47416 wxValidator const &arg7_defvalue = wxDefaultValidator ;
47417 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
47418 wxString const &arg8_defvalue = wxPyControlNameStr ;
47419 wxString *arg8 = (wxString *) &arg8_defvalue ;
47420 bool result;
47421 void *argp1 = 0 ;
47422 int res1 = 0 ;
47423 void *argp2 = 0 ;
47424 int res2 = 0 ;
47425 int val3 ;
47426 int ecode3 = 0 ;
47427 wxPoint temp4 ;
47428 wxSize temp5 ;
47429 long val6 ;
47430 int ecode6 = 0 ;
47431 void *argp7 = 0 ;
47432 int res7 = 0 ;
47433 bool temp8 = false ;
47434 PyObject * obj0 = 0 ;
47435 PyObject * obj1 = 0 ;
47436 PyObject * obj2 = 0 ;
47437 PyObject * obj3 = 0 ;
47438 PyObject * obj4 = 0 ;
47439 PyObject * obj5 = 0 ;
47440 PyObject * obj6 = 0 ;
47441 PyObject * obj7 = 0 ;
47442 char * kwnames[] = {
47443 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47444 };
47445
47446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
47447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47448 if (!SWIG_IsOK(res1)) {
47449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
47450 }
47451 arg1 = reinterpret_cast< wxControl * >(argp1);
47452 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47453 if (!SWIG_IsOK(res2)) {
47454 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
47455 }
47456 arg2 = reinterpret_cast< wxWindow * >(argp2);
47457 if (obj2) {
47458 ecode3 = SWIG_AsVal_int(obj2, &val3);
47459 if (!SWIG_IsOK(ecode3)) {
47460 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
47461 }
47462 arg3 = static_cast< int >(val3);
47463 }
47464 if (obj3) {
47465 {
47466 arg4 = &temp4;
47467 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
47468 }
47469 }
47470 if (obj4) {
47471 {
47472 arg5 = &temp5;
47473 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
47474 }
47475 }
47476 if (obj5) {
47477 ecode6 = SWIG_AsVal_long(obj5, &val6);
47478 if (!SWIG_IsOK(ecode6)) {
47479 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
47480 }
47481 arg6 = static_cast< long >(val6);
47482 }
47483 if (obj6) {
47484 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
47485 if (!SWIG_IsOK(res7)) {
47486 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47487 }
47488 if (!argp7) {
47489 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47490 }
47491 arg7 = reinterpret_cast< wxValidator * >(argp7);
47492 }
47493 if (obj7) {
47494 {
47495 arg8 = wxString_in_helper(obj7);
47496 if (arg8 == NULL) SWIG_fail;
47497 temp8 = true;
47498 }
47499 }
47500 {
47501 PyThreadState* __tstate = wxPyBeginAllowThreads();
47502 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
47503 wxPyEndAllowThreads(__tstate);
47504 if (PyErr_Occurred()) SWIG_fail;
47505 }
47506 {
47507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47508 }
47509 {
47510 if (temp8)
47511 delete arg8;
47512 }
47513 return resultobj;
47514 fail:
47515 {
47516 if (temp8)
47517 delete arg8;
47518 }
47519 return NULL;
47520 }
47521
47522
47523 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47524 PyObject *resultobj = 0;
47525 wxControl *arg1 = (wxControl *) 0 ;
47526 int result;
47527 void *argp1 = 0 ;
47528 int res1 = 0 ;
47529 PyObject *swig_obj[1] ;
47530
47531 if (!args) SWIG_fail;
47532 swig_obj[0] = args;
47533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47534 if (!SWIG_IsOK(res1)) {
47535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
47536 }
47537 arg1 = reinterpret_cast< wxControl * >(argp1);
47538 {
47539 PyThreadState* __tstate = wxPyBeginAllowThreads();
47540 result = (int)((wxControl const *)arg1)->GetAlignment();
47541 wxPyEndAllowThreads(__tstate);
47542 if (PyErr_Occurred()) SWIG_fail;
47543 }
47544 resultobj = SWIG_From_int(static_cast< int >(result));
47545 return resultobj;
47546 fail:
47547 return NULL;
47548 }
47549
47550
47551 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47552 PyObject *resultobj = 0;
47553 wxControl *arg1 = (wxControl *) 0 ;
47554 wxString result;
47555 void *argp1 = 0 ;
47556 int res1 = 0 ;
47557 PyObject *swig_obj[1] ;
47558
47559 if (!args) SWIG_fail;
47560 swig_obj[0] = args;
47561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47562 if (!SWIG_IsOK(res1)) {
47563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
47564 }
47565 arg1 = reinterpret_cast< wxControl * >(argp1);
47566 {
47567 PyThreadState* __tstate = wxPyBeginAllowThreads();
47568 result = ((wxControl const *)arg1)->GetLabelText();
47569 wxPyEndAllowThreads(__tstate);
47570 if (PyErr_Occurred()) SWIG_fail;
47571 }
47572 {
47573 #if wxUSE_UNICODE
47574 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
47575 #else
47576 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
47577 #endif
47578 }
47579 return resultobj;
47580 fail:
47581 return NULL;
47582 }
47583
47584
47585 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47586 PyObject *resultobj = 0;
47587 wxControl *arg1 = (wxControl *) 0 ;
47588 wxCommandEvent *arg2 = 0 ;
47589 void *argp1 = 0 ;
47590 int res1 = 0 ;
47591 void *argp2 = 0 ;
47592 int res2 = 0 ;
47593 PyObject * obj0 = 0 ;
47594 PyObject * obj1 = 0 ;
47595 char * kwnames[] = {
47596 (char *) "self",(char *) "event", NULL
47597 };
47598
47599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
47600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47601 if (!SWIG_IsOK(res1)) {
47602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
47603 }
47604 arg1 = reinterpret_cast< wxControl * >(argp1);
47605 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
47606 if (!SWIG_IsOK(res2)) {
47607 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47608 }
47609 if (!argp2) {
47610 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47611 }
47612 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
47613 {
47614 PyThreadState* __tstate = wxPyBeginAllowThreads();
47615 (arg1)->Command(*arg2);
47616 wxPyEndAllowThreads(__tstate);
47617 if (PyErr_Occurred()) SWIG_fail;
47618 }
47619 resultobj = SWIG_Py_Void();
47620 return resultobj;
47621 fail:
47622 return NULL;
47623 }
47624
47625
47626 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47627 PyObject *resultobj = 0;
47628 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
47629 SwigValueWrapper<wxVisualAttributes > result;
47630 int val1 ;
47631 int ecode1 = 0 ;
47632 PyObject * obj0 = 0 ;
47633 char * kwnames[] = {
47634 (char *) "variant", NULL
47635 };
47636
47637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
47638 if (obj0) {
47639 ecode1 = SWIG_AsVal_int(obj0, &val1);
47640 if (!SWIG_IsOK(ecode1)) {
47641 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
47642 }
47643 arg1 = static_cast< wxWindowVariant >(val1);
47644 }
47645 {
47646 if (!wxPyCheckForApp()) SWIG_fail;
47647 PyThreadState* __tstate = wxPyBeginAllowThreads();
47648 result = wxControl::GetClassDefaultAttributes(arg1);
47649 wxPyEndAllowThreads(__tstate);
47650 if (PyErr_Occurred()) SWIG_fail;
47651 }
47652 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
47653 return resultobj;
47654 fail:
47655 return NULL;
47656 }
47657
47658
47659 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47660 PyObject *obj;
47661 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47662 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
47663 return SWIG_Py_Void();
47664 }
47665
47666 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47667 return SWIG_Python_InitShadowInstance(args);
47668 }
47669
47670 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47671 PyObject *resultobj = 0;
47672 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47673 wxString *arg2 = 0 ;
47674 PyObject *arg3 = (PyObject *) NULL ;
47675 int result;
47676 void *argp1 = 0 ;
47677 int res1 = 0 ;
47678 bool temp2 = false ;
47679 PyObject * obj0 = 0 ;
47680 PyObject * obj1 = 0 ;
47681 PyObject * obj2 = 0 ;
47682 char * kwnames[] = {
47683 (char *) "self",(char *) "item",(char *) "clientData", NULL
47684 };
47685
47686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47688 if (!SWIG_IsOK(res1)) {
47689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47690 }
47691 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47692 {
47693 arg2 = wxString_in_helper(obj1);
47694 if (arg2 == NULL) SWIG_fail;
47695 temp2 = true;
47696 }
47697 if (obj2) {
47698 arg3 = obj2;
47699 }
47700 {
47701 PyThreadState* __tstate = wxPyBeginAllowThreads();
47702 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
47703 wxPyEndAllowThreads(__tstate);
47704 if (PyErr_Occurred()) SWIG_fail;
47705 }
47706 resultobj = SWIG_From_int(static_cast< int >(result));
47707 {
47708 if (temp2)
47709 delete arg2;
47710 }
47711 return resultobj;
47712 fail:
47713 {
47714 if (temp2)
47715 delete arg2;
47716 }
47717 return NULL;
47718 }
47719
47720
47721 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47722 PyObject *resultobj = 0;
47723 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47724 wxArrayString *arg2 = 0 ;
47725 void *argp1 = 0 ;
47726 int res1 = 0 ;
47727 bool temp2 = false ;
47728 PyObject * obj0 = 0 ;
47729 PyObject * obj1 = 0 ;
47730 char * kwnames[] = {
47731 (char *) "self",(char *) "strings", NULL
47732 };
47733
47734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
47735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47736 if (!SWIG_IsOK(res1)) {
47737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47738 }
47739 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47740 {
47741 if (! PySequence_Check(obj1)) {
47742 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
47743 SWIG_fail;
47744 }
47745 arg2 = new wxArrayString;
47746 temp2 = true;
47747 int i, len=PySequence_Length(obj1);
47748 for (i=0; i<len; i++) {
47749 PyObject* item = PySequence_GetItem(obj1, i);
47750 wxString* s = wxString_in_helper(item);
47751 if (PyErr_Occurred()) SWIG_fail;
47752 arg2->Add(*s);
47753 delete s;
47754 Py_DECREF(item);
47755 }
47756 }
47757 {
47758 PyThreadState* __tstate = wxPyBeginAllowThreads();
47759 (arg1)->Append((wxArrayString const &)*arg2);
47760 wxPyEndAllowThreads(__tstate);
47761 if (PyErr_Occurred()) SWIG_fail;
47762 }
47763 resultobj = SWIG_Py_Void();
47764 {
47765 if (temp2) delete arg2;
47766 }
47767 return resultobj;
47768 fail:
47769 {
47770 if (temp2) delete arg2;
47771 }
47772 return NULL;
47773 }
47774
47775
47776 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47777 PyObject *resultobj = 0;
47778 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47779 wxString *arg2 = 0 ;
47780 unsigned int arg3 ;
47781 PyObject *arg4 = (PyObject *) NULL ;
47782 int result;
47783 void *argp1 = 0 ;
47784 int res1 = 0 ;
47785 bool temp2 = false ;
47786 unsigned int val3 ;
47787 int ecode3 = 0 ;
47788 PyObject * obj0 = 0 ;
47789 PyObject * obj1 = 0 ;
47790 PyObject * obj2 = 0 ;
47791 PyObject * obj3 = 0 ;
47792 char * kwnames[] = {
47793 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
47794 };
47795
47796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47798 if (!SWIG_IsOK(res1)) {
47799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47800 }
47801 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47802 {
47803 arg2 = wxString_in_helper(obj1);
47804 if (arg2 == NULL) SWIG_fail;
47805 temp2 = true;
47806 }
47807 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
47808 if (!SWIG_IsOK(ecode3)) {
47809 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
47810 }
47811 arg3 = static_cast< unsigned int >(val3);
47812 if (obj3) {
47813 arg4 = obj3;
47814 }
47815 {
47816 PyThreadState* __tstate = wxPyBeginAllowThreads();
47817 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
47818 wxPyEndAllowThreads(__tstate);
47819 if (PyErr_Occurred()) SWIG_fail;
47820 }
47821 resultobj = SWIG_From_int(static_cast< int >(result));
47822 {
47823 if (temp2)
47824 delete arg2;
47825 }
47826 return resultobj;
47827 fail:
47828 {
47829 if (temp2)
47830 delete arg2;
47831 }
47832 return NULL;
47833 }
47834
47835
47836 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47837 PyObject *resultobj = 0;
47838 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47839 void *argp1 = 0 ;
47840 int res1 = 0 ;
47841 PyObject *swig_obj[1] ;
47842
47843 if (!args) SWIG_fail;
47844 swig_obj[0] = args;
47845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47846 if (!SWIG_IsOK(res1)) {
47847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47848 }
47849 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47850 {
47851 PyThreadState* __tstate = wxPyBeginAllowThreads();
47852 (arg1)->Clear();
47853 wxPyEndAllowThreads(__tstate);
47854 if (PyErr_Occurred()) SWIG_fail;
47855 }
47856 resultobj = SWIG_Py_Void();
47857 return resultobj;
47858 fail:
47859 return NULL;
47860 }
47861
47862
47863 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47864 PyObject *resultobj = 0;
47865 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47866 unsigned int arg2 ;
47867 void *argp1 = 0 ;
47868 int res1 = 0 ;
47869 unsigned int val2 ;
47870 int ecode2 = 0 ;
47871 PyObject * obj0 = 0 ;
47872 PyObject * obj1 = 0 ;
47873 char * kwnames[] = {
47874 (char *) "self",(char *) "n", NULL
47875 };
47876
47877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
47878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47879 if (!SWIG_IsOK(res1)) {
47880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47881 }
47882 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47883 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47884 if (!SWIG_IsOK(ecode2)) {
47885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
47886 }
47887 arg2 = static_cast< unsigned int >(val2);
47888 {
47889 PyThreadState* __tstate = wxPyBeginAllowThreads();
47890 (arg1)->Delete(arg2);
47891 wxPyEndAllowThreads(__tstate);
47892 if (PyErr_Occurred()) SWIG_fail;
47893 }
47894 resultobj = SWIG_Py_Void();
47895 return resultobj;
47896 fail:
47897 return NULL;
47898 }
47899
47900
47901 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47902 PyObject *resultobj = 0;
47903 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47904 unsigned int arg2 ;
47905 PyObject *result = 0 ;
47906 void *argp1 = 0 ;
47907 int res1 = 0 ;
47908 unsigned int val2 ;
47909 int ecode2 = 0 ;
47910 PyObject * obj0 = 0 ;
47911 PyObject * obj1 = 0 ;
47912 char * kwnames[] = {
47913 (char *) "self",(char *) "n", NULL
47914 };
47915
47916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
47917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47918 if (!SWIG_IsOK(res1)) {
47919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47920 }
47921 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47922 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47923 if (!SWIG_IsOK(ecode2)) {
47924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
47925 }
47926 arg2 = static_cast< unsigned int >(val2);
47927 {
47928 PyThreadState* __tstate = wxPyBeginAllowThreads();
47929 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
47930 wxPyEndAllowThreads(__tstate);
47931 if (PyErr_Occurred()) SWIG_fail;
47932 }
47933 resultobj = result;
47934 return resultobj;
47935 fail:
47936 return NULL;
47937 }
47938
47939
47940 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47941 PyObject *resultobj = 0;
47942 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47943 unsigned int arg2 ;
47944 PyObject *arg3 = (PyObject *) 0 ;
47945 void *argp1 = 0 ;
47946 int res1 = 0 ;
47947 unsigned int val2 ;
47948 int ecode2 = 0 ;
47949 PyObject * obj0 = 0 ;
47950 PyObject * obj1 = 0 ;
47951 PyObject * obj2 = 0 ;
47952 char * kwnames[] = {
47953 (char *) "self",(char *) "n",(char *) "clientData", NULL
47954 };
47955
47956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47958 if (!SWIG_IsOK(res1)) {
47959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47960 }
47961 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47962 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47963 if (!SWIG_IsOK(ecode2)) {
47964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
47965 }
47966 arg2 = static_cast< unsigned int >(val2);
47967 arg3 = obj2;
47968 {
47969 PyThreadState* __tstate = wxPyBeginAllowThreads();
47970 wxItemContainer_SetClientData(arg1,arg2,arg3);
47971 wxPyEndAllowThreads(__tstate);
47972 if (PyErr_Occurred()) SWIG_fail;
47973 }
47974 resultobj = SWIG_Py_Void();
47975 return resultobj;
47976 fail:
47977 return NULL;
47978 }
47979
47980
47981 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47982 PyObject *resultobj = 0;
47983 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47984 unsigned int result;
47985 void *argp1 = 0 ;
47986 int res1 = 0 ;
47987 PyObject *swig_obj[1] ;
47988
47989 if (!args) SWIG_fail;
47990 swig_obj[0] = args;
47991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47992 if (!SWIG_IsOK(res1)) {
47993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
47994 }
47995 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47996 {
47997 PyThreadState* __tstate = wxPyBeginAllowThreads();
47998 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
47999 wxPyEndAllowThreads(__tstate);
48000 if (PyErr_Occurred()) SWIG_fail;
48001 }
48002 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
48003 return resultobj;
48004 fail:
48005 return NULL;
48006 }
48007
48008
48009 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48010 PyObject *resultobj = 0;
48011 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48012 bool result;
48013 void *argp1 = 0 ;
48014 int res1 = 0 ;
48015 PyObject *swig_obj[1] ;
48016
48017 if (!args) SWIG_fail;
48018 swig_obj[0] = args;
48019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48020 if (!SWIG_IsOK(res1)) {
48021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48022 }
48023 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48024 {
48025 PyThreadState* __tstate = wxPyBeginAllowThreads();
48026 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
48027 wxPyEndAllowThreads(__tstate);
48028 if (PyErr_Occurred()) SWIG_fail;
48029 }
48030 {
48031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48032 }
48033 return resultobj;
48034 fail:
48035 return NULL;
48036 }
48037
48038
48039 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48040 PyObject *resultobj = 0;
48041 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48042 unsigned int arg2 ;
48043 wxString result;
48044 void *argp1 = 0 ;
48045 int res1 = 0 ;
48046 unsigned int val2 ;
48047 int ecode2 = 0 ;
48048 PyObject * obj0 = 0 ;
48049 PyObject * obj1 = 0 ;
48050 char * kwnames[] = {
48051 (char *) "self",(char *) "n", NULL
48052 };
48053
48054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
48055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48056 if (!SWIG_IsOK(res1)) {
48057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48058 }
48059 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48060 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
48061 if (!SWIG_IsOK(ecode2)) {
48062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
48063 }
48064 arg2 = static_cast< unsigned int >(val2);
48065 {
48066 PyThreadState* __tstate = wxPyBeginAllowThreads();
48067 result = ((wxItemContainer const *)arg1)->GetString(arg2);
48068 wxPyEndAllowThreads(__tstate);
48069 if (PyErr_Occurred()) SWIG_fail;
48070 }
48071 {
48072 #if wxUSE_UNICODE
48073 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48074 #else
48075 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48076 #endif
48077 }
48078 return resultobj;
48079 fail:
48080 return NULL;
48081 }
48082
48083
48084 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48085 PyObject *resultobj = 0;
48086 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48087 wxArrayString result;
48088 void *argp1 = 0 ;
48089 int res1 = 0 ;
48090 PyObject *swig_obj[1] ;
48091
48092 if (!args) SWIG_fail;
48093 swig_obj[0] = args;
48094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48095 if (!SWIG_IsOK(res1)) {
48096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48097 }
48098 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48099 {
48100 PyThreadState* __tstate = wxPyBeginAllowThreads();
48101 result = ((wxItemContainer const *)arg1)->GetStrings();
48102 wxPyEndAllowThreads(__tstate);
48103 if (PyErr_Occurred()) SWIG_fail;
48104 }
48105 {
48106 resultobj = wxArrayString2PyList_helper(result);
48107 }
48108 return resultobj;
48109 fail:
48110 return NULL;
48111 }
48112
48113
48114 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48115 PyObject *resultobj = 0;
48116 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48117 unsigned int arg2 ;
48118 wxString *arg3 = 0 ;
48119 void *argp1 = 0 ;
48120 int res1 = 0 ;
48121 unsigned int val2 ;
48122 int ecode2 = 0 ;
48123 bool temp3 = false ;
48124 PyObject * obj0 = 0 ;
48125 PyObject * obj1 = 0 ;
48126 PyObject * obj2 = 0 ;
48127 char * kwnames[] = {
48128 (char *) "self",(char *) "n",(char *) "s", NULL
48129 };
48130
48131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48133 if (!SWIG_IsOK(res1)) {
48134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48135 }
48136 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48137 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
48138 if (!SWIG_IsOK(ecode2)) {
48139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
48140 }
48141 arg2 = static_cast< unsigned int >(val2);
48142 {
48143 arg3 = wxString_in_helper(obj2);
48144 if (arg3 == NULL) SWIG_fail;
48145 temp3 = true;
48146 }
48147 {
48148 PyThreadState* __tstate = wxPyBeginAllowThreads();
48149 (arg1)->SetString(arg2,(wxString const &)*arg3);
48150 wxPyEndAllowThreads(__tstate);
48151 if (PyErr_Occurred()) SWIG_fail;
48152 }
48153 resultobj = SWIG_Py_Void();
48154 {
48155 if (temp3)
48156 delete arg3;
48157 }
48158 return resultobj;
48159 fail:
48160 {
48161 if (temp3)
48162 delete arg3;
48163 }
48164 return NULL;
48165 }
48166
48167
48168 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48169 PyObject *resultobj = 0;
48170 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48171 wxString *arg2 = 0 ;
48172 int result;
48173 void *argp1 = 0 ;
48174 int res1 = 0 ;
48175 bool temp2 = false ;
48176 PyObject * obj0 = 0 ;
48177 PyObject * obj1 = 0 ;
48178 char * kwnames[] = {
48179 (char *) "self",(char *) "s", NULL
48180 };
48181
48182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
48183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48184 if (!SWIG_IsOK(res1)) {
48185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48186 }
48187 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48188 {
48189 arg2 = wxString_in_helper(obj1);
48190 if (arg2 == NULL) SWIG_fail;
48191 temp2 = true;
48192 }
48193 {
48194 PyThreadState* __tstate = wxPyBeginAllowThreads();
48195 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
48196 wxPyEndAllowThreads(__tstate);
48197 if (PyErr_Occurred()) SWIG_fail;
48198 }
48199 resultobj = SWIG_From_int(static_cast< int >(result));
48200 {
48201 if (temp2)
48202 delete arg2;
48203 }
48204 return resultobj;
48205 fail:
48206 {
48207 if (temp2)
48208 delete arg2;
48209 }
48210 return NULL;
48211 }
48212
48213
48214 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48215 PyObject *resultobj = 0;
48216 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48217 int arg2 ;
48218 void *argp1 = 0 ;
48219 int res1 = 0 ;
48220 int val2 ;
48221 int ecode2 = 0 ;
48222 PyObject * obj0 = 0 ;
48223 PyObject * obj1 = 0 ;
48224 char * kwnames[] = {
48225 (char *) "self",(char *) "n", NULL
48226 };
48227
48228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48230 if (!SWIG_IsOK(res1)) {
48231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48232 }
48233 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48234 ecode2 = SWIG_AsVal_int(obj1, &val2);
48235 if (!SWIG_IsOK(ecode2)) {
48236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
48237 }
48238 arg2 = static_cast< int >(val2);
48239 {
48240 PyThreadState* __tstate = wxPyBeginAllowThreads();
48241 (arg1)->SetSelection(arg2);
48242 wxPyEndAllowThreads(__tstate);
48243 if (PyErr_Occurred()) SWIG_fail;
48244 }
48245 resultobj = SWIG_Py_Void();
48246 return resultobj;
48247 fail:
48248 return NULL;
48249 }
48250
48251
48252 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48253 PyObject *resultobj = 0;
48254 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48255 int result;
48256 void *argp1 = 0 ;
48257 int res1 = 0 ;
48258 PyObject *swig_obj[1] ;
48259
48260 if (!args) SWIG_fail;
48261 swig_obj[0] = args;
48262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48263 if (!SWIG_IsOK(res1)) {
48264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48265 }
48266 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48267 {
48268 PyThreadState* __tstate = wxPyBeginAllowThreads();
48269 result = (int)((wxItemContainer const *)arg1)->GetSelection();
48270 wxPyEndAllowThreads(__tstate);
48271 if (PyErr_Occurred()) SWIG_fail;
48272 }
48273 resultobj = SWIG_From_int(static_cast< int >(result));
48274 return resultobj;
48275 fail:
48276 return NULL;
48277 }
48278
48279
48280 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48281 PyObject *resultobj = 0;
48282 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48283 wxString *arg2 = 0 ;
48284 bool result;
48285 void *argp1 = 0 ;
48286 int res1 = 0 ;
48287 bool temp2 = false ;
48288 PyObject * obj0 = 0 ;
48289 PyObject * obj1 = 0 ;
48290 char * kwnames[] = {
48291 (char *) "self",(char *) "s", NULL
48292 };
48293
48294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48296 if (!SWIG_IsOK(res1)) {
48297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48298 }
48299 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48300 {
48301 arg2 = wxString_in_helper(obj1);
48302 if (arg2 == NULL) SWIG_fail;
48303 temp2 = true;
48304 }
48305 {
48306 PyThreadState* __tstate = wxPyBeginAllowThreads();
48307 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
48308 wxPyEndAllowThreads(__tstate);
48309 if (PyErr_Occurred()) SWIG_fail;
48310 }
48311 {
48312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48313 }
48314 {
48315 if (temp2)
48316 delete arg2;
48317 }
48318 return resultobj;
48319 fail:
48320 {
48321 if (temp2)
48322 delete arg2;
48323 }
48324 return NULL;
48325 }
48326
48327
48328 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48329 PyObject *resultobj = 0;
48330 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48331 wxString result;
48332 void *argp1 = 0 ;
48333 int res1 = 0 ;
48334 PyObject *swig_obj[1] ;
48335
48336 if (!args) SWIG_fail;
48337 swig_obj[0] = args;
48338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48339 if (!SWIG_IsOK(res1)) {
48340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48341 }
48342 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48343 {
48344 PyThreadState* __tstate = wxPyBeginAllowThreads();
48345 result = ((wxItemContainer const *)arg1)->GetStringSelection();
48346 wxPyEndAllowThreads(__tstate);
48347 if (PyErr_Occurred()) SWIG_fail;
48348 }
48349 {
48350 #if wxUSE_UNICODE
48351 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48352 #else
48353 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48354 #endif
48355 }
48356 return resultobj;
48357 fail:
48358 return NULL;
48359 }
48360
48361
48362 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48363 PyObject *resultobj = 0;
48364 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48365 int arg2 ;
48366 void *argp1 = 0 ;
48367 int res1 = 0 ;
48368 int val2 ;
48369 int ecode2 = 0 ;
48370 PyObject * obj0 = 0 ;
48371 PyObject * obj1 = 0 ;
48372 char * kwnames[] = {
48373 (char *) "self",(char *) "n", NULL
48374 };
48375
48376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
48377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48378 if (!SWIG_IsOK(res1)) {
48379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48380 }
48381 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48382 ecode2 = SWIG_AsVal_int(obj1, &val2);
48383 if (!SWIG_IsOK(ecode2)) {
48384 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
48385 }
48386 arg2 = static_cast< int >(val2);
48387 {
48388 PyThreadState* __tstate = wxPyBeginAllowThreads();
48389 (arg1)->Select(arg2);
48390 wxPyEndAllowThreads(__tstate);
48391 if (PyErr_Occurred()) SWIG_fail;
48392 }
48393 resultobj = SWIG_Py_Void();
48394 return resultobj;
48395 fail:
48396 return NULL;
48397 }
48398
48399
48400 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48401 PyObject *obj;
48402 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48403 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
48404 return SWIG_Py_Void();
48405 }
48406
48407 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48408 PyObject *obj;
48409 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48410 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
48411 return SWIG_Py_Void();
48412 }
48413
48414 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48415 PyObject *resultobj = 0;
48416 wxSizerItem *result = 0 ;
48417
48418 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
48419 {
48420 PyThreadState* __tstate = wxPyBeginAllowThreads();
48421 result = (wxSizerItem *)new wxSizerItem();
48422 wxPyEndAllowThreads(__tstate);
48423 if (PyErr_Occurred()) SWIG_fail;
48424 }
48425 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
48426 return resultobj;
48427 fail:
48428 return NULL;
48429 }
48430
48431
48432 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48433 PyObject *resultobj = 0;
48434 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48435 void *argp1 = 0 ;
48436 int res1 = 0 ;
48437 PyObject *swig_obj[1] ;
48438
48439 if (!args) SWIG_fail;
48440 swig_obj[0] = args;
48441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48442 if (!SWIG_IsOK(res1)) {
48443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48444 }
48445 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48446 {
48447 PyThreadState* __tstate = wxPyBeginAllowThreads();
48448 delete arg1;
48449
48450 wxPyEndAllowThreads(__tstate);
48451 if (PyErr_Occurred()) SWIG_fail;
48452 }
48453 resultobj = SWIG_Py_Void();
48454 return resultobj;
48455 fail:
48456 return NULL;
48457 }
48458
48459
48460 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48461 PyObject *resultobj = 0;
48462 wxWindow *arg1 = (wxWindow *) 0 ;
48463 int arg2 ;
48464 int arg3 ;
48465 int arg4 ;
48466 PyObject *arg5 = (PyObject *) NULL ;
48467 wxSizerItem *result = 0 ;
48468 void *argp1 = 0 ;
48469 int res1 = 0 ;
48470 int val2 ;
48471 int ecode2 = 0 ;
48472 int val3 ;
48473 int ecode3 = 0 ;
48474 int val4 ;
48475 int ecode4 = 0 ;
48476 PyObject * obj0 = 0 ;
48477 PyObject * obj1 = 0 ;
48478 PyObject * obj2 = 0 ;
48479 PyObject * obj3 = 0 ;
48480 PyObject * obj4 = 0 ;
48481 char * kwnames[] = {
48482 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48483 };
48484
48485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
48487 if (!SWIG_IsOK(res1)) {
48488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
48489 }
48490 arg1 = reinterpret_cast< wxWindow * >(argp1);
48491 ecode2 = SWIG_AsVal_int(obj1, &val2);
48492 if (!SWIG_IsOK(ecode2)) {
48493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
48494 }
48495 arg2 = static_cast< int >(val2);
48496 ecode3 = SWIG_AsVal_int(obj2, &val3);
48497 if (!SWIG_IsOK(ecode3)) {
48498 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
48499 }
48500 arg3 = static_cast< int >(val3);
48501 ecode4 = SWIG_AsVal_int(obj3, &val4);
48502 if (!SWIG_IsOK(ecode4)) {
48503 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
48504 }
48505 arg4 = static_cast< int >(val4);
48506 if (obj4) {
48507 arg5 = obj4;
48508 }
48509 {
48510 PyThreadState* __tstate = wxPyBeginAllowThreads();
48511 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48512 wxPyEndAllowThreads(__tstate);
48513 if (PyErr_Occurred()) SWIG_fail;
48514 }
48515 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48516 return resultobj;
48517 fail:
48518 return NULL;
48519 }
48520
48521
48522 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48523 PyObject *resultobj = 0;
48524 int arg1 ;
48525 int arg2 ;
48526 int arg3 ;
48527 int arg4 ;
48528 int arg5 ;
48529 PyObject *arg6 = (PyObject *) NULL ;
48530 wxSizerItem *result = 0 ;
48531 int val1 ;
48532 int ecode1 = 0 ;
48533 int val2 ;
48534 int ecode2 = 0 ;
48535 int val3 ;
48536 int ecode3 = 0 ;
48537 int val4 ;
48538 int ecode4 = 0 ;
48539 int val5 ;
48540 int ecode5 = 0 ;
48541 PyObject * obj0 = 0 ;
48542 PyObject * obj1 = 0 ;
48543 PyObject * obj2 = 0 ;
48544 PyObject * obj3 = 0 ;
48545 PyObject * obj4 = 0 ;
48546 PyObject * obj5 = 0 ;
48547 char * kwnames[] = {
48548 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48549 };
48550
48551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
48552 ecode1 = SWIG_AsVal_int(obj0, &val1);
48553 if (!SWIG_IsOK(ecode1)) {
48554 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
48555 }
48556 arg1 = static_cast< int >(val1);
48557 ecode2 = SWIG_AsVal_int(obj1, &val2);
48558 if (!SWIG_IsOK(ecode2)) {
48559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
48560 }
48561 arg2 = static_cast< int >(val2);
48562 ecode3 = SWIG_AsVal_int(obj2, &val3);
48563 if (!SWIG_IsOK(ecode3)) {
48564 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
48565 }
48566 arg3 = static_cast< int >(val3);
48567 ecode4 = SWIG_AsVal_int(obj3, &val4);
48568 if (!SWIG_IsOK(ecode4)) {
48569 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
48570 }
48571 arg4 = static_cast< int >(val4);
48572 ecode5 = SWIG_AsVal_int(obj4, &val5);
48573 if (!SWIG_IsOK(ecode5)) {
48574 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
48575 }
48576 arg5 = static_cast< int >(val5);
48577 if (obj5) {
48578 arg6 = obj5;
48579 }
48580 {
48581 PyThreadState* __tstate = wxPyBeginAllowThreads();
48582 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
48583 wxPyEndAllowThreads(__tstate);
48584 if (PyErr_Occurred()) SWIG_fail;
48585 }
48586 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48587 return resultobj;
48588 fail:
48589 return NULL;
48590 }
48591
48592
48593 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48594 PyObject *resultobj = 0;
48595 wxSizer *arg1 = (wxSizer *) 0 ;
48596 int arg2 ;
48597 int arg3 ;
48598 int arg4 ;
48599 PyObject *arg5 = (PyObject *) NULL ;
48600 wxSizerItem *result = 0 ;
48601 int res1 = 0 ;
48602 int val2 ;
48603 int ecode2 = 0 ;
48604 int val3 ;
48605 int ecode3 = 0 ;
48606 int val4 ;
48607 int ecode4 = 0 ;
48608 PyObject * obj0 = 0 ;
48609 PyObject * obj1 = 0 ;
48610 PyObject * obj2 = 0 ;
48611 PyObject * obj3 = 0 ;
48612 PyObject * obj4 = 0 ;
48613 char * kwnames[] = {
48614 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48615 };
48616
48617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48618 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
48619 if (!SWIG_IsOK(res1)) {
48620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
48621 }
48622 ecode2 = SWIG_AsVal_int(obj1, &val2);
48623 if (!SWIG_IsOK(ecode2)) {
48624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
48625 }
48626 arg2 = static_cast< int >(val2);
48627 ecode3 = SWIG_AsVal_int(obj2, &val3);
48628 if (!SWIG_IsOK(ecode3)) {
48629 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
48630 }
48631 arg3 = static_cast< int >(val3);
48632 ecode4 = SWIG_AsVal_int(obj3, &val4);
48633 if (!SWIG_IsOK(ecode4)) {
48634 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
48635 }
48636 arg4 = static_cast< int >(val4);
48637 if (obj4) {
48638 arg5 = obj4;
48639 }
48640 {
48641 PyThreadState* __tstate = wxPyBeginAllowThreads();
48642 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48643 wxPyEndAllowThreads(__tstate);
48644 if (PyErr_Occurred()) SWIG_fail;
48645 }
48646 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48647 return resultobj;
48648 fail:
48649 return NULL;
48650 }
48651
48652
48653 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48654 PyObject *resultobj = 0;
48655 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48656 void *argp1 = 0 ;
48657 int res1 = 0 ;
48658 PyObject *swig_obj[1] ;
48659
48660 if (!args) SWIG_fail;
48661 swig_obj[0] = args;
48662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48663 if (!SWIG_IsOK(res1)) {
48664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48665 }
48666 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48667 {
48668 PyThreadState* __tstate = wxPyBeginAllowThreads();
48669 (arg1)->DeleteWindows();
48670 wxPyEndAllowThreads(__tstate);
48671 if (PyErr_Occurred()) SWIG_fail;
48672 }
48673 resultobj = SWIG_Py_Void();
48674 return resultobj;
48675 fail:
48676 return NULL;
48677 }
48678
48679
48680 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48681 PyObject *resultobj = 0;
48682 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48683 void *argp1 = 0 ;
48684 int res1 = 0 ;
48685 PyObject *swig_obj[1] ;
48686
48687 if (!args) SWIG_fail;
48688 swig_obj[0] = args;
48689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48690 if (!SWIG_IsOK(res1)) {
48691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48692 }
48693 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48694 {
48695 PyThreadState* __tstate = wxPyBeginAllowThreads();
48696 (arg1)->DetachSizer();
48697 wxPyEndAllowThreads(__tstate);
48698 if (PyErr_Occurred()) SWIG_fail;
48699 }
48700 resultobj = SWIG_Py_Void();
48701 return resultobj;
48702 fail:
48703 return NULL;
48704 }
48705
48706
48707 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48708 PyObject *resultobj = 0;
48709 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48710 wxSize result;
48711 void *argp1 = 0 ;
48712 int res1 = 0 ;
48713 PyObject *swig_obj[1] ;
48714
48715 if (!args) SWIG_fail;
48716 swig_obj[0] = args;
48717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48718 if (!SWIG_IsOK(res1)) {
48719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48720 }
48721 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48722 {
48723 PyThreadState* __tstate = wxPyBeginAllowThreads();
48724 result = (arg1)->GetSize();
48725 wxPyEndAllowThreads(__tstate);
48726 if (PyErr_Occurred()) SWIG_fail;
48727 }
48728 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48729 return resultobj;
48730 fail:
48731 return NULL;
48732 }
48733
48734
48735 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48736 PyObject *resultobj = 0;
48737 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48738 wxSize result;
48739 void *argp1 = 0 ;
48740 int res1 = 0 ;
48741 PyObject *swig_obj[1] ;
48742
48743 if (!args) SWIG_fail;
48744 swig_obj[0] = args;
48745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48746 if (!SWIG_IsOK(res1)) {
48747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48748 }
48749 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48750 {
48751 PyThreadState* __tstate = wxPyBeginAllowThreads();
48752 result = (arg1)->CalcMin();
48753 wxPyEndAllowThreads(__tstate);
48754 if (PyErr_Occurred()) SWIG_fail;
48755 }
48756 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48757 return resultobj;
48758 fail:
48759 return NULL;
48760 }
48761
48762
48763 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48764 PyObject *resultobj = 0;
48765 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48766 wxPoint *arg2 = 0 ;
48767 wxSize *arg3 = 0 ;
48768 void *argp1 = 0 ;
48769 int res1 = 0 ;
48770 wxPoint temp2 ;
48771 wxSize temp3 ;
48772 PyObject * obj0 = 0 ;
48773 PyObject * obj1 = 0 ;
48774 PyObject * obj2 = 0 ;
48775 char * kwnames[] = {
48776 (char *) "self",(char *) "pos",(char *) "size", NULL
48777 };
48778
48779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48781 if (!SWIG_IsOK(res1)) {
48782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48783 }
48784 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48785 {
48786 arg2 = &temp2;
48787 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
48788 }
48789 {
48790 arg3 = &temp3;
48791 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
48792 }
48793 {
48794 PyThreadState* __tstate = wxPyBeginAllowThreads();
48795 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
48796 wxPyEndAllowThreads(__tstate);
48797 if (PyErr_Occurred()) SWIG_fail;
48798 }
48799 resultobj = SWIG_Py_Void();
48800 return resultobj;
48801 fail:
48802 return NULL;
48803 }
48804
48805
48806 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48807 PyObject *resultobj = 0;
48808 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48809 wxSize result;
48810 void *argp1 = 0 ;
48811 int res1 = 0 ;
48812 PyObject *swig_obj[1] ;
48813
48814 if (!args) SWIG_fail;
48815 swig_obj[0] = args;
48816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48817 if (!SWIG_IsOK(res1)) {
48818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48819 }
48820 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48821 {
48822 PyThreadState* __tstate = wxPyBeginAllowThreads();
48823 result = (arg1)->GetMinSize();
48824 wxPyEndAllowThreads(__tstate);
48825 if (PyErr_Occurred()) SWIG_fail;
48826 }
48827 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48828 return resultobj;
48829 fail:
48830 return NULL;
48831 }
48832
48833
48834 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48835 PyObject *resultobj = 0;
48836 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48837 wxSize result;
48838 void *argp1 = 0 ;
48839 int res1 = 0 ;
48840 PyObject *swig_obj[1] ;
48841
48842 if (!args) SWIG_fail;
48843 swig_obj[0] = args;
48844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48845 if (!SWIG_IsOK(res1)) {
48846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
48847 }
48848 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48849 {
48850 PyThreadState* __tstate = wxPyBeginAllowThreads();
48851 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
48852 wxPyEndAllowThreads(__tstate);
48853 if (PyErr_Occurred()) SWIG_fail;
48854 }
48855 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48856 return resultobj;
48857 fail:
48858 return NULL;
48859 }
48860
48861
48862 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48863 PyObject *resultobj = 0;
48864 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48865 int arg2 ;
48866 int arg3 ;
48867 void *argp1 = 0 ;
48868 int res1 = 0 ;
48869 int val2 ;
48870 int ecode2 = 0 ;
48871 int val3 ;
48872 int ecode3 = 0 ;
48873 PyObject * obj0 = 0 ;
48874 PyObject * obj1 = 0 ;
48875 PyObject * obj2 = 0 ;
48876 char * kwnames[] = {
48877 (char *) "self",(char *) "x",(char *) "y", NULL
48878 };
48879
48880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48882 if (!SWIG_IsOK(res1)) {
48883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48884 }
48885 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48886 ecode2 = SWIG_AsVal_int(obj1, &val2);
48887 if (!SWIG_IsOK(ecode2)) {
48888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
48889 }
48890 arg2 = static_cast< int >(val2);
48891 ecode3 = SWIG_AsVal_int(obj2, &val3);
48892 if (!SWIG_IsOK(ecode3)) {
48893 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
48894 }
48895 arg3 = static_cast< int >(val3);
48896 {
48897 PyThreadState* __tstate = wxPyBeginAllowThreads();
48898 (arg1)->SetInitSize(arg2,arg3);
48899 wxPyEndAllowThreads(__tstate);
48900 if (PyErr_Occurred()) SWIG_fail;
48901 }
48902 resultobj = SWIG_Py_Void();
48903 return resultobj;
48904 fail:
48905 return NULL;
48906 }
48907
48908
48909 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48910 PyObject *resultobj = 0;
48911 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48912 int arg2 ;
48913 int arg3 ;
48914 void *argp1 = 0 ;
48915 int res1 = 0 ;
48916 int val2 ;
48917 int ecode2 = 0 ;
48918 int val3 ;
48919 int ecode3 = 0 ;
48920 PyObject * obj0 = 0 ;
48921 PyObject * obj1 = 0 ;
48922 PyObject * obj2 = 0 ;
48923 char * kwnames[] = {
48924 (char *) "self",(char *) "width",(char *) "height", NULL
48925 };
48926
48927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48929 if (!SWIG_IsOK(res1)) {
48930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48931 }
48932 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48933 ecode2 = SWIG_AsVal_int(obj1, &val2);
48934 if (!SWIG_IsOK(ecode2)) {
48935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
48936 }
48937 arg2 = static_cast< int >(val2);
48938 ecode3 = SWIG_AsVal_int(obj2, &val3);
48939 if (!SWIG_IsOK(ecode3)) {
48940 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
48941 }
48942 arg3 = static_cast< int >(val3);
48943 {
48944 PyThreadState* __tstate = wxPyBeginAllowThreads();
48945 (arg1)->SetRatio(arg2,arg3);
48946 wxPyEndAllowThreads(__tstate);
48947 if (PyErr_Occurred()) SWIG_fail;
48948 }
48949 resultobj = SWIG_Py_Void();
48950 return resultobj;
48951 fail:
48952 return NULL;
48953 }
48954
48955
48956 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48957 PyObject *resultobj = 0;
48958 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48959 wxSize *arg2 = 0 ;
48960 void *argp1 = 0 ;
48961 int res1 = 0 ;
48962 wxSize temp2 ;
48963 PyObject * obj0 = 0 ;
48964 PyObject * obj1 = 0 ;
48965 char * kwnames[] = {
48966 (char *) "self",(char *) "size", NULL
48967 };
48968
48969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
48970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48971 if (!SWIG_IsOK(res1)) {
48972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48973 }
48974 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48975 {
48976 arg2 = &temp2;
48977 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
48978 }
48979 {
48980 PyThreadState* __tstate = wxPyBeginAllowThreads();
48981 (arg1)->SetRatio((wxSize const &)*arg2);
48982 wxPyEndAllowThreads(__tstate);
48983 if (PyErr_Occurred()) SWIG_fail;
48984 }
48985 resultobj = SWIG_Py_Void();
48986 return resultobj;
48987 fail:
48988 return NULL;
48989 }
48990
48991
48992 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48993 PyObject *resultobj = 0;
48994 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48995 float arg2 ;
48996 void *argp1 = 0 ;
48997 int res1 = 0 ;
48998 float val2 ;
48999 int ecode2 = 0 ;
49000 PyObject * obj0 = 0 ;
49001 PyObject * obj1 = 0 ;
49002 char * kwnames[] = {
49003 (char *) "self",(char *) "ratio", NULL
49004 };
49005
49006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
49007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49008 if (!SWIG_IsOK(res1)) {
49009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49010 }
49011 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49012 ecode2 = SWIG_AsVal_float(obj1, &val2);
49013 if (!SWIG_IsOK(ecode2)) {
49014 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
49015 }
49016 arg2 = static_cast< float >(val2);
49017 {
49018 PyThreadState* __tstate = wxPyBeginAllowThreads();
49019 (arg1)->SetRatio(arg2);
49020 wxPyEndAllowThreads(__tstate);
49021 if (PyErr_Occurred()) SWIG_fail;
49022 }
49023 resultobj = SWIG_Py_Void();
49024 return resultobj;
49025 fail:
49026 return NULL;
49027 }
49028
49029
49030 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49031 PyObject *resultobj = 0;
49032 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49033 float result;
49034 void *argp1 = 0 ;
49035 int res1 = 0 ;
49036 PyObject *swig_obj[1] ;
49037
49038 if (!args) SWIG_fail;
49039 swig_obj[0] = args;
49040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49041 if (!SWIG_IsOK(res1)) {
49042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49043 }
49044 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49045 {
49046 PyThreadState* __tstate = wxPyBeginAllowThreads();
49047 result = (float)(arg1)->GetRatio();
49048 wxPyEndAllowThreads(__tstate);
49049 if (PyErr_Occurred()) SWIG_fail;
49050 }
49051 resultobj = SWIG_From_float(static_cast< float >(result));
49052 return resultobj;
49053 fail:
49054 return NULL;
49055 }
49056
49057
49058 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49059 PyObject *resultobj = 0;
49060 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49061 wxRect result;
49062 void *argp1 = 0 ;
49063 int res1 = 0 ;
49064 PyObject *swig_obj[1] ;
49065
49066 if (!args) SWIG_fail;
49067 swig_obj[0] = args;
49068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49069 if (!SWIG_IsOK(res1)) {
49070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49071 }
49072 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49073 {
49074 PyThreadState* __tstate = wxPyBeginAllowThreads();
49075 result = (arg1)->GetRect();
49076 wxPyEndAllowThreads(__tstate);
49077 if (PyErr_Occurred()) SWIG_fail;
49078 }
49079 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
49080 return resultobj;
49081 fail:
49082 return NULL;
49083 }
49084
49085
49086 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49087 PyObject *resultobj = 0;
49088 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49089 bool result;
49090 void *argp1 = 0 ;
49091 int res1 = 0 ;
49092 PyObject *swig_obj[1] ;
49093
49094 if (!args) SWIG_fail;
49095 swig_obj[0] = args;
49096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49097 if (!SWIG_IsOK(res1)) {
49098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49099 }
49100 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49101 {
49102 PyThreadState* __tstate = wxPyBeginAllowThreads();
49103 result = (bool)(arg1)->IsWindow();
49104 wxPyEndAllowThreads(__tstate);
49105 if (PyErr_Occurred()) SWIG_fail;
49106 }
49107 {
49108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49109 }
49110 return resultobj;
49111 fail:
49112 return NULL;
49113 }
49114
49115
49116 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49117 PyObject *resultobj = 0;
49118 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49119 bool result;
49120 void *argp1 = 0 ;
49121 int res1 = 0 ;
49122 PyObject *swig_obj[1] ;
49123
49124 if (!args) SWIG_fail;
49125 swig_obj[0] = args;
49126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49127 if (!SWIG_IsOK(res1)) {
49128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49129 }
49130 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49131 {
49132 PyThreadState* __tstate = wxPyBeginAllowThreads();
49133 result = (bool)(arg1)->IsSizer();
49134 wxPyEndAllowThreads(__tstate);
49135 if (PyErr_Occurred()) SWIG_fail;
49136 }
49137 {
49138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49139 }
49140 return resultobj;
49141 fail:
49142 return NULL;
49143 }
49144
49145
49146 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49147 PyObject *resultobj = 0;
49148 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49149 bool result;
49150 void *argp1 = 0 ;
49151 int res1 = 0 ;
49152 PyObject *swig_obj[1] ;
49153
49154 if (!args) SWIG_fail;
49155 swig_obj[0] = args;
49156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49157 if (!SWIG_IsOK(res1)) {
49158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49159 }
49160 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49161 {
49162 PyThreadState* __tstate = wxPyBeginAllowThreads();
49163 result = (bool)(arg1)->IsSpacer();
49164 wxPyEndAllowThreads(__tstate);
49165 if (PyErr_Occurred()) SWIG_fail;
49166 }
49167 {
49168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49169 }
49170 return resultobj;
49171 fail:
49172 return NULL;
49173 }
49174
49175
49176 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49177 PyObject *resultobj = 0;
49178 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49179 int arg2 ;
49180 void *argp1 = 0 ;
49181 int res1 = 0 ;
49182 int val2 ;
49183 int ecode2 = 0 ;
49184 PyObject * obj0 = 0 ;
49185 PyObject * obj1 = 0 ;
49186 char * kwnames[] = {
49187 (char *) "self",(char *) "proportion", NULL
49188 };
49189
49190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
49191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49192 if (!SWIG_IsOK(res1)) {
49193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49194 }
49195 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49196 ecode2 = SWIG_AsVal_int(obj1, &val2);
49197 if (!SWIG_IsOK(ecode2)) {
49198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
49199 }
49200 arg2 = static_cast< int >(val2);
49201 {
49202 PyThreadState* __tstate = wxPyBeginAllowThreads();
49203 (arg1)->SetProportion(arg2);
49204 wxPyEndAllowThreads(__tstate);
49205 if (PyErr_Occurred()) SWIG_fail;
49206 }
49207 resultobj = SWIG_Py_Void();
49208 return resultobj;
49209 fail:
49210 return NULL;
49211 }
49212
49213
49214 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49215 PyObject *resultobj = 0;
49216 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49217 int result;
49218 void *argp1 = 0 ;
49219 int res1 = 0 ;
49220 PyObject *swig_obj[1] ;
49221
49222 if (!args) SWIG_fail;
49223 swig_obj[0] = args;
49224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49225 if (!SWIG_IsOK(res1)) {
49226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49227 }
49228 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49229 {
49230 PyThreadState* __tstate = wxPyBeginAllowThreads();
49231 result = (int)(arg1)->GetProportion();
49232 wxPyEndAllowThreads(__tstate);
49233 if (PyErr_Occurred()) SWIG_fail;
49234 }
49235 resultobj = SWIG_From_int(static_cast< int >(result));
49236 return resultobj;
49237 fail:
49238 return NULL;
49239 }
49240
49241
49242 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49243 PyObject *resultobj = 0;
49244 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49245 int arg2 ;
49246 void *argp1 = 0 ;
49247 int res1 = 0 ;
49248 int val2 ;
49249 int ecode2 = 0 ;
49250 PyObject * obj0 = 0 ;
49251 PyObject * obj1 = 0 ;
49252 char * kwnames[] = {
49253 (char *) "self",(char *) "flag", NULL
49254 };
49255
49256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
49257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49258 if (!SWIG_IsOK(res1)) {
49259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49260 }
49261 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49262 ecode2 = SWIG_AsVal_int(obj1, &val2);
49263 if (!SWIG_IsOK(ecode2)) {
49264 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
49265 }
49266 arg2 = static_cast< int >(val2);
49267 {
49268 PyThreadState* __tstate = wxPyBeginAllowThreads();
49269 (arg1)->SetFlag(arg2);
49270 wxPyEndAllowThreads(__tstate);
49271 if (PyErr_Occurred()) SWIG_fail;
49272 }
49273 resultobj = SWIG_Py_Void();
49274 return resultobj;
49275 fail:
49276 return NULL;
49277 }
49278
49279
49280 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49281 PyObject *resultobj = 0;
49282 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49283 int result;
49284 void *argp1 = 0 ;
49285 int res1 = 0 ;
49286 PyObject *swig_obj[1] ;
49287
49288 if (!args) SWIG_fail;
49289 swig_obj[0] = args;
49290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49291 if (!SWIG_IsOK(res1)) {
49292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49293 }
49294 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49295 {
49296 PyThreadState* __tstate = wxPyBeginAllowThreads();
49297 result = (int)(arg1)->GetFlag();
49298 wxPyEndAllowThreads(__tstate);
49299 if (PyErr_Occurred()) SWIG_fail;
49300 }
49301 resultobj = SWIG_From_int(static_cast< int >(result));
49302 return resultobj;
49303 fail:
49304 return NULL;
49305 }
49306
49307
49308 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49309 PyObject *resultobj = 0;
49310 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49311 int arg2 ;
49312 void *argp1 = 0 ;
49313 int res1 = 0 ;
49314 int val2 ;
49315 int ecode2 = 0 ;
49316 PyObject * obj0 = 0 ;
49317 PyObject * obj1 = 0 ;
49318 char * kwnames[] = {
49319 (char *) "self",(char *) "border", NULL
49320 };
49321
49322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49324 if (!SWIG_IsOK(res1)) {
49325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49326 }
49327 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49328 ecode2 = SWIG_AsVal_int(obj1, &val2);
49329 if (!SWIG_IsOK(ecode2)) {
49330 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
49331 }
49332 arg2 = static_cast< int >(val2);
49333 {
49334 PyThreadState* __tstate = wxPyBeginAllowThreads();
49335 (arg1)->SetBorder(arg2);
49336 wxPyEndAllowThreads(__tstate);
49337 if (PyErr_Occurred()) SWIG_fail;
49338 }
49339 resultobj = SWIG_Py_Void();
49340 return resultobj;
49341 fail:
49342 return NULL;
49343 }
49344
49345
49346 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49347 PyObject *resultobj = 0;
49348 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49349 int result;
49350 void *argp1 = 0 ;
49351 int res1 = 0 ;
49352 PyObject *swig_obj[1] ;
49353
49354 if (!args) SWIG_fail;
49355 swig_obj[0] = args;
49356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49357 if (!SWIG_IsOK(res1)) {
49358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49359 }
49360 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49361 {
49362 PyThreadState* __tstate = wxPyBeginAllowThreads();
49363 result = (int)(arg1)->GetBorder();
49364 wxPyEndAllowThreads(__tstate);
49365 if (PyErr_Occurred()) SWIG_fail;
49366 }
49367 resultobj = SWIG_From_int(static_cast< int >(result));
49368 return resultobj;
49369 fail:
49370 return NULL;
49371 }
49372
49373
49374 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49375 PyObject *resultobj = 0;
49376 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49377 wxWindow *result = 0 ;
49378 void *argp1 = 0 ;
49379 int res1 = 0 ;
49380 PyObject *swig_obj[1] ;
49381
49382 if (!args) SWIG_fail;
49383 swig_obj[0] = args;
49384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49385 if (!SWIG_IsOK(res1)) {
49386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49387 }
49388 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49389 {
49390 PyThreadState* __tstate = wxPyBeginAllowThreads();
49391 result = (wxWindow *)(arg1)->GetWindow();
49392 wxPyEndAllowThreads(__tstate);
49393 if (PyErr_Occurred()) SWIG_fail;
49394 }
49395 {
49396 resultobj = wxPyMake_wxObject(result, 0);
49397 }
49398 return resultobj;
49399 fail:
49400 return NULL;
49401 }
49402
49403
49404 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49405 PyObject *resultobj = 0;
49406 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49407 wxWindow *arg2 = (wxWindow *) 0 ;
49408 void *argp1 = 0 ;
49409 int res1 = 0 ;
49410 void *argp2 = 0 ;
49411 int res2 = 0 ;
49412 PyObject * obj0 = 0 ;
49413 PyObject * obj1 = 0 ;
49414 char * kwnames[] = {
49415 (char *) "self",(char *) "window", NULL
49416 };
49417
49418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
49419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49420 if (!SWIG_IsOK(res1)) {
49421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49422 }
49423 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49424 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
49425 if (!SWIG_IsOK(res2)) {
49426 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
49427 }
49428 arg2 = reinterpret_cast< wxWindow * >(argp2);
49429 {
49430 PyThreadState* __tstate = wxPyBeginAllowThreads();
49431 (arg1)->SetWindow(arg2);
49432 wxPyEndAllowThreads(__tstate);
49433 if (PyErr_Occurred()) SWIG_fail;
49434 }
49435 resultobj = SWIG_Py_Void();
49436 return resultobj;
49437 fail:
49438 return NULL;
49439 }
49440
49441
49442 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49443 PyObject *resultobj = 0;
49444 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49445 wxSizer *result = 0 ;
49446 void *argp1 = 0 ;
49447 int res1 = 0 ;
49448 PyObject *swig_obj[1] ;
49449
49450 if (!args) SWIG_fail;
49451 swig_obj[0] = args;
49452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49453 if (!SWIG_IsOK(res1)) {
49454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49455 }
49456 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49457 {
49458 PyThreadState* __tstate = wxPyBeginAllowThreads();
49459 result = (wxSizer *)(arg1)->GetSizer();
49460 wxPyEndAllowThreads(__tstate);
49461 if (PyErr_Occurred()) SWIG_fail;
49462 }
49463 {
49464 resultobj = wxPyMake_wxObject(result, (bool)0);
49465 }
49466 return resultobj;
49467 fail:
49468 return NULL;
49469 }
49470
49471
49472 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49473 PyObject *resultobj = 0;
49474 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49475 wxSizer *arg2 = (wxSizer *) 0 ;
49476 void *argp1 = 0 ;
49477 int res1 = 0 ;
49478 int res2 = 0 ;
49479 PyObject * obj0 = 0 ;
49480 PyObject * obj1 = 0 ;
49481 char * kwnames[] = {
49482 (char *) "self",(char *) "sizer", NULL
49483 };
49484
49485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49487 if (!SWIG_IsOK(res1)) {
49488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49489 }
49490 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49491 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49492 if (!SWIG_IsOK(res2)) {
49493 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
49494 }
49495 {
49496 PyThreadState* __tstate = wxPyBeginAllowThreads();
49497 (arg1)->SetSizer(arg2);
49498 wxPyEndAllowThreads(__tstate);
49499 if (PyErr_Occurred()) SWIG_fail;
49500 }
49501 resultobj = SWIG_Py_Void();
49502 return resultobj;
49503 fail:
49504 return NULL;
49505 }
49506
49507
49508 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49509 PyObject *resultobj = 0;
49510 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49511 wxSize result;
49512 void *argp1 = 0 ;
49513 int res1 = 0 ;
49514 PyObject *swig_obj[1] ;
49515
49516 if (!args) SWIG_fail;
49517 swig_obj[0] = args;
49518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49519 if (!SWIG_IsOK(res1)) {
49520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49521 }
49522 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49523 {
49524 PyThreadState* __tstate = wxPyBeginAllowThreads();
49525 result = (arg1)->GetSpacer();
49526 wxPyEndAllowThreads(__tstate);
49527 if (PyErr_Occurred()) SWIG_fail;
49528 }
49529 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49530 return resultobj;
49531 fail:
49532 return NULL;
49533 }
49534
49535
49536 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49537 PyObject *resultobj = 0;
49538 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49539 wxSize *arg2 = 0 ;
49540 void *argp1 = 0 ;
49541 int res1 = 0 ;
49542 wxSize temp2 ;
49543 PyObject * obj0 = 0 ;
49544 PyObject * obj1 = 0 ;
49545 char * kwnames[] = {
49546 (char *) "self",(char *) "size", NULL
49547 };
49548
49549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
49550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49551 if (!SWIG_IsOK(res1)) {
49552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49553 }
49554 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49555 {
49556 arg2 = &temp2;
49557 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
49558 }
49559 {
49560 PyThreadState* __tstate = wxPyBeginAllowThreads();
49561 (arg1)->SetSpacer((wxSize const &)*arg2);
49562 wxPyEndAllowThreads(__tstate);
49563 if (PyErr_Occurred()) SWIG_fail;
49564 }
49565 resultobj = SWIG_Py_Void();
49566 return resultobj;
49567 fail:
49568 return NULL;
49569 }
49570
49571
49572 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49573 PyObject *resultobj = 0;
49574 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49575 bool arg2 ;
49576 void *argp1 = 0 ;
49577 int res1 = 0 ;
49578 bool val2 ;
49579 int ecode2 = 0 ;
49580 PyObject * obj0 = 0 ;
49581 PyObject * obj1 = 0 ;
49582 char * kwnames[] = {
49583 (char *) "self",(char *) "show", NULL
49584 };
49585
49586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
49587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49588 if (!SWIG_IsOK(res1)) {
49589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49590 }
49591 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49592 ecode2 = SWIG_AsVal_bool(obj1, &val2);
49593 if (!SWIG_IsOK(ecode2)) {
49594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
49595 }
49596 arg2 = static_cast< bool >(val2);
49597 {
49598 PyThreadState* __tstate = wxPyBeginAllowThreads();
49599 (arg1)->Show(arg2);
49600 wxPyEndAllowThreads(__tstate);
49601 if (PyErr_Occurred()) SWIG_fail;
49602 }
49603 resultobj = SWIG_Py_Void();
49604 return resultobj;
49605 fail:
49606 return NULL;
49607 }
49608
49609
49610 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49611 PyObject *resultobj = 0;
49612 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49613 bool result;
49614 void *argp1 = 0 ;
49615 int res1 = 0 ;
49616 PyObject *swig_obj[1] ;
49617
49618 if (!args) SWIG_fail;
49619 swig_obj[0] = args;
49620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49621 if (!SWIG_IsOK(res1)) {
49622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49623 }
49624 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49625 {
49626 PyThreadState* __tstate = wxPyBeginAllowThreads();
49627 result = (bool)(arg1)->IsShown();
49628 wxPyEndAllowThreads(__tstate);
49629 if (PyErr_Occurred()) SWIG_fail;
49630 }
49631 {
49632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49633 }
49634 return resultobj;
49635 fail:
49636 return NULL;
49637 }
49638
49639
49640 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49641 PyObject *resultobj = 0;
49642 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49643 wxPoint result;
49644 void *argp1 = 0 ;
49645 int res1 = 0 ;
49646 PyObject *swig_obj[1] ;
49647
49648 if (!args) SWIG_fail;
49649 swig_obj[0] = args;
49650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49651 if (!SWIG_IsOK(res1)) {
49652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49653 }
49654 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49655 {
49656 PyThreadState* __tstate = wxPyBeginAllowThreads();
49657 result = (arg1)->GetPosition();
49658 wxPyEndAllowThreads(__tstate);
49659 if (PyErr_Occurred()) SWIG_fail;
49660 }
49661 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
49662 return resultobj;
49663 fail:
49664 return NULL;
49665 }
49666
49667
49668 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49669 PyObject *resultobj = 0;
49670 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49671 PyObject *result = 0 ;
49672 void *argp1 = 0 ;
49673 int res1 = 0 ;
49674 PyObject *swig_obj[1] ;
49675
49676 if (!args) SWIG_fail;
49677 swig_obj[0] = args;
49678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49679 if (!SWIG_IsOK(res1)) {
49680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49681 }
49682 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49683 {
49684 PyThreadState* __tstate = wxPyBeginAllowThreads();
49685 result = (PyObject *)wxSizerItem_GetUserData(arg1);
49686 wxPyEndAllowThreads(__tstate);
49687 if (PyErr_Occurred()) SWIG_fail;
49688 }
49689 resultobj = result;
49690 return resultobj;
49691 fail:
49692 return NULL;
49693 }
49694
49695
49696 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49697 PyObject *resultobj = 0;
49698 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49699 PyObject *arg2 = (PyObject *) 0 ;
49700 void *argp1 = 0 ;
49701 int res1 = 0 ;
49702 PyObject * obj0 = 0 ;
49703 PyObject * obj1 = 0 ;
49704 char * kwnames[] = {
49705 (char *) "self",(char *) "userData", NULL
49706 };
49707
49708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
49709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49710 if (!SWIG_IsOK(res1)) {
49711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49712 }
49713 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49714 arg2 = obj1;
49715 {
49716 PyThreadState* __tstate = wxPyBeginAllowThreads();
49717 wxSizerItem_SetUserData(arg1,arg2);
49718 wxPyEndAllowThreads(__tstate);
49719 if (PyErr_Occurred()) SWIG_fail;
49720 }
49721 resultobj = SWIG_Py_Void();
49722 return resultobj;
49723 fail:
49724 return NULL;
49725 }
49726
49727
49728 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49729 PyObject *obj;
49730 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49731 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
49732 return SWIG_Py_Void();
49733 }
49734
49735 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49736 return SWIG_Python_InitShadowInstance(args);
49737 }
49738
49739 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49740 PyObject *resultobj = 0;
49741 wxSizer *arg1 = (wxSizer *) 0 ;
49742 void *argp1 = 0 ;
49743 int res1 = 0 ;
49744 PyObject *swig_obj[1] ;
49745
49746 if (!args) SWIG_fail;
49747 swig_obj[0] = args;
49748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49749 if (!SWIG_IsOK(res1)) {
49750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49751 }
49752 arg1 = reinterpret_cast< wxSizer * >(argp1);
49753 {
49754 PyThreadState* __tstate = wxPyBeginAllowThreads();
49755 delete arg1;
49756
49757 wxPyEndAllowThreads(__tstate);
49758 if (PyErr_Occurred()) SWIG_fail;
49759 }
49760 resultobj = SWIG_Py_Void();
49761 return resultobj;
49762 fail:
49763 return NULL;
49764 }
49765
49766
49767 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49768 PyObject *resultobj = 0;
49769 wxSizer *arg1 = (wxSizer *) 0 ;
49770 PyObject *arg2 = (PyObject *) 0 ;
49771 void *argp1 = 0 ;
49772 int res1 = 0 ;
49773 PyObject * obj0 = 0 ;
49774 PyObject * obj1 = 0 ;
49775 char * kwnames[] = {
49776 (char *) "self",(char *) "_self", NULL
49777 };
49778
49779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
49780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49781 if (!SWIG_IsOK(res1)) {
49782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
49783 }
49784 arg1 = reinterpret_cast< wxSizer * >(argp1);
49785 arg2 = obj1;
49786 {
49787 PyThreadState* __tstate = wxPyBeginAllowThreads();
49788 wxSizer__setOORInfo(arg1,arg2);
49789 wxPyEndAllowThreads(__tstate);
49790 if (PyErr_Occurred()) SWIG_fail;
49791 }
49792 resultobj = SWIG_Py_Void();
49793 return resultobj;
49794 fail:
49795 return NULL;
49796 }
49797
49798
49799 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49800 PyObject *resultobj = 0;
49801 wxSizer *arg1 = (wxSizer *) 0 ;
49802 PyObject *arg2 = (PyObject *) 0 ;
49803 int arg3 = (int) 0 ;
49804 int arg4 = (int) 0 ;
49805 int arg5 = (int) 0 ;
49806 PyObject *arg6 = (PyObject *) NULL ;
49807 wxSizerItem *result = 0 ;
49808 void *argp1 = 0 ;
49809 int res1 = 0 ;
49810 int val3 ;
49811 int ecode3 = 0 ;
49812 int val4 ;
49813 int ecode4 = 0 ;
49814 int val5 ;
49815 int ecode5 = 0 ;
49816 PyObject * obj0 = 0 ;
49817 PyObject * obj1 = 0 ;
49818 PyObject * obj2 = 0 ;
49819 PyObject * obj3 = 0 ;
49820 PyObject * obj4 = 0 ;
49821 PyObject * obj5 = 0 ;
49822 char * kwnames[] = {
49823 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49824 };
49825
49826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49828 if (!SWIG_IsOK(res1)) {
49829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
49830 }
49831 arg1 = reinterpret_cast< wxSizer * >(argp1);
49832 arg2 = obj1;
49833 if (obj2) {
49834 ecode3 = SWIG_AsVal_int(obj2, &val3);
49835 if (!SWIG_IsOK(ecode3)) {
49836 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
49837 }
49838 arg3 = static_cast< int >(val3);
49839 }
49840 if (obj3) {
49841 ecode4 = SWIG_AsVal_int(obj3, &val4);
49842 if (!SWIG_IsOK(ecode4)) {
49843 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
49844 }
49845 arg4 = static_cast< int >(val4);
49846 }
49847 if (obj4) {
49848 ecode5 = SWIG_AsVal_int(obj4, &val5);
49849 if (!SWIG_IsOK(ecode5)) {
49850 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
49851 }
49852 arg5 = static_cast< int >(val5);
49853 }
49854 if (obj5) {
49855 arg6 = obj5;
49856 }
49857 {
49858 PyThreadState* __tstate = wxPyBeginAllowThreads();
49859 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
49860 wxPyEndAllowThreads(__tstate);
49861 if (PyErr_Occurred()) SWIG_fail;
49862 }
49863 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49864 return resultobj;
49865 fail:
49866 return NULL;
49867 }
49868
49869
49870 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49871 PyObject *resultobj = 0;
49872 wxSizer *arg1 = (wxSizer *) 0 ;
49873 int arg2 ;
49874 PyObject *arg3 = (PyObject *) 0 ;
49875 int arg4 = (int) 0 ;
49876 int arg5 = (int) 0 ;
49877 int arg6 = (int) 0 ;
49878 PyObject *arg7 = (PyObject *) NULL ;
49879 wxSizerItem *result = 0 ;
49880 void *argp1 = 0 ;
49881 int res1 = 0 ;
49882 int val2 ;
49883 int ecode2 = 0 ;
49884 int val4 ;
49885 int ecode4 = 0 ;
49886 int val5 ;
49887 int ecode5 = 0 ;
49888 int val6 ;
49889 int ecode6 = 0 ;
49890 PyObject * obj0 = 0 ;
49891 PyObject * obj1 = 0 ;
49892 PyObject * obj2 = 0 ;
49893 PyObject * obj3 = 0 ;
49894 PyObject * obj4 = 0 ;
49895 PyObject * obj5 = 0 ;
49896 PyObject * obj6 = 0 ;
49897 char * kwnames[] = {
49898 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49899 };
49900
49901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49903 if (!SWIG_IsOK(res1)) {
49904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
49905 }
49906 arg1 = reinterpret_cast< wxSizer * >(argp1);
49907 ecode2 = SWIG_AsVal_int(obj1, &val2);
49908 if (!SWIG_IsOK(ecode2)) {
49909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
49910 }
49911 arg2 = static_cast< int >(val2);
49912 arg3 = obj2;
49913 if (obj3) {
49914 ecode4 = SWIG_AsVal_int(obj3, &val4);
49915 if (!SWIG_IsOK(ecode4)) {
49916 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
49917 }
49918 arg4 = static_cast< int >(val4);
49919 }
49920 if (obj4) {
49921 ecode5 = SWIG_AsVal_int(obj4, &val5);
49922 if (!SWIG_IsOK(ecode5)) {
49923 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
49924 }
49925 arg5 = static_cast< int >(val5);
49926 }
49927 if (obj5) {
49928 ecode6 = SWIG_AsVal_int(obj5, &val6);
49929 if (!SWIG_IsOK(ecode6)) {
49930 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
49931 }
49932 arg6 = static_cast< int >(val6);
49933 }
49934 if (obj6) {
49935 arg7 = obj6;
49936 }
49937 {
49938 PyThreadState* __tstate = wxPyBeginAllowThreads();
49939 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
49940 wxPyEndAllowThreads(__tstate);
49941 if (PyErr_Occurred()) SWIG_fail;
49942 }
49943 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49944 return resultobj;
49945 fail:
49946 return NULL;
49947 }
49948
49949
49950 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49951 PyObject *resultobj = 0;
49952 wxSizer *arg1 = (wxSizer *) 0 ;
49953 PyObject *arg2 = (PyObject *) 0 ;
49954 int arg3 = (int) 0 ;
49955 int arg4 = (int) 0 ;
49956 int arg5 = (int) 0 ;
49957 PyObject *arg6 = (PyObject *) NULL ;
49958 wxSizerItem *result = 0 ;
49959 void *argp1 = 0 ;
49960 int res1 = 0 ;
49961 int val3 ;
49962 int ecode3 = 0 ;
49963 int val4 ;
49964 int ecode4 = 0 ;
49965 int val5 ;
49966 int ecode5 = 0 ;
49967 PyObject * obj0 = 0 ;
49968 PyObject * obj1 = 0 ;
49969 PyObject * obj2 = 0 ;
49970 PyObject * obj3 = 0 ;
49971 PyObject * obj4 = 0 ;
49972 PyObject * obj5 = 0 ;
49973 char * kwnames[] = {
49974 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49975 };
49976
49977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49979 if (!SWIG_IsOK(res1)) {
49980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
49981 }
49982 arg1 = reinterpret_cast< wxSizer * >(argp1);
49983 arg2 = obj1;
49984 if (obj2) {
49985 ecode3 = SWIG_AsVal_int(obj2, &val3);
49986 if (!SWIG_IsOK(ecode3)) {
49987 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
49988 }
49989 arg3 = static_cast< int >(val3);
49990 }
49991 if (obj3) {
49992 ecode4 = SWIG_AsVal_int(obj3, &val4);
49993 if (!SWIG_IsOK(ecode4)) {
49994 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
49995 }
49996 arg4 = static_cast< int >(val4);
49997 }
49998 if (obj4) {
49999 ecode5 = SWIG_AsVal_int(obj4, &val5);
50000 if (!SWIG_IsOK(ecode5)) {
50001 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
50002 }
50003 arg5 = static_cast< int >(val5);
50004 }
50005 if (obj5) {
50006 arg6 = obj5;
50007 }
50008 {
50009 PyThreadState* __tstate = wxPyBeginAllowThreads();
50010 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
50011 wxPyEndAllowThreads(__tstate);
50012 if (PyErr_Occurred()) SWIG_fail;
50013 }
50014 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50015 return resultobj;
50016 fail:
50017 return NULL;
50018 }
50019
50020
50021 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50022 PyObject *resultobj = 0;
50023 wxSizer *arg1 = (wxSizer *) 0 ;
50024 PyObject *arg2 = (PyObject *) 0 ;
50025 bool result;
50026 void *argp1 = 0 ;
50027 int res1 = 0 ;
50028 PyObject * obj0 = 0 ;
50029 PyObject * obj1 = 0 ;
50030 char * kwnames[] = {
50031 (char *) "self",(char *) "item", NULL
50032 };
50033
50034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
50035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50036 if (!SWIG_IsOK(res1)) {
50037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
50038 }
50039 arg1 = reinterpret_cast< wxSizer * >(argp1);
50040 arg2 = obj1;
50041 {
50042 PyThreadState* __tstate = wxPyBeginAllowThreads();
50043 result = (bool)wxSizer_Remove(arg1,arg2);
50044 wxPyEndAllowThreads(__tstate);
50045 if (PyErr_Occurred()) SWIG_fail;
50046 }
50047 {
50048 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50049 }
50050 return resultobj;
50051 fail:
50052 return NULL;
50053 }
50054
50055
50056 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50057 PyObject *resultobj = 0;
50058 wxSizer *arg1 = (wxSizer *) 0 ;
50059 PyObject *arg2 = (PyObject *) 0 ;
50060 bool result;
50061 void *argp1 = 0 ;
50062 int res1 = 0 ;
50063 PyObject * obj0 = 0 ;
50064 PyObject * obj1 = 0 ;
50065 char * kwnames[] = {
50066 (char *) "self",(char *) "item", NULL
50067 };
50068
50069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
50070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50071 if (!SWIG_IsOK(res1)) {
50072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
50073 }
50074 arg1 = reinterpret_cast< wxSizer * >(argp1);
50075 arg2 = obj1;
50076 {
50077 PyThreadState* __tstate = wxPyBeginAllowThreads();
50078 result = (bool)wxSizer_Detach(arg1,arg2);
50079 wxPyEndAllowThreads(__tstate);
50080 if (PyErr_Occurred()) SWIG_fail;
50081 }
50082 {
50083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50084 }
50085 return resultobj;
50086 fail:
50087 return NULL;
50088 }
50089
50090
50091 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50092 PyObject *resultobj = 0;
50093 wxSizer *arg1 = (wxSizer *) 0 ;
50094 PyObject *arg2 = (PyObject *) 0 ;
50095 wxSizerItem *result = 0 ;
50096 void *argp1 = 0 ;
50097 int res1 = 0 ;
50098 PyObject * obj0 = 0 ;
50099 PyObject * obj1 = 0 ;
50100 char * kwnames[] = {
50101 (char *) "self",(char *) "item", NULL
50102 };
50103
50104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
50105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50106 if (!SWIG_IsOK(res1)) {
50107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50108 }
50109 arg1 = reinterpret_cast< wxSizer * >(argp1);
50110 arg2 = obj1;
50111 {
50112 PyThreadState* __tstate = wxPyBeginAllowThreads();
50113 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
50114 wxPyEndAllowThreads(__tstate);
50115 if (PyErr_Occurred()) SWIG_fail;
50116 }
50117 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50118 return resultobj;
50119 fail:
50120 return NULL;
50121 }
50122
50123
50124 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50125 PyObject *resultobj = 0;
50126 wxSizer *arg1 = (wxSizer *) 0 ;
50127 PyObject *arg2 = (PyObject *) 0 ;
50128 wxSize *arg3 = 0 ;
50129 void *argp1 = 0 ;
50130 int res1 = 0 ;
50131 wxSize temp3 ;
50132 PyObject * obj0 = 0 ;
50133 PyObject * obj1 = 0 ;
50134 PyObject * obj2 = 0 ;
50135 char * kwnames[] = {
50136 (char *) "self",(char *) "item",(char *) "size", NULL
50137 };
50138
50139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50141 if (!SWIG_IsOK(res1)) {
50142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50143 }
50144 arg1 = reinterpret_cast< wxSizer * >(argp1);
50145 arg2 = obj1;
50146 {
50147 arg3 = &temp3;
50148 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
50149 }
50150 {
50151 PyThreadState* __tstate = wxPyBeginAllowThreads();
50152 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
50153 wxPyEndAllowThreads(__tstate);
50154 if (PyErr_Occurred()) SWIG_fail;
50155 }
50156 resultobj = SWIG_Py_Void();
50157 return resultobj;
50158 fail:
50159 return NULL;
50160 }
50161
50162
50163 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50164 PyObject *resultobj = 0;
50165 wxSizer *arg1 = (wxSizer *) 0 ;
50166 wxWindow *arg2 = (wxWindow *) 0 ;
50167 wxWindow *arg3 = (wxWindow *) 0 ;
50168 bool arg4 = (bool) false ;
50169 bool result;
50170 void *argp1 = 0 ;
50171 int res1 = 0 ;
50172 void *argp2 = 0 ;
50173 int res2 = 0 ;
50174 void *argp3 = 0 ;
50175 int res3 = 0 ;
50176 bool val4 ;
50177 int ecode4 = 0 ;
50178 PyObject * obj0 = 0 ;
50179 PyObject * obj1 = 0 ;
50180 PyObject * obj2 = 0 ;
50181 PyObject * obj3 = 0 ;
50182 char * kwnames[] = {
50183 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
50184 };
50185
50186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50188 if (!SWIG_IsOK(res1)) {
50189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
50190 }
50191 arg1 = reinterpret_cast< wxSizer * >(argp1);
50192 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50193 if (!SWIG_IsOK(res2)) {
50194 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
50195 }
50196 arg2 = reinterpret_cast< wxWindow * >(argp2);
50197 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
50198 if (!SWIG_IsOK(res3)) {
50199 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
50200 }
50201 arg3 = reinterpret_cast< wxWindow * >(argp3);
50202 if (obj3) {
50203 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50204 if (!SWIG_IsOK(ecode4)) {
50205 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
50206 }
50207 arg4 = static_cast< bool >(val4);
50208 }
50209 {
50210 PyThreadState* __tstate = wxPyBeginAllowThreads();
50211 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50212 wxPyEndAllowThreads(__tstate);
50213 if (PyErr_Occurred()) SWIG_fail;
50214 }
50215 {
50216 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50217 }
50218 return resultobj;
50219 fail:
50220 return NULL;
50221 }
50222
50223
50224 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50225 PyObject *resultobj = 0;
50226 wxSizer *arg1 = (wxSizer *) 0 ;
50227 wxSizer *arg2 = (wxSizer *) 0 ;
50228 wxSizer *arg3 = (wxSizer *) 0 ;
50229 bool arg4 = (bool) false ;
50230 bool result;
50231 void *argp1 = 0 ;
50232 int res1 = 0 ;
50233 void *argp2 = 0 ;
50234 int res2 = 0 ;
50235 void *argp3 = 0 ;
50236 int res3 = 0 ;
50237 bool val4 ;
50238 int ecode4 = 0 ;
50239 PyObject * obj0 = 0 ;
50240 PyObject * obj1 = 0 ;
50241 PyObject * obj2 = 0 ;
50242 PyObject * obj3 = 0 ;
50243 char * kwnames[] = {
50244 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
50245 };
50246
50247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50249 if (!SWIG_IsOK(res1)) {
50250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50251 }
50252 arg1 = reinterpret_cast< wxSizer * >(argp1);
50253 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50254 if (!SWIG_IsOK(res2)) {
50255 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
50256 }
50257 arg2 = reinterpret_cast< wxSizer * >(argp2);
50258 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
50259 if (!SWIG_IsOK(res3)) {
50260 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
50261 }
50262 arg3 = reinterpret_cast< wxSizer * >(argp3);
50263 if (obj3) {
50264 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50265 if (!SWIG_IsOK(ecode4)) {
50266 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
50267 }
50268 arg4 = static_cast< bool >(val4);
50269 }
50270 {
50271 PyThreadState* __tstate = wxPyBeginAllowThreads();
50272 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50273 wxPyEndAllowThreads(__tstate);
50274 if (PyErr_Occurred()) SWIG_fail;
50275 }
50276 {
50277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50278 }
50279 return resultobj;
50280 fail:
50281 return NULL;
50282 }
50283
50284
50285 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50286 PyObject *resultobj = 0;
50287 wxSizer *arg1 = (wxSizer *) 0 ;
50288 size_t arg2 ;
50289 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50290 bool result;
50291 void *argp1 = 0 ;
50292 int res1 = 0 ;
50293 size_t val2 ;
50294 int ecode2 = 0 ;
50295 void *argp3 = 0 ;
50296 int res3 = 0 ;
50297 PyObject * obj0 = 0 ;
50298 PyObject * obj1 = 0 ;
50299 PyObject * obj2 = 0 ;
50300 char * kwnames[] = {
50301 (char *) "self",(char *) "index",(char *) "newitem", NULL
50302 };
50303
50304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50306 if (!SWIG_IsOK(res1)) {
50307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50308 }
50309 arg1 = reinterpret_cast< wxSizer * >(argp1);
50310 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50311 if (!SWIG_IsOK(ecode2)) {
50312 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
50313 }
50314 arg2 = static_cast< size_t >(val2);
50315 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50316 if (!SWIG_IsOK(res3)) {
50317 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50318 }
50319 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
50320 {
50321 PyThreadState* __tstate = wxPyBeginAllowThreads();
50322 result = (bool)(arg1)->Replace(arg2,arg3);
50323 wxPyEndAllowThreads(__tstate);
50324 if (PyErr_Occurred()) SWIG_fail;
50325 }
50326 {
50327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50328 }
50329 return resultobj;
50330 fail:
50331 return NULL;
50332 }
50333
50334
50335 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50336 PyObject *resultobj = 0;
50337 wxSizer *arg1 = (wxSizer *) 0 ;
50338 wxWindow *arg2 = (wxWindow *) 0 ;
50339 void *argp1 = 0 ;
50340 int res1 = 0 ;
50341 void *argp2 = 0 ;
50342 int res2 = 0 ;
50343 PyObject * obj0 = 0 ;
50344 PyObject * obj1 = 0 ;
50345 char * kwnames[] = {
50346 (char *) "self",(char *) "window", NULL
50347 };
50348
50349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
50350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50351 if (!SWIG_IsOK(res1)) {
50352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
50353 }
50354 arg1 = reinterpret_cast< wxSizer * >(argp1);
50355 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50356 if (!SWIG_IsOK(res2)) {
50357 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
50358 }
50359 arg2 = reinterpret_cast< wxWindow * >(argp2);
50360 {
50361 PyThreadState* __tstate = wxPyBeginAllowThreads();
50362 (arg1)->SetContainingWindow(arg2);
50363 wxPyEndAllowThreads(__tstate);
50364 if (PyErr_Occurred()) SWIG_fail;
50365 }
50366 resultobj = SWIG_Py_Void();
50367 return resultobj;
50368 fail:
50369 return NULL;
50370 }
50371
50372
50373 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50374 PyObject *resultobj = 0;
50375 wxSizer *arg1 = (wxSizer *) 0 ;
50376 wxWindow *result = 0 ;
50377 void *argp1 = 0 ;
50378 int res1 = 0 ;
50379 PyObject *swig_obj[1] ;
50380
50381 if (!args) SWIG_fail;
50382 swig_obj[0] = args;
50383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50384 if (!SWIG_IsOK(res1)) {
50385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
50386 }
50387 arg1 = reinterpret_cast< wxSizer * >(argp1);
50388 {
50389 PyThreadState* __tstate = wxPyBeginAllowThreads();
50390 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
50391 wxPyEndAllowThreads(__tstate);
50392 if (PyErr_Occurred()) SWIG_fail;
50393 }
50394 {
50395 resultobj = wxPyMake_wxObject(result, 0);
50396 }
50397 return resultobj;
50398 fail:
50399 return NULL;
50400 }
50401
50402
50403 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50404 PyObject *resultobj = 0;
50405 wxSizer *arg1 = (wxSizer *) 0 ;
50406 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50407 wxSizerItem *result = 0 ;
50408 void *argp1 = 0 ;
50409 int res1 = 0 ;
50410 int res2 = 0 ;
50411 PyObject * obj0 = 0 ;
50412 PyObject * obj1 = 0 ;
50413 char * kwnames[] = {
50414 (char *) "self",(char *) "item", NULL
50415 };
50416
50417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50419 if (!SWIG_IsOK(res1)) {
50420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50421 }
50422 arg1 = reinterpret_cast< wxSizer * >(argp1);
50423 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50424 if (!SWIG_IsOK(res2)) {
50425 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50426 }
50427 {
50428 PyThreadState* __tstate = wxPyBeginAllowThreads();
50429 result = (wxSizerItem *)(arg1)->Add(arg2);
50430 wxPyEndAllowThreads(__tstate);
50431 if (PyErr_Occurred()) SWIG_fail;
50432 }
50433 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50434 return resultobj;
50435 fail:
50436 return NULL;
50437 }
50438
50439
50440 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50441 PyObject *resultobj = 0;
50442 wxSizer *arg1 = (wxSizer *) 0 ;
50443 size_t arg2 ;
50444 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50445 wxSizerItem *result = 0 ;
50446 void *argp1 = 0 ;
50447 int res1 = 0 ;
50448 size_t val2 ;
50449 int ecode2 = 0 ;
50450 int res3 = 0 ;
50451 PyObject * obj0 = 0 ;
50452 PyObject * obj1 = 0 ;
50453 PyObject * obj2 = 0 ;
50454 char * kwnames[] = {
50455 (char *) "self",(char *) "index",(char *) "item", NULL
50456 };
50457
50458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50460 if (!SWIG_IsOK(res1)) {
50461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50462 }
50463 arg1 = reinterpret_cast< wxSizer * >(argp1);
50464 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50465 if (!SWIG_IsOK(ecode2)) {
50466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
50467 }
50468 arg2 = static_cast< size_t >(val2);
50469 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50470 if (!SWIG_IsOK(res3)) {
50471 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50472 }
50473 {
50474 PyThreadState* __tstate = wxPyBeginAllowThreads();
50475 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
50476 wxPyEndAllowThreads(__tstate);
50477 if (PyErr_Occurred()) SWIG_fail;
50478 }
50479 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50480 return resultobj;
50481 fail:
50482 return NULL;
50483 }
50484
50485
50486 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50487 PyObject *resultobj = 0;
50488 wxSizer *arg1 = (wxSizer *) 0 ;
50489 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50490 wxSizerItem *result = 0 ;
50491 void *argp1 = 0 ;
50492 int res1 = 0 ;
50493 int res2 = 0 ;
50494 PyObject * obj0 = 0 ;
50495 PyObject * obj1 = 0 ;
50496 char * kwnames[] = {
50497 (char *) "self",(char *) "item", NULL
50498 };
50499
50500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
50501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50502 if (!SWIG_IsOK(res1)) {
50503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50504 }
50505 arg1 = reinterpret_cast< wxSizer * >(argp1);
50506 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50507 if (!SWIG_IsOK(res2)) {
50508 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50509 }
50510 {
50511 PyThreadState* __tstate = wxPyBeginAllowThreads();
50512 result = (wxSizerItem *)(arg1)->Prepend(arg2);
50513 wxPyEndAllowThreads(__tstate);
50514 if (PyErr_Occurred()) SWIG_fail;
50515 }
50516 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50517 return resultobj;
50518 fail:
50519 return NULL;
50520 }
50521
50522
50523 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50524 PyObject *resultobj = 0;
50525 wxSizer *arg1 = (wxSizer *) 0 ;
50526 int arg2 ;
50527 int arg3 ;
50528 int arg4 ;
50529 int arg5 ;
50530 void *argp1 = 0 ;
50531 int res1 = 0 ;
50532 int val2 ;
50533 int ecode2 = 0 ;
50534 int val3 ;
50535 int ecode3 = 0 ;
50536 int val4 ;
50537 int ecode4 = 0 ;
50538 int val5 ;
50539 int ecode5 = 0 ;
50540 PyObject * obj0 = 0 ;
50541 PyObject * obj1 = 0 ;
50542 PyObject * obj2 = 0 ;
50543 PyObject * obj3 = 0 ;
50544 PyObject * obj4 = 0 ;
50545 char * kwnames[] = {
50546 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
50547 };
50548
50549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
50550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50551 if (!SWIG_IsOK(res1)) {
50552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
50553 }
50554 arg1 = reinterpret_cast< wxSizer * >(argp1);
50555 ecode2 = SWIG_AsVal_int(obj1, &val2);
50556 if (!SWIG_IsOK(ecode2)) {
50557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
50558 }
50559 arg2 = static_cast< int >(val2);
50560 ecode3 = SWIG_AsVal_int(obj2, &val3);
50561 if (!SWIG_IsOK(ecode3)) {
50562 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
50563 }
50564 arg3 = static_cast< int >(val3);
50565 ecode4 = SWIG_AsVal_int(obj3, &val4);
50566 if (!SWIG_IsOK(ecode4)) {
50567 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
50568 }
50569 arg4 = static_cast< int >(val4);
50570 ecode5 = SWIG_AsVal_int(obj4, &val5);
50571 if (!SWIG_IsOK(ecode5)) {
50572 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
50573 }
50574 arg5 = static_cast< int >(val5);
50575 {
50576 PyThreadState* __tstate = wxPyBeginAllowThreads();
50577 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
50578 wxPyEndAllowThreads(__tstate);
50579 if (PyErr_Occurred()) SWIG_fail;
50580 }
50581 resultobj = SWIG_Py_Void();
50582 return resultobj;
50583 fail:
50584 return NULL;
50585 }
50586
50587
50588 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50589 PyObject *resultobj = 0;
50590 wxSizer *arg1 = (wxSizer *) 0 ;
50591 wxSize *arg2 = 0 ;
50592 void *argp1 = 0 ;
50593 int res1 = 0 ;
50594 wxSize temp2 ;
50595 PyObject * obj0 = 0 ;
50596 PyObject * obj1 = 0 ;
50597 char * kwnames[] = {
50598 (char *) "self",(char *) "size", NULL
50599 };
50600
50601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
50602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50603 if (!SWIG_IsOK(res1)) {
50604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50605 }
50606 arg1 = reinterpret_cast< wxSizer * >(argp1);
50607 {
50608 arg2 = &temp2;
50609 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50610 }
50611 {
50612 PyThreadState* __tstate = wxPyBeginAllowThreads();
50613 (arg1)->SetMinSize((wxSize const &)*arg2);
50614 wxPyEndAllowThreads(__tstate);
50615 if (PyErr_Occurred()) SWIG_fail;
50616 }
50617 resultobj = SWIG_Py_Void();
50618 return resultobj;
50619 fail:
50620 return NULL;
50621 }
50622
50623
50624 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50625 PyObject *resultobj = 0;
50626 wxSizer *arg1 = (wxSizer *) 0 ;
50627 wxSize result;
50628 void *argp1 = 0 ;
50629 int res1 = 0 ;
50630 PyObject *swig_obj[1] ;
50631
50632 if (!args) SWIG_fail;
50633 swig_obj[0] = args;
50634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50635 if (!SWIG_IsOK(res1)) {
50636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50637 }
50638 arg1 = reinterpret_cast< wxSizer * >(argp1);
50639 {
50640 PyThreadState* __tstate = wxPyBeginAllowThreads();
50641 result = (arg1)->GetSize();
50642 wxPyEndAllowThreads(__tstate);
50643 if (PyErr_Occurred()) SWIG_fail;
50644 }
50645 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50646 return resultobj;
50647 fail:
50648 return NULL;
50649 }
50650
50651
50652 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50653 PyObject *resultobj = 0;
50654 wxSizer *arg1 = (wxSizer *) 0 ;
50655 wxPoint result;
50656 void *argp1 = 0 ;
50657 int res1 = 0 ;
50658 PyObject *swig_obj[1] ;
50659
50660 if (!args) SWIG_fail;
50661 swig_obj[0] = args;
50662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50663 if (!SWIG_IsOK(res1)) {
50664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
50665 }
50666 arg1 = reinterpret_cast< wxSizer * >(argp1);
50667 {
50668 PyThreadState* __tstate = wxPyBeginAllowThreads();
50669 result = (arg1)->GetPosition();
50670 wxPyEndAllowThreads(__tstate);
50671 if (PyErr_Occurred()) SWIG_fail;
50672 }
50673 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
50674 return resultobj;
50675 fail:
50676 return NULL;
50677 }
50678
50679
50680 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50681 PyObject *resultobj = 0;
50682 wxSizer *arg1 = (wxSizer *) 0 ;
50683 wxSize result;
50684 void *argp1 = 0 ;
50685 int res1 = 0 ;
50686 PyObject *swig_obj[1] ;
50687
50688 if (!args) SWIG_fail;
50689 swig_obj[0] = args;
50690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50691 if (!SWIG_IsOK(res1)) {
50692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50693 }
50694 arg1 = reinterpret_cast< wxSizer * >(argp1);
50695 {
50696 PyThreadState* __tstate = wxPyBeginAllowThreads();
50697 result = (arg1)->GetMinSize();
50698 wxPyEndAllowThreads(__tstate);
50699 if (PyErr_Occurred()) SWIG_fail;
50700 }
50701 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50702 return resultobj;
50703 fail:
50704 return NULL;
50705 }
50706
50707
50708 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50709 PyObject *resultobj = 0;
50710 wxSizer *arg1 = (wxSizer *) 0 ;
50711 void *argp1 = 0 ;
50712 int res1 = 0 ;
50713 PyObject *swig_obj[1] ;
50714
50715 if (!args) SWIG_fail;
50716 swig_obj[0] = args;
50717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50718 if (!SWIG_IsOK(res1)) {
50719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
50720 }
50721 arg1 = reinterpret_cast< wxSizer * >(argp1);
50722 {
50723 PyThreadState* __tstate = wxPyBeginAllowThreads();
50724 (arg1)->RecalcSizes();
50725 wxPyEndAllowThreads(__tstate);
50726 if (PyErr_Occurred()) SWIG_fail;
50727 }
50728 resultobj = SWIG_Py_Void();
50729 return resultobj;
50730 fail:
50731 return NULL;
50732 }
50733
50734
50735 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50736 PyObject *resultobj = 0;
50737 wxSizer *arg1 = (wxSizer *) 0 ;
50738 wxSize result;
50739 void *argp1 = 0 ;
50740 int res1 = 0 ;
50741 PyObject *swig_obj[1] ;
50742
50743 if (!args) SWIG_fail;
50744 swig_obj[0] = args;
50745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50746 if (!SWIG_IsOK(res1)) {
50747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
50748 }
50749 arg1 = reinterpret_cast< wxSizer * >(argp1);
50750 {
50751 PyThreadState* __tstate = wxPyBeginAllowThreads();
50752 result = (arg1)->CalcMin();
50753 wxPyEndAllowThreads(__tstate);
50754 if (PyErr_Occurred()) SWIG_fail;
50755 }
50756 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50757 return resultobj;
50758 fail:
50759 return NULL;
50760 }
50761
50762
50763 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50764 PyObject *resultobj = 0;
50765 wxSizer *arg1 = (wxSizer *) 0 ;
50766 void *argp1 = 0 ;
50767 int res1 = 0 ;
50768 PyObject *swig_obj[1] ;
50769
50770 if (!args) SWIG_fail;
50771 swig_obj[0] = args;
50772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50773 if (!SWIG_IsOK(res1)) {
50774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
50775 }
50776 arg1 = reinterpret_cast< wxSizer * >(argp1);
50777 {
50778 PyThreadState* __tstate = wxPyBeginAllowThreads();
50779 (arg1)->Layout();
50780 wxPyEndAllowThreads(__tstate);
50781 if (PyErr_Occurred()) SWIG_fail;
50782 }
50783 resultobj = SWIG_Py_Void();
50784 return resultobj;
50785 fail:
50786 return NULL;
50787 }
50788
50789
50790 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50791 PyObject *resultobj = 0;
50792 wxSizer *arg1 = (wxSizer *) 0 ;
50793 wxWindow *arg2 = (wxWindow *) 0 ;
50794 wxSize result;
50795 void *argp1 = 0 ;
50796 int res1 = 0 ;
50797 void *argp2 = 0 ;
50798 int res2 = 0 ;
50799 PyObject * obj0 = 0 ;
50800 PyObject * obj1 = 0 ;
50801 char * kwnames[] = {
50802 (char *) "self",(char *) "window", NULL
50803 };
50804
50805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
50806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50807 if (!SWIG_IsOK(res1)) {
50808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
50809 }
50810 arg1 = reinterpret_cast< wxSizer * >(argp1);
50811 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50812 if (!SWIG_IsOK(res2)) {
50813 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
50814 }
50815 arg2 = reinterpret_cast< wxWindow * >(argp2);
50816 {
50817 PyThreadState* __tstate = wxPyBeginAllowThreads();
50818 result = (arg1)->Fit(arg2);
50819 wxPyEndAllowThreads(__tstate);
50820 if (PyErr_Occurred()) SWIG_fail;
50821 }
50822 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50823 return resultobj;
50824 fail:
50825 return NULL;
50826 }
50827
50828
50829 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50830 PyObject *resultobj = 0;
50831 wxSizer *arg1 = (wxSizer *) 0 ;
50832 wxWindow *arg2 = (wxWindow *) 0 ;
50833 void *argp1 = 0 ;
50834 int res1 = 0 ;
50835 void *argp2 = 0 ;
50836 int res2 = 0 ;
50837 PyObject * obj0 = 0 ;
50838 PyObject * obj1 = 0 ;
50839 char * kwnames[] = {
50840 (char *) "self",(char *) "window", NULL
50841 };
50842
50843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
50844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50845 if (!SWIG_IsOK(res1)) {
50846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
50847 }
50848 arg1 = reinterpret_cast< wxSizer * >(argp1);
50849 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50850 if (!SWIG_IsOK(res2)) {
50851 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
50852 }
50853 arg2 = reinterpret_cast< wxWindow * >(argp2);
50854 {
50855 PyThreadState* __tstate = wxPyBeginAllowThreads();
50856 (arg1)->FitInside(arg2);
50857 wxPyEndAllowThreads(__tstate);
50858 if (PyErr_Occurred()) SWIG_fail;
50859 }
50860 resultobj = SWIG_Py_Void();
50861 return resultobj;
50862 fail:
50863 return NULL;
50864 }
50865
50866
50867 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50868 PyObject *resultobj = 0;
50869 wxSizer *arg1 = (wxSizer *) 0 ;
50870 wxWindow *arg2 = (wxWindow *) 0 ;
50871 void *argp1 = 0 ;
50872 int res1 = 0 ;
50873 void *argp2 = 0 ;
50874 int res2 = 0 ;
50875 PyObject * obj0 = 0 ;
50876 PyObject * obj1 = 0 ;
50877 char * kwnames[] = {
50878 (char *) "self",(char *) "window", NULL
50879 };
50880
50881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
50882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50883 if (!SWIG_IsOK(res1)) {
50884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
50885 }
50886 arg1 = reinterpret_cast< wxSizer * >(argp1);
50887 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50888 if (!SWIG_IsOK(res2)) {
50889 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
50890 }
50891 arg2 = reinterpret_cast< wxWindow * >(argp2);
50892 {
50893 PyThreadState* __tstate = wxPyBeginAllowThreads();
50894 (arg1)->SetSizeHints(arg2);
50895 wxPyEndAllowThreads(__tstate);
50896 if (PyErr_Occurred()) SWIG_fail;
50897 }
50898 resultobj = SWIG_Py_Void();
50899 return resultobj;
50900 fail:
50901 return NULL;
50902 }
50903
50904
50905 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50906 PyObject *resultobj = 0;
50907 wxSizer *arg1 = (wxSizer *) 0 ;
50908 wxWindow *arg2 = (wxWindow *) 0 ;
50909 void *argp1 = 0 ;
50910 int res1 = 0 ;
50911 void *argp2 = 0 ;
50912 int res2 = 0 ;
50913 PyObject * obj0 = 0 ;
50914 PyObject * obj1 = 0 ;
50915 char * kwnames[] = {
50916 (char *) "self",(char *) "window", NULL
50917 };
50918
50919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
50920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50921 if (!SWIG_IsOK(res1)) {
50922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
50923 }
50924 arg1 = reinterpret_cast< wxSizer * >(argp1);
50925 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50926 if (!SWIG_IsOK(res2)) {
50927 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
50928 }
50929 arg2 = reinterpret_cast< wxWindow * >(argp2);
50930 {
50931 PyThreadState* __tstate = wxPyBeginAllowThreads();
50932 (arg1)->SetVirtualSizeHints(arg2);
50933 wxPyEndAllowThreads(__tstate);
50934 if (PyErr_Occurred()) SWIG_fail;
50935 }
50936 resultobj = SWIG_Py_Void();
50937 return resultobj;
50938 fail:
50939 return NULL;
50940 }
50941
50942
50943 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50944 PyObject *resultobj = 0;
50945 wxSizer *arg1 = (wxSizer *) 0 ;
50946 bool arg2 = (bool) false ;
50947 void *argp1 = 0 ;
50948 int res1 = 0 ;
50949 bool val2 ;
50950 int ecode2 = 0 ;
50951 PyObject * obj0 = 0 ;
50952 PyObject * obj1 = 0 ;
50953 char * kwnames[] = {
50954 (char *) "self",(char *) "deleteWindows", NULL
50955 };
50956
50957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
50958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50959 if (!SWIG_IsOK(res1)) {
50960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
50961 }
50962 arg1 = reinterpret_cast< wxSizer * >(argp1);
50963 if (obj1) {
50964 ecode2 = SWIG_AsVal_bool(obj1, &val2);
50965 if (!SWIG_IsOK(ecode2)) {
50966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
50967 }
50968 arg2 = static_cast< bool >(val2);
50969 }
50970 {
50971 PyThreadState* __tstate = wxPyBeginAllowThreads();
50972 (arg1)->Clear(arg2);
50973 wxPyEndAllowThreads(__tstate);
50974 if (PyErr_Occurred()) SWIG_fail;
50975 }
50976 resultobj = SWIG_Py_Void();
50977 return resultobj;
50978 fail:
50979 return NULL;
50980 }
50981
50982
50983 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50984 PyObject *resultobj = 0;
50985 wxSizer *arg1 = (wxSizer *) 0 ;
50986 void *argp1 = 0 ;
50987 int res1 = 0 ;
50988 PyObject *swig_obj[1] ;
50989
50990 if (!args) SWIG_fail;
50991 swig_obj[0] = args;
50992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50993 if (!SWIG_IsOK(res1)) {
50994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
50995 }
50996 arg1 = reinterpret_cast< wxSizer * >(argp1);
50997 {
50998 PyThreadState* __tstate = wxPyBeginAllowThreads();
50999 (arg1)->DeleteWindows();
51000 wxPyEndAllowThreads(__tstate);
51001 if (PyErr_Occurred()) SWIG_fail;
51002 }
51003 resultobj = SWIG_Py_Void();
51004 return resultobj;
51005 fail:
51006 return NULL;
51007 }
51008
51009
51010 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51011 PyObject *resultobj = 0;
51012 wxSizer *arg1 = (wxSizer *) 0 ;
51013 PyObject *result = 0 ;
51014 void *argp1 = 0 ;
51015 int res1 = 0 ;
51016 PyObject *swig_obj[1] ;
51017
51018 if (!args) SWIG_fail;
51019 swig_obj[0] = args;
51020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51021 if (!SWIG_IsOK(res1)) {
51022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
51023 }
51024 arg1 = reinterpret_cast< wxSizer * >(argp1);
51025 {
51026 PyThreadState* __tstate = wxPyBeginAllowThreads();
51027 result = (PyObject *)wxSizer_GetChildren(arg1);
51028 wxPyEndAllowThreads(__tstate);
51029 if (PyErr_Occurred()) SWIG_fail;
51030 }
51031 resultobj = result;
51032 return resultobj;
51033 fail:
51034 return NULL;
51035 }
51036
51037
51038 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51039 PyObject *resultobj = 0;
51040 wxSizer *arg1 = (wxSizer *) 0 ;
51041 PyObject *arg2 = (PyObject *) 0 ;
51042 bool arg3 = (bool) true ;
51043 bool arg4 = (bool) false ;
51044 bool result;
51045 void *argp1 = 0 ;
51046 int res1 = 0 ;
51047 bool val3 ;
51048 int ecode3 = 0 ;
51049 bool val4 ;
51050 int ecode4 = 0 ;
51051 PyObject * obj0 = 0 ;
51052 PyObject * obj1 = 0 ;
51053 PyObject * obj2 = 0 ;
51054 PyObject * obj3 = 0 ;
51055 char * kwnames[] = {
51056 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
51057 };
51058
51059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51061 if (!SWIG_IsOK(res1)) {
51062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
51063 }
51064 arg1 = reinterpret_cast< wxSizer * >(argp1);
51065 arg2 = obj1;
51066 if (obj2) {
51067 ecode3 = SWIG_AsVal_bool(obj2, &val3);
51068 if (!SWIG_IsOK(ecode3)) {
51069 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
51070 }
51071 arg3 = static_cast< bool >(val3);
51072 }
51073 if (obj3) {
51074 ecode4 = SWIG_AsVal_bool(obj3, &val4);
51075 if (!SWIG_IsOK(ecode4)) {
51076 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
51077 }
51078 arg4 = static_cast< bool >(val4);
51079 }
51080 {
51081 PyThreadState* __tstate = wxPyBeginAllowThreads();
51082 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
51083 wxPyEndAllowThreads(__tstate);
51084 if (PyErr_Occurred()) SWIG_fail;
51085 }
51086 {
51087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51088 }
51089 return resultobj;
51090 fail:
51091 return NULL;
51092 }
51093
51094
51095 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51096 PyObject *resultobj = 0;
51097 wxSizer *arg1 = (wxSizer *) 0 ;
51098 PyObject *arg2 = (PyObject *) 0 ;
51099 bool result;
51100 void *argp1 = 0 ;
51101 int res1 = 0 ;
51102 PyObject * obj0 = 0 ;
51103 PyObject * obj1 = 0 ;
51104 char * kwnames[] = {
51105 (char *) "self",(char *) "item", NULL
51106 };
51107
51108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
51109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51110 if (!SWIG_IsOK(res1)) {
51111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
51112 }
51113 arg1 = reinterpret_cast< wxSizer * >(argp1);
51114 arg2 = obj1;
51115 {
51116 PyThreadState* __tstate = wxPyBeginAllowThreads();
51117 result = (bool)wxSizer_IsShown(arg1,arg2);
51118 wxPyEndAllowThreads(__tstate);
51119 if (PyErr_Occurred()) SWIG_fail;
51120 }
51121 {
51122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51123 }
51124 return resultobj;
51125 fail:
51126 return NULL;
51127 }
51128
51129
51130 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51131 PyObject *resultobj = 0;
51132 wxSizer *arg1 = (wxSizer *) 0 ;
51133 bool arg2 ;
51134 void *argp1 = 0 ;
51135 int res1 = 0 ;
51136 bool val2 ;
51137 int ecode2 = 0 ;
51138 PyObject * obj0 = 0 ;
51139 PyObject * obj1 = 0 ;
51140 char * kwnames[] = {
51141 (char *) "self",(char *) "show", NULL
51142 };
51143
51144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
51145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51146 if (!SWIG_IsOK(res1)) {
51147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
51148 }
51149 arg1 = reinterpret_cast< wxSizer * >(argp1);
51150 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51151 if (!SWIG_IsOK(ecode2)) {
51152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
51153 }
51154 arg2 = static_cast< bool >(val2);
51155 {
51156 PyThreadState* __tstate = wxPyBeginAllowThreads();
51157 (arg1)->ShowItems(arg2);
51158 wxPyEndAllowThreads(__tstate);
51159 if (PyErr_Occurred()) SWIG_fail;
51160 }
51161 resultobj = SWIG_Py_Void();
51162 return resultobj;
51163 fail:
51164 return NULL;
51165 }
51166
51167
51168 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51169 PyObject *obj;
51170 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51171 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
51172 return SWIG_Py_Void();
51173 }
51174
51175 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51176 PyObject *resultobj = 0;
51177 wxPySizer *result = 0 ;
51178
51179 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
51180 {
51181 PyThreadState* __tstate = wxPyBeginAllowThreads();
51182 result = (wxPySizer *)new wxPySizer();
51183 wxPyEndAllowThreads(__tstate);
51184 if (PyErr_Occurred()) SWIG_fail;
51185 }
51186 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
51187 return resultobj;
51188 fail:
51189 return NULL;
51190 }
51191
51192
51193 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51194 PyObject *resultobj = 0;
51195 wxPySizer *arg1 = (wxPySizer *) 0 ;
51196 PyObject *arg2 = (PyObject *) 0 ;
51197 PyObject *arg3 = (PyObject *) 0 ;
51198 void *argp1 = 0 ;
51199 int res1 = 0 ;
51200 PyObject * obj0 = 0 ;
51201 PyObject * obj1 = 0 ;
51202 PyObject * obj2 = 0 ;
51203 char * kwnames[] = {
51204 (char *) "self",(char *) "self",(char *) "_class", NULL
51205 };
51206
51207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
51209 if (!SWIG_IsOK(res1)) {
51210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
51211 }
51212 arg1 = reinterpret_cast< wxPySizer * >(argp1);
51213 arg2 = obj1;
51214 arg3 = obj2;
51215 {
51216 PyThreadState* __tstate = wxPyBeginAllowThreads();
51217 (arg1)->_setCallbackInfo(arg2,arg3);
51218 wxPyEndAllowThreads(__tstate);
51219 if (PyErr_Occurred()) SWIG_fail;
51220 }
51221 resultobj = SWIG_Py_Void();
51222 return resultobj;
51223 fail:
51224 return NULL;
51225 }
51226
51227
51228 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51229 PyObject *obj;
51230 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51231 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
51232 return SWIG_Py_Void();
51233 }
51234
51235 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51236 return SWIG_Python_InitShadowInstance(args);
51237 }
51238
51239 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51240 PyObject *resultobj = 0;
51241 int arg1 = (int) wxHORIZONTAL ;
51242 wxBoxSizer *result = 0 ;
51243 int val1 ;
51244 int ecode1 = 0 ;
51245 PyObject * obj0 = 0 ;
51246 char * kwnames[] = {
51247 (char *) "orient", NULL
51248 };
51249
51250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
51251 if (obj0) {
51252 ecode1 = SWIG_AsVal_int(obj0, &val1);
51253 if (!SWIG_IsOK(ecode1)) {
51254 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
51255 }
51256 arg1 = static_cast< int >(val1);
51257 }
51258 {
51259 PyThreadState* __tstate = wxPyBeginAllowThreads();
51260 result = (wxBoxSizer *)new wxBoxSizer(arg1);
51261 wxPyEndAllowThreads(__tstate);
51262 if (PyErr_Occurred()) SWIG_fail;
51263 }
51264 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
51265 return resultobj;
51266 fail:
51267 return NULL;
51268 }
51269
51270
51271 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51272 PyObject *resultobj = 0;
51273 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51274 int result;
51275 void *argp1 = 0 ;
51276 int res1 = 0 ;
51277 PyObject *swig_obj[1] ;
51278
51279 if (!args) SWIG_fail;
51280 swig_obj[0] = args;
51281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51282 if (!SWIG_IsOK(res1)) {
51283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51284 }
51285 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51286 {
51287 PyThreadState* __tstate = wxPyBeginAllowThreads();
51288 result = (int)(arg1)->GetOrientation();
51289 wxPyEndAllowThreads(__tstate);
51290 if (PyErr_Occurred()) SWIG_fail;
51291 }
51292 resultobj = SWIG_From_int(static_cast< int >(result));
51293 return resultobj;
51294 fail:
51295 return NULL;
51296 }
51297
51298
51299 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51300 PyObject *resultobj = 0;
51301 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51302 int arg2 ;
51303 void *argp1 = 0 ;
51304 int res1 = 0 ;
51305 int val2 ;
51306 int ecode2 = 0 ;
51307 PyObject * obj0 = 0 ;
51308 PyObject * obj1 = 0 ;
51309 char * kwnames[] = {
51310 (char *) "self",(char *) "orient", NULL
51311 };
51312
51313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
51314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51315 if (!SWIG_IsOK(res1)) {
51316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51317 }
51318 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51319 ecode2 = SWIG_AsVal_int(obj1, &val2);
51320 if (!SWIG_IsOK(ecode2)) {
51321 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
51322 }
51323 arg2 = static_cast< int >(val2);
51324 {
51325 PyThreadState* __tstate = wxPyBeginAllowThreads();
51326 (arg1)->SetOrientation(arg2);
51327 wxPyEndAllowThreads(__tstate);
51328 if (PyErr_Occurred()) SWIG_fail;
51329 }
51330 resultobj = SWIG_Py_Void();
51331 return resultobj;
51332 fail:
51333 return NULL;
51334 }
51335
51336
51337 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51338 PyObject *obj;
51339 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51340 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
51341 return SWIG_Py_Void();
51342 }
51343
51344 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51345 return SWIG_Python_InitShadowInstance(args);
51346 }
51347
51348 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51349 PyObject *resultobj = 0;
51350 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
51351 int arg2 = (int) wxHORIZONTAL ;
51352 wxStaticBoxSizer *result = 0 ;
51353 void *argp1 = 0 ;
51354 int res1 = 0 ;
51355 int val2 ;
51356 int ecode2 = 0 ;
51357 PyObject * obj0 = 0 ;
51358 PyObject * obj1 = 0 ;
51359 char * kwnames[] = {
51360 (char *) "box",(char *) "orient", NULL
51361 };
51362
51363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
51365 if (!SWIG_IsOK(res1)) {
51366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
51367 }
51368 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
51369 if (obj1) {
51370 ecode2 = SWIG_AsVal_int(obj1, &val2);
51371 if (!SWIG_IsOK(ecode2)) {
51372 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
51373 }
51374 arg2 = static_cast< int >(val2);
51375 }
51376 {
51377 PyThreadState* __tstate = wxPyBeginAllowThreads();
51378 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
51379 wxPyEndAllowThreads(__tstate);
51380 if (PyErr_Occurred()) SWIG_fail;
51381 }
51382 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
51383 return resultobj;
51384 fail:
51385 return NULL;
51386 }
51387
51388
51389 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51390 PyObject *resultobj = 0;
51391 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
51392 wxStaticBox *result = 0 ;
51393 void *argp1 = 0 ;
51394 int res1 = 0 ;
51395 PyObject *swig_obj[1] ;
51396
51397 if (!args) SWIG_fail;
51398 swig_obj[0] = args;
51399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
51400 if (!SWIG_IsOK(res1)) {
51401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
51402 }
51403 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
51404 {
51405 PyThreadState* __tstate = wxPyBeginAllowThreads();
51406 result = (wxStaticBox *)(arg1)->GetStaticBox();
51407 wxPyEndAllowThreads(__tstate);
51408 if (PyErr_Occurred()) SWIG_fail;
51409 }
51410 {
51411 resultobj = wxPyMake_wxObject(result, (bool)0);
51412 }
51413 return resultobj;
51414 fail:
51415 return NULL;
51416 }
51417
51418
51419 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51420 PyObject *obj;
51421 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51422 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
51423 return SWIG_Py_Void();
51424 }
51425
51426 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51427 return SWIG_Python_InitShadowInstance(args);
51428 }
51429
51430 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51431 PyObject *resultobj = 0;
51432 int arg1 = (int) 1 ;
51433 int arg2 = (int) 0 ;
51434 int arg3 = (int) 0 ;
51435 int arg4 = (int) 0 ;
51436 wxGridSizer *result = 0 ;
51437 int val1 ;
51438 int ecode1 = 0 ;
51439 int val2 ;
51440 int ecode2 = 0 ;
51441 int val3 ;
51442 int ecode3 = 0 ;
51443 int val4 ;
51444 int ecode4 = 0 ;
51445 PyObject * obj0 = 0 ;
51446 PyObject * obj1 = 0 ;
51447 PyObject * obj2 = 0 ;
51448 PyObject * obj3 = 0 ;
51449 char * kwnames[] = {
51450 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51451 };
51452
51453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51454 if (obj0) {
51455 ecode1 = SWIG_AsVal_int(obj0, &val1);
51456 if (!SWIG_IsOK(ecode1)) {
51457 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
51458 }
51459 arg1 = static_cast< int >(val1);
51460 }
51461 if (obj1) {
51462 ecode2 = SWIG_AsVal_int(obj1, &val2);
51463 if (!SWIG_IsOK(ecode2)) {
51464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
51465 }
51466 arg2 = static_cast< int >(val2);
51467 }
51468 if (obj2) {
51469 ecode3 = SWIG_AsVal_int(obj2, &val3);
51470 if (!SWIG_IsOK(ecode3)) {
51471 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
51472 }
51473 arg3 = static_cast< int >(val3);
51474 }
51475 if (obj3) {
51476 ecode4 = SWIG_AsVal_int(obj3, &val4);
51477 if (!SWIG_IsOK(ecode4)) {
51478 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
51479 }
51480 arg4 = static_cast< int >(val4);
51481 }
51482 {
51483 PyThreadState* __tstate = wxPyBeginAllowThreads();
51484 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
51485 wxPyEndAllowThreads(__tstate);
51486 if (PyErr_Occurred()) SWIG_fail;
51487 }
51488 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
51489 return resultobj;
51490 fail:
51491 return NULL;
51492 }
51493
51494
51495 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51496 PyObject *resultobj = 0;
51497 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51498 int arg2 ;
51499 void *argp1 = 0 ;
51500 int res1 = 0 ;
51501 int val2 ;
51502 int ecode2 = 0 ;
51503 PyObject * obj0 = 0 ;
51504 PyObject * obj1 = 0 ;
51505 char * kwnames[] = {
51506 (char *) "self",(char *) "cols", NULL
51507 };
51508
51509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
51510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51511 if (!SWIG_IsOK(res1)) {
51512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51513 }
51514 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51515 ecode2 = SWIG_AsVal_int(obj1, &val2);
51516 if (!SWIG_IsOK(ecode2)) {
51517 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
51518 }
51519 arg2 = static_cast< int >(val2);
51520 {
51521 PyThreadState* __tstate = wxPyBeginAllowThreads();
51522 (arg1)->SetCols(arg2);
51523 wxPyEndAllowThreads(__tstate);
51524 if (PyErr_Occurred()) SWIG_fail;
51525 }
51526 resultobj = SWIG_Py_Void();
51527 return resultobj;
51528 fail:
51529 return NULL;
51530 }
51531
51532
51533 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51534 PyObject *resultobj = 0;
51535 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51536 int arg2 ;
51537 void *argp1 = 0 ;
51538 int res1 = 0 ;
51539 int val2 ;
51540 int ecode2 = 0 ;
51541 PyObject * obj0 = 0 ;
51542 PyObject * obj1 = 0 ;
51543 char * kwnames[] = {
51544 (char *) "self",(char *) "rows", NULL
51545 };
51546
51547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
51548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51549 if (!SWIG_IsOK(res1)) {
51550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51551 }
51552 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51553 ecode2 = SWIG_AsVal_int(obj1, &val2);
51554 if (!SWIG_IsOK(ecode2)) {
51555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
51556 }
51557 arg2 = static_cast< int >(val2);
51558 {
51559 PyThreadState* __tstate = wxPyBeginAllowThreads();
51560 (arg1)->SetRows(arg2);
51561 wxPyEndAllowThreads(__tstate);
51562 if (PyErr_Occurred()) SWIG_fail;
51563 }
51564 resultobj = SWIG_Py_Void();
51565 return resultobj;
51566 fail:
51567 return NULL;
51568 }
51569
51570
51571 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51572 PyObject *resultobj = 0;
51573 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51574 int arg2 ;
51575 void *argp1 = 0 ;
51576 int res1 = 0 ;
51577 int val2 ;
51578 int ecode2 = 0 ;
51579 PyObject * obj0 = 0 ;
51580 PyObject * obj1 = 0 ;
51581 char * kwnames[] = {
51582 (char *) "self",(char *) "gap", NULL
51583 };
51584
51585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
51586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51587 if (!SWIG_IsOK(res1)) {
51588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51589 }
51590 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51591 ecode2 = SWIG_AsVal_int(obj1, &val2);
51592 if (!SWIG_IsOK(ecode2)) {
51593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
51594 }
51595 arg2 = static_cast< int >(val2);
51596 {
51597 PyThreadState* __tstate = wxPyBeginAllowThreads();
51598 (arg1)->SetVGap(arg2);
51599 wxPyEndAllowThreads(__tstate);
51600 if (PyErr_Occurred()) SWIG_fail;
51601 }
51602 resultobj = SWIG_Py_Void();
51603 return resultobj;
51604 fail:
51605 return NULL;
51606 }
51607
51608
51609 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51610 PyObject *resultobj = 0;
51611 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51612 int arg2 ;
51613 void *argp1 = 0 ;
51614 int res1 = 0 ;
51615 int val2 ;
51616 int ecode2 = 0 ;
51617 PyObject * obj0 = 0 ;
51618 PyObject * obj1 = 0 ;
51619 char * kwnames[] = {
51620 (char *) "self",(char *) "gap", NULL
51621 };
51622
51623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
51624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51625 if (!SWIG_IsOK(res1)) {
51626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51627 }
51628 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51629 ecode2 = SWIG_AsVal_int(obj1, &val2);
51630 if (!SWIG_IsOK(ecode2)) {
51631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
51632 }
51633 arg2 = static_cast< int >(val2);
51634 {
51635 PyThreadState* __tstate = wxPyBeginAllowThreads();
51636 (arg1)->SetHGap(arg2);
51637 wxPyEndAllowThreads(__tstate);
51638 if (PyErr_Occurred()) SWIG_fail;
51639 }
51640 resultobj = SWIG_Py_Void();
51641 return resultobj;
51642 fail:
51643 return NULL;
51644 }
51645
51646
51647 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51648 PyObject *resultobj = 0;
51649 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51650 int result;
51651 void *argp1 = 0 ;
51652 int res1 = 0 ;
51653 PyObject *swig_obj[1] ;
51654
51655 if (!args) SWIG_fail;
51656 swig_obj[0] = args;
51657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51658 if (!SWIG_IsOK(res1)) {
51659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51660 }
51661 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51662 {
51663 PyThreadState* __tstate = wxPyBeginAllowThreads();
51664 result = (int)(arg1)->GetCols();
51665 wxPyEndAllowThreads(__tstate);
51666 if (PyErr_Occurred()) SWIG_fail;
51667 }
51668 resultobj = SWIG_From_int(static_cast< int >(result));
51669 return resultobj;
51670 fail:
51671 return NULL;
51672 }
51673
51674
51675 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51676 PyObject *resultobj = 0;
51677 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51678 int result;
51679 void *argp1 = 0 ;
51680 int res1 = 0 ;
51681 PyObject *swig_obj[1] ;
51682
51683 if (!args) SWIG_fail;
51684 swig_obj[0] = args;
51685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51686 if (!SWIG_IsOK(res1)) {
51687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51688 }
51689 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51690 {
51691 PyThreadState* __tstate = wxPyBeginAllowThreads();
51692 result = (int)(arg1)->GetRows();
51693 wxPyEndAllowThreads(__tstate);
51694 if (PyErr_Occurred()) SWIG_fail;
51695 }
51696 resultobj = SWIG_From_int(static_cast< int >(result));
51697 return resultobj;
51698 fail:
51699 return NULL;
51700 }
51701
51702
51703 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51704 PyObject *resultobj = 0;
51705 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51706 int result;
51707 void *argp1 = 0 ;
51708 int res1 = 0 ;
51709 PyObject *swig_obj[1] ;
51710
51711 if (!args) SWIG_fail;
51712 swig_obj[0] = args;
51713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51714 if (!SWIG_IsOK(res1)) {
51715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51716 }
51717 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51718 {
51719 PyThreadState* __tstate = wxPyBeginAllowThreads();
51720 result = (int)(arg1)->GetVGap();
51721 wxPyEndAllowThreads(__tstate);
51722 if (PyErr_Occurred()) SWIG_fail;
51723 }
51724 resultobj = SWIG_From_int(static_cast< int >(result));
51725 return resultobj;
51726 fail:
51727 return NULL;
51728 }
51729
51730
51731 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51732 PyObject *resultobj = 0;
51733 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51734 int result;
51735 void *argp1 = 0 ;
51736 int res1 = 0 ;
51737 PyObject *swig_obj[1] ;
51738
51739 if (!args) SWIG_fail;
51740 swig_obj[0] = args;
51741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51742 if (!SWIG_IsOK(res1)) {
51743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51744 }
51745 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51746 {
51747 PyThreadState* __tstate = wxPyBeginAllowThreads();
51748 result = (int)(arg1)->GetHGap();
51749 wxPyEndAllowThreads(__tstate);
51750 if (PyErr_Occurred()) SWIG_fail;
51751 }
51752 resultobj = SWIG_From_int(static_cast< int >(result));
51753 return resultobj;
51754 fail:
51755 return NULL;
51756 }
51757
51758
51759 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51760 PyObject *obj;
51761 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51762 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
51763 return SWIG_Py_Void();
51764 }
51765
51766 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51767 return SWIG_Python_InitShadowInstance(args);
51768 }
51769
51770 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51771 PyObject *resultobj = 0;
51772 int arg1 = (int) 1 ;
51773 int arg2 = (int) 0 ;
51774 int arg3 = (int) 0 ;
51775 int arg4 = (int) 0 ;
51776 wxFlexGridSizer *result = 0 ;
51777 int val1 ;
51778 int ecode1 = 0 ;
51779 int val2 ;
51780 int ecode2 = 0 ;
51781 int val3 ;
51782 int ecode3 = 0 ;
51783 int val4 ;
51784 int ecode4 = 0 ;
51785 PyObject * obj0 = 0 ;
51786 PyObject * obj1 = 0 ;
51787 PyObject * obj2 = 0 ;
51788 PyObject * obj3 = 0 ;
51789 char * kwnames[] = {
51790 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51791 };
51792
51793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51794 if (obj0) {
51795 ecode1 = SWIG_AsVal_int(obj0, &val1);
51796 if (!SWIG_IsOK(ecode1)) {
51797 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
51798 }
51799 arg1 = static_cast< int >(val1);
51800 }
51801 if (obj1) {
51802 ecode2 = SWIG_AsVal_int(obj1, &val2);
51803 if (!SWIG_IsOK(ecode2)) {
51804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
51805 }
51806 arg2 = static_cast< int >(val2);
51807 }
51808 if (obj2) {
51809 ecode3 = SWIG_AsVal_int(obj2, &val3);
51810 if (!SWIG_IsOK(ecode3)) {
51811 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
51812 }
51813 arg3 = static_cast< int >(val3);
51814 }
51815 if (obj3) {
51816 ecode4 = SWIG_AsVal_int(obj3, &val4);
51817 if (!SWIG_IsOK(ecode4)) {
51818 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
51819 }
51820 arg4 = static_cast< int >(val4);
51821 }
51822 {
51823 PyThreadState* __tstate = wxPyBeginAllowThreads();
51824 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
51825 wxPyEndAllowThreads(__tstate);
51826 if (PyErr_Occurred()) SWIG_fail;
51827 }
51828 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
51829 return resultobj;
51830 fail:
51831 return NULL;
51832 }
51833
51834
51835 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51836 PyObject *resultobj = 0;
51837 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51838 size_t arg2 ;
51839 int arg3 = (int) 0 ;
51840 void *argp1 = 0 ;
51841 int res1 = 0 ;
51842 size_t val2 ;
51843 int ecode2 = 0 ;
51844 int val3 ;
51845 int ecode3 = 0 ;
51846 PyObject * obj0 = 0 ;
51847 PyObject * obj1 = 0 ;
51848 PyObject * obj2 = 0 ;
51849 char * kwnames[] = {
51850 (char *) "self",(char *) "idx",(char *) "proportion", NULL
51851 };
51852
51853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51855 if (!SWIG_IsOK(res1)) {
51856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51857 }
51858 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51859 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51860 if (!SWIG_IsOK(ecode2)) {
51861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
51862 }
51863 arg2 = static_cast< size_t >(val2);
51864 if (obj2) {
51865 ecode3 = SWIG_AsVal_int(obj2, &val3);
51866 if (!SWIG_IsOK(ecode3)) {
51867 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
51868 }
51869 arg3 = static_cast< int >(val3);
51870 }
51871 {
51872 PyThreadState* __tstate = wxPyBeginAllowThreads();
51873 (arg1)->AddGrowableRow(arg2,arg3);
51874 wxPyEndAllowThreads(__tstate);
51875 if (PyErr_Occurred()) SWIG_fail;
51876 }
51877 resultobj = SWIG_Py_Void();
51878 return resultobj;
51879 fail:
51880 return NULL;
51881 }
51882
51883
51884 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51885 PyObject *resultobj = 0;
51886 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51887 size_t arg2 ;
51888 void *argp1 = 0 ;
51889 int res1 = 0 ;
51890 size_t val2 ;
51891 int ecode2 = 0 ;
51892 PyObject * obj0 = 0 ;
51893 PyObject * obj1 = 0 ;
51894 char * kwnames[] = {
51895 (char *) "self",(char *) "idx", NULL
51896 };
51897
51898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
51899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51900 if (!SWIG_IsOK(res1)) {
51901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51902 }
51903 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51904 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51905 if (!SWIG_IsOK(ecode2)) {
51906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
51907 }
51908 arg2 = static_cast< size_t >(val2);
51909 {
51910 PyThreadState* __tstate = wxPyBeginAllowThreads();
51911 (arg1)->RemoveGrowableRow(arg2);
51912 wxPyEndAllowThreads(__tstate);
51913 if (PyErr_Occurred()) SWIG_fail;
51914 }
51915 resultobj = SWIG_Py_Void();
51916 return resultobj;
51917 fail:
51918 return NULL;
51919 }
51920
51921
51922 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51923 PyObject *resultobj = 0;
51924 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51925 size_t arg2 ;
51926 int arg3 = (int) 0 ;
51927 void *argp1 = 0 ;
51928 int res1 = 0 ;
51929 size_t val2 ;
51930 int ecode2 = 0 ;
51931 int val3 ;
51932 int ecode3 = 0 ;
51933 PyObject * obj0 = 0 ;
51934 PyObject * obj1 = 0 ;
51935 PyObject * obj2 = 0 ;
51936 char * kwnames[] = {
51937 (char *) "self",(char *) "idx",(char *) "proportion", NULL
51938 };
51939
51940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51942 if (!SWIG_IsOK(res1)) {
51943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51944 }
51945 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51946 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51947 if (!SWIG_IsOK(ecode2)) {
51948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
51949 }
51950 arg2 = static_cast< size_t >(val2);
51951 if (obj2) {
51952 ecode3 = SWIG_AsVal_int(obj2, &val3);
51953 if (!SWIG_IsOK(ecode3)) {
51954 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
51955 }
51956 arg3 = static_cast< int >(val3);
51957 }
51958 {
51959 PyThreadState* __tstate = wxPyBeginAllowThreads();
51960 (arg1)->AddGrowableCol(arg2,arg3);
51961 wxPyEndAllowThreads(__tstate);
51962 if (PyErr_Occurred()) SWIG_fail;
51963 }
51964 resultobj = SWIG_Py_Void();
51965 return resultobj;
51966 fail:
51967 return NULL;
51968 }
51969
51970
51971 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51972 PyObject *resultobj = 0;
51973 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51974 size_t arg2 ;
51975 void *argp1 = 0 ;
51976 int res1 = 0 ;
51977 size_t val2 ;
51978 int ecode2 = 0 ;
51979 PyObject * obj0 = 0 ;
51980 PyObject * obj1 = 0 ;
51981 char * kwnames[] = {
51982 (char *) "self",(char *) "idx", NULL
51983 };
51984
51985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
51986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51987 if (!SWIG_IsOK(res1)) {
51988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51989 }
51990 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51991 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51992 if (!SWIG_IsOK(ecode2)) {
51993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
51994 }
51995 arg2 = static_cast< size_t >(val2);
51996 {
51997 PyThreadState* __tstate = wxPyBeginAllowThreads();
51998 (arg1)->RemoveGrowableCol(arg2);
51999 wxPyEndAllowThreads(__tstate);
52000 if (PyErr_Occurred()) SWIG_fail;
52001 }
52002 resultobj = SWIG_Py_Void();
52003 return resultobj;
52004 fail:
52005 return NULL;
52006 }
52007
52008
52009 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52010 PyObject *resultobj = 0;
52011 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52012 int arg2 ;
52013 void *argp1 = 0 ;
52014 int res1 = 0 ;
52015 int val2 ;
52016 int ecode2 = 0 ;
52017 PyObject * obj0 = 0 ;
52018 PyObject * obj1 = 0 ;
52019 char * kwnames[] = {
52020 (char *) "self",(char *) "direction", NULL
52021 };
52022
52023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
52024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52025 if (!SWIG_IsOK(res1)) {
52026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52027 }
52028 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52029 ecode2 = SWIG_AsVal_int(obj1, &val2);
52030 if (!SWIG_IsOK(ecode2)) {
52031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
52032 }
52033 arg2 = static_cast< int >(val2);
52034 {
52035 PyThreadState* __tstate = wxPyBeginAllowThreads();
52036 (arg1)->SetFlexibleDirection(arg2);
52037 wxPyEndAllowThreads(__tstate);
52038 if (PyErr_Occurred()) SWIG_fail;
52039 }
52040 resultobj = SWIG_Py_Void();
52041 return resultobj;
52042 fail:
52043 return NULL;
52044 }
52045
52046
52047 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52048 PyObject *resultobj = 0;
52049 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52050 int result;
52051 void *argp1 = 0 ;
52052 int res1 = 0 ;
52053 PyObject *swig_obj[1] ;
52054
52055 if (!args) SWIG_fail;
52056 swig_obj[0] = args;
52057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52058 if (!SWIG_IsOK(res1)) {
52059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52060 }
52061 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52062 {
52063 PyThreadState* __tstate = wxPyBeginAllowThreads();
52064 result = (int)(arg1)->GetFlexibleDirection();
52065 wxPyEndAllowThreads(__tstate);
52066 if (PyErr_Occurred()) SWIG_fail;
52067 }
52068 resultobj = SWIG_From_int(static_cast< int >(result));
52069 return resultobj;
52070 fail:
52071 return NULL;
52072 }
52073
52074
52075 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52076 PyObject *resultobj = 0;
52077 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52078 wxFlexSizerGrowMode arg2 ;
52079 void *argp1 = 0 ;
52080 int res1 = 0 ;
52081 int val2 ;
52082 int ecode2 = 0 ;
52083 PyObject * obj0 = 0 ;
52084 PyObject * obj1 = 0 ;
52085 char * kwnames[] = {
52086 (char *) "self",(char *) "mode", NULL
52087 };
52088
52089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
52090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52091 if (!SWIG_IsOK(res1)) {
52092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52093 }
52094 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52095 ecode2 = SWIG_AsVal_int(obj1, &val2);
52096 if (!SWIG_IsOK(ecode2)) {
52097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
52098 }
52099 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
52100 {
52101 PyThreadState* __tstate = wxPyBeginAllowThreads();
52102 (arg1)->SetNonFlexibleGrowMode(arg2);
52103 wxPyEndAllowThreads(__tstate);
52104 if (PyErr_Occurred()) SWIG_fail;
52105 }
52106 resultobj = SWIG_Py_Void();
52107 return resultobj;
52108 fail:
52109 return NULL;
52110 }
52111
52112
52113 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52114 PyObject *resultobj = 0;
52115 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52116 wxFlexSizerGrowMode result;
52117 void *argp1 = 0 ;
52118 int res1 = 0 ;
52119 PyObject *swig_obj[1] ;
52120
52121 if (!args) SWIG_fail;
52122 swig_obj[0] = args;
52123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52124 if (!SWIG_IsOK(res1)) {
52125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52126 }
52127 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52128 {
52129 PyThreadState* __tstate = wxPyBeginAllowThreads();
52130 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
52131 wxPyEndAllowThreads(__tstate);
52132 if (PyErr_Occurred()) SWIG_fail;
52133 }
52134 resultobj = SWIG_From_int(static_cast< int >(result));
52135 return resultobj;
52136 fail:
52137 return NULL;
52138 }
52139
52140
52141 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52142 PyObject *resultobj = 0;
52143 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52144 wxArrayInt *result = 0 ;
52145 void *argp1 = 0 ;
52146 int res1 = 0 ;
52147 PyObject *swig_obj[1] ;
52148
52149 if (!args) SWIG_fail;
52150 swig_obj[0] = args;
52151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52152 if (!SWIG_IsOK(res1)) {
52153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52154 }
52155 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52156 {
52157 PyThreadState* __tstate = wxPyBeginAllowThreads();
52158 {
52159 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
52160 result = (wxArrayInt *) &_result_ref;
52161 }
52162 wxPyEndAllowThreads(__tstate);
52163 if (PyErr_Occurred()) SWIG_fail;
52164 }
52165 {
52166 resultobj = wxArrayInt2PyList_helper(*result);
52167 }
52168 return resultobj;
52169 fail:
52170 return NULL;
52171 }
52172
52173
52174 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52175 PyObject *resultobj = 0;
52176 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52177 wxArrayInt *result = 0 ;
52178 void *argp1 = 0 ;
52179 int res1 = 0 ;
52180 PyObject *swig_obj[1] ;
52181
52182 if (!args) SWIG_fail;
52183 swig_obj[0] = args;
52184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52185 if (!SWIG_IsOK(res1)) {
52186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52187 }
52188 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52189 {
52190 PyThreadState* __tstate = wxPyBeginAllowThreads();
52191 {
52192 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
52193 result = (wxArrayInt *) &_result_ref;
52194 }
52195 wxPyEndAllowThreads(__tstate);
52196 if (PyErr_Occurred()) SWIG_fail;
52197 }
52198 {
52199 resultobj = wxArrayInt2PyList_helper(*result);
52200 }
52201 return resultobj;
52202 fail:
52203 return NULL;
52204 }
52205
52206
52207 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52208 PyObject *obj;
52209 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52210 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
52211 return SWIG_Py_Void();
52212 }
52213
52214 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52215 return SWIG_Python_InitShadowInstance(args);
52216 }
52217
52218 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52219 PyObject *resultobj = 0;
52220 wxStdDialogButtonSizer *result = 0 ;
52221
52222 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
52223 {
52224 PyThreadState* __tstate = wxPyBeginAllowThreads();
52225 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
52226 wxPyEndAllowThreads(__tstate);
52227 if (PyErr_Occurred()) SWIG_fail;
52228 }
52229 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
52230 return resultobj;
52231 fail:
52232 return NULL;
52233 }
52234
52235
52236 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52237 PyObject *resultobj = 0;
52238 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52239 wxButton *arg2 = (wxButton *) 0 ;
52240 void *argp1 = 0 ;
52241 int res1 = 0 ;
52242 void *argp2 = 0 ;
52243 int res2 = 0 ;
52244 PyObject * obj0 = 0 ;
52245 PyObject * obj1 = 0 ;
52246 char * kwnames[] = {
52247 (char *) "self",(char *) "button", NULL
52248 };
52249
52250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
52251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52252 if (!SWIG_IsOK(res1)) {
52253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52254 }
52255 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52256 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52257 if (!SWIG_IsOK(res2)) {
52258 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
52259 }
52260 arg2 = reinterpret_cast< wxButton * >(argp2);
52261 {
52262 PyThreadState* __tstate = wxPyBeginAllowThreads();
52263 (arg1)->AddButton(arg2);
52264 wxPyEndAllowThreads(__tstate);
52265 if (PyErr_Occurred()) SWIG_fail;
52266 }
52267 resultobj = SWIG_Py_Void();
52268 return resultobj;
52269 fail:
52270 return NULL;
52271 }
52272
52273
52274 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52275 PyObject *resultobj = 0;
52276 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52277 void *argp1 = 0 ;
52278 int res1 = 0 ;
52279 PyObject *swig_obj[1] ;
52280
52281 if (!args) SWIG_fail;
52282 swig_obj[0] = args;
52283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52284 if (!SWIG_IsOK(res1)) {
52285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52286 }
52287 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52288 {
52289 PyThreadState* __tstate = wxPyBeginAllowThreads();
52290 (arg1)->Realize();
52291 wxPyEndAllowThreads(__tstate);
52292 if (PyErr_Occurred()) SWIG_fail;
52293 }
52294 resultobj = SWIG_Py_Void();
52295 return resultobj;
52296 fail:
52297 return NULL;
52298 }
52299
52300
52301 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52302 PyObject *resultobj = 0;
52303 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52304 wxButton *arg2 = (wxButton *) 0 ;
52305 void *argp1 = 0 ;
52306 int res1 = 0 ;
52307 void *argp2 = 0 ;
52308 int res2 = 0 ;
52309 PyObject * obj0 = 0 ;
52310 PyObject * obj1 = 0 ;
52311 char * kwnames[] = {
52312 (char *) "self",(char *) "button", NULL
52313 };
52314
52315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52317 if (!SWIG_IsOK(res1)) {
52318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52319 }
52320 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52321 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52322 if (!SWIG_IsOK(res2)) {
52323 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52324 }
52325 arg2 = reinterpret_cast< wxButton * >(argp2);
52326 {
52327 PyThreadState* __tstate = wxPyBeginAllowThreads();
52328 (arg1)->SetAffirmativeButton(arg2);
52329 wxPyEndAllowThreads(__tstate);
52330 if (PyErr_Occurred()) SWIG_fail;
52331 }
52332 resultobj = SWIG_Py_Void();
52333 return resultobj;
52334 fail:
52335 return NULL;
52336 }
52337
52338
52339 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52340 PyObject *resultobj = 0;
52341 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52342 wxButton *arg2 = (wxButton *) 0 ;
52343 void *argp1 = 0 ;
52344 int res1 = 0 ;
52345 void *argp2 = 0 ;
52346 int res2 = 0 ;
52347 PyObject * obj0 = 0 ;
52348 PyObject * obj1 = 0 ;
52349 char * kwnames[] = {
52350 (char *) "self",(char *) "button", NULL
52351 };
52352
52353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52355 if (!SWIG_IsOK(res1)) {
52356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52357 }
52358 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52359 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52360 if (!SWIG_IsOK(res2)) {
52361 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52362 }
52363 arg2 = reinterpret_cast< wxButton * >(argp2);
52364 {
52365 PyThreadState* __tstate = wxPyBeginAllowThreads();
52366 (arg1)->SetNegativeButton(arg2);
52367 wxPyEndAllowThreads(__tstate);
52368 if (PyErr_Occurred()) SWIG_fail;
52369 }
52370 resultobj = SWIG_Py_Void();
52371 return resultobj;
52372 fail:
52373 return NULL;
52374 }
52375
52376
52377 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52378 PyObject *resultobj = 0;
52379 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52380 wxButton *arg2 = (wxButton *) 0 ;
52381 void *argp1 = 0 ;
52382 int res1 = 0 ;
52383 void *argp2 = 0 ;
52384 int res2 = 0 ;
52385 PyObject * obj0 = 0 ;
52386 PyObject * obj1 = 0 ;
52387 char * kwnames[] = {
52388 (char *) "self",(char *) "button", NULL
52389 };
52390
52391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
52392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52393 if (!SWIG_IsOK(res1)) {
52394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52395 }
52396 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52397 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52398 if (!SWIG_IsOK(res2)) {
52399 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
52400 }
52401 arg2 = reinterpret_cast< wxButton * >(argp2);
52402 {
52403 PyThreadState* __tstate = wxPyBeginAllowThreads();
52404 (arg1)->SetCancelButton(arg2);
52405 wxPyEndAllowThreads(__tstate);
52406 if (PyErr_Occurred()) SWIG_fail;
52407 }
52408 resultobj = SWIG_Py_Void();
52409 return resultobj;
52410 fail:
52411 return NULL;
52412 }
52413
52414
52415 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52416 PyObject *resultobj = 0;
52417 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52418 wxButton *result = 0 ;
52419 void *argp1 = 0 ;
52420 int res1 = 0 ;
52421 PyObject *swig_obj[1] ;
52422
52423 if (!args) SWIG_fail;
52424 swig_obj[0] = args;
52425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52426 if (!SWIG_IsOK(res1)) {
52427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52428 }
52429 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52430 {
52431 PyThreadState* __tstate = wxPyBeginAllowThreads();
52432 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
52433 wxPyEndAllowThreads(__tstate);
52434 if (PyErr_Occurred()) SWIG_fail;
52435 }
52436 {
52437 resultobj = wxPyMake_wxObject(result, (bool)0);
52438 }
52439 return resultobj;
52440 fail:
52441 return NULL;
52442 }
52443
52444
52445 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52446 PyObject *resultobj = 0;
52447 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52448 wxButton *result = 0 ;
52449 void *argp1 = 0 ;
52450 int res1 = 0 ;
52451 PyObject *swig_obj[1] ;
52452
52453 if (!args) SWIG_fail;
52454 swig_obj[0] = args;
52455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52456 if (!SWIG_IsOK(res1)) {
52457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52458 }
52459 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52460 {
52461 PyThreadState* __tstate = wxPyBeginAllowThreads();
52462 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
52463 wxPyEndAllowThreads(__tstate);
52464 if (PyErr_Occurred()) SWIG_fail;
52465 }
52466 {
52467 resultobj = wxPyMake_wxObject(result, (bool)0);
52468 }
52469 return resultobj;
52470 fail:
52471 return NULL;
52472 }
52473
52474
52475 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52476 PyObject *resultobj = 0;
52477 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52478 wxButton *result = 0 ;
52479 void *argp1 = 0 ;
52480 int res1 = 0 ;
52481 PyObject *swig_obj[1] ;
52482
52483 if (!args) SWIG_fail;
52484 swig_obj[0] = args;
52485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52486 if (!SWIG_IsOK(res1)) {
52487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52488 }
52489 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52490 {
52491 PyThreadState* __tstate = wxPyBeginAllowThreads();
52492 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
52493 wxPyEndAllowThreads(__tstate);
52494 if (PyErr_Occurred()) SWIG_fail;
52495 }
52496 {
52497 resultobj = wxPyMake_wxObject(result, (bool)0);
52498 }
52499 return resultobj;
52500 fail:
52501 return NULL;
52502 }
52503
52504
52505 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52506 PyObject *resultobj = 0;
52507 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52508 wxButton *result = 0 ;
52509 void *argp1 = 0 ;
52510 int res1 = 0 ;
52511 PyObject *swig_obj[1] ;
52512
52513 if (!args) SWIG_fail;
52514 swig_obj[0] = args;
52515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52516 if (!SWIG_IsOK(res1)) {
52517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52518 }
52519 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52520 {
52521 PyThreadState* __tstate = wxPyBeginAllowThreads();
52522 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
52523 wxPyEndAllowThreads(__tstate);
52524 if (PyErr_Occurred()) SWIG_fail;
52525 }
52526 {
52527 resultobj = wxPyMake_wxObject(result, (bool)0);
52528 }
52529 return resultobj;
52530 fail:
52531 return NULL;
52532 }
52533
52534
52535 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52536 PyObject *resultobj = 0;
52537 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52538 wxButton *result = 0 ;
52539 void *argp1 = 0 ;
52540 int res1 = 0 ;
52541 PyObject *swig_obj[1] ;
52542
52543 if (!args) SWIG_fail;
52544 swig_obj[0] = args;
52545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52546 if (!SWIG_IsOK(res1)) {
52547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52548 }
52549 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52550 {
52551 PyThreadState* __tstate = wxPyBeginAllowThreads();
52552 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
52553 wxPyEndAllowThreads(__tstate);
52554 if (PyErr_Occurred()) SWIG_fail;
52555 }
52556 {
52557 resultobj = wxPyMake_wxObject(result, (bool)0);
52558 }
52559 return resultobj;
52560 fail:
52561 return NULL;
52562 }
52563
52564
52565 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52566 PyObject *obj;
52567 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52568 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
52569 return SWIG_Py_Void();
52570 }
52571
52572 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52573 return SWIG_Python_InitShadowInstance(args);
52574 }
52575
52576 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52577 PyObject *resultobj = 0;
52578 int arg1 = (int) 0 ;
52579 int arg2 = (int) 0 ;
52580 wxGBPosition *result = 0 ;
52581 int val1 ;
52582 int ecode1 = 0 ;
52583 int val2 ;
52584 int ecode2 = 0 ;
52585 PyObject * obj0 = 0 ;
52586 PyObject * obj1 = 0 ;
52587 char * kwnames[] = {
52588 (char *) "row",(char *) "col", NULL
52589 };
52590
52591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52592 if (obj0) {
52593 ecode1 = SWIG_AsVal_int(obj0, &val1);
52594 if (!SWIG_IsOK(ecode1)) {
52595 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
52596 }
52597 arg1 = static_cast< int >(val1);
52598 }
52599 if (obj1) {
52600 ecode2 = SWIG_AsVal_int(obj1, &val2);
52601 if (!SWIG_IsOK(ecode2)) {
52602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
52603 }
52604 arg2 = static_cast< int >(val2);
52605 }
52606 {
52607 PyThreadState* __tstate = wxPyBeginAllowThreads();
52608 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
52609 wxPyEndAllowThreads(__tstate);
52610 if (PyErr_Occurred()) SWIG_fail;
52611 }
52612 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
52613 return resultobj;
52614 fail:
52615 return NULL;
52616 }
52617
52618
52619 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52620 PyObject *resultobj = 0;
52621 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52622 void *argp1 = 0 ;
52623 int res1 = 0 ;
52624 PyObject *swig_obj[1] ;
52625
52626 if (!args) SWIG_fail;
52627 swig_obj[0] = args;
52628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
52629 if (!SWIG_IsOK(res1)) {
52630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52631 }
52632 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52633 {
52634 PyThreadState* __tstate = wxPyBeginAllowThreads();
52635 delete arg1;
52636
52637 wxPyEndAllowThreads(__tstate);
52638 if (PyErr_Occurred()) SWIG_fail;
52639 }
52640 resultobj = SWIG_Py_Void();
52641 return resultobj;
52642 fail:
52643 return NULL;
52644 }
52645
52646
52647 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52648 PyObject *resultobj = 0;
52649 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52650 int result;
52651 void *argp1 = 0 ;
52652 int res1 = 0 ;
52653 PyObject *swig_obj[1] ;
52654
52655 if (!args) SWIG_fail;
52656 swig_obj[0] = args;
52657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52658 if (!SWIG_IsOK(res1)) {
52659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52660 }
52661 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52662 {
52663 PyThreadState* __tstate = wxPyBeginAllowThreads();
52664 result = (int)((wxGBPosition const *)arg1)->GetRow();
52665 wxPyEndAllowThreads(__tstate);
52666 if (PyErr_Occurred()) SWIG_fail;
52667 }
52668 resultobj = SWIG_From_int(static_cast< int >(result));
52669 return resultobj;
52670 fail:
52671 return NULL;
52672 }
52673
52674
52675 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52676 PyObject *resultobj = 0;
52677 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52678 int result;
52679 void *argp1 = 0 ;
52680 int res1 = 0 ;
52681 PyObject *swig_obj[1] ;
52682
52683 if (!args) SWIG_fail;
52684 swig_obj[0] = args;
52685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52686 if (!SWIG_IsOK(res1)) {
52687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52688 }
52689 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52690 {
52691 PyThreadState* __tstate = wxPyBeginAllowThreads();
52692 result = (int)((wxGBPosition const *)arg1)->GetCol();
52693 wxPyEndAllowThreads(__tstate);
52694 if (PyErr_Occurred()) SWIG_fail;
52695 }
52696 resultobj = SWIG_From_int(static_cast< int >(result));
52697 return resultobj;
52698 fail:
52699 return NULL;
52700 }
52701
52702
52703 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52704 PyObject *resultobj = 0;
52705 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52706 int arg2 ;
52707 void *argp1 = 0 ;
52708 int res1 = 0 ;
52709 int val2 ;
52710 int ecode2 = 0 ;
52711 PyObject * obj0 = 0 ;
52712 PyObject * obj1 = 0 ;
52713 char * kwnames[] = {
52714 (char *) "self",(char *) "row", NULL
52715 };
52716
52717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
52718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52719 if (!SWIG_IsOK(res1)) {
52720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52721 }
52722 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52723 ecode2 = SWIG_AsVal_int(obj1, &val2);
52724 if (!SWIG_IsOK(ecode2)) {
52725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
52726 }
52727 arg2 = static_cast< int >(val2);
52728 {
52729 PyThreadState* __tstate = wxPyBeginAllowThreads();
52730 (arg1)->SetRow(arg2);
52731 wxPyEndAllowThreads(__tstate);
52732 if (PyErr_Occurred()) SWIG_fail;
52733 }
52734 resultobj = SWIG_Py_Void();
52735 return resultobj;
52736 fail:
52737 return NULL;
52738 }
52739
52740
52741 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52742 PyObject *resultobj = 0;
52743 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52744 int arg2 ;
52745 void *argp1 = 0 ;
52746 int res1 = 0 ;
52747 int val2 ;
52748 int ecode2 = 0 ;
52749 PyObject * obj0 = 0 ;
52750 PyObject * obj1 = 0 ;
52751 char * kwnames[] = {
52752 (char *) "self",(char *) "col", NULL
52753 };
52754
52755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
52756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52757 if (!SWIG_IsOK(res1)) {
52758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52759 }
52760 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52761 ecode2 = SWIG_AsVal_int(obj1, &val2);
52762 if (!SWIG_IsOK(ecode2)) {
52763 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
52764 }
52765 arg2 = static_cast< int >(val2);
52766 {
52767 PyThreadState* __tstate = wxPyBeginAllowThreads();
52768 (arg1)->SetCol(arg2);
52769 wxPyEndAllowThreads(__tstate);
52770 if (PyErr_Occurred()) SWIG_fail;
52771 }
52772 resultobj = SWIG_Py_Void();
52773 return resultobj;
52774 fail:
52775 return NULL;
52776 }
52777
52778
52779 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52780 PyObject *resultobj = 0;
52781 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52782 PyObject *arg2 = (PyObject *) 0 ;
52783 bool result;
52784 void *argp1 = 0 ;
52785 int res1 = 0 ;
52786 PyObject * obj0 = 0 ;
52787 PyObject * obj1 = 0 ;
52788 char * kwnames[] = {
52789 (char *) "self",(char *) "other", NULL
52790 };
52791
52792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
52793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52794 if (!SWIG_IsOK(res1)) {
52795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52796 }
52797 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52798 arg2 = obj1;
52799 {
52800 result = (bool)wxGBPosition___eq__(arg1,arg2);
52801 if (PyErr_Occurred()) SWIG_fail;
52802 }
52803 {
52804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52805 }
52806 return resultobj;
52807 fail:
52808 return NULL;
52809 }
52810
52811
52812 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52813 PyObject *resultobj = 0;
52814 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52815 PyObject *arg2 = (PyObject *) 0 ;
52816 bool result;
52817 void *argp1 = 0 ;
52818 int res1 = 0 ;
52819 PyObject * obj0 = 0 ;
52820 PyObject * obj1 = 0 ;
52821 char * kwnames[] = {
52822 (char *) "self",(char *) "other", NULL
52823 };
52824
52825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
52826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52827 if (!SWIG_IsOK(res1)) {
52828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52829 }
52830 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52831 arg2 = obj1;
52832 {
52833 result = (bool)wxGBPosition___ne__(arg1,arg2);
52834 if (PyErr_Occurred()) SWIG_fail;
52835 }
52836 {
52837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52838 }
52839 return resultobj;
52840 fail:
52841 return NULL;
52842 }
52843
52844
52845 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52846 PyObject *resultobj = 0;
52847 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52848 int arg2 = (int) 0 ;
52849 int arg3 = (int) 0 ;
52850 void *argp1 = 0 ;
52851 int res1 = 0 ;
52852 int val2 ;
52853 int ecode2 = 0 ;
52854 int val3 ;
52855 int ecode3 = 0 ;
52856 PyObject * obj0 = 0 ;
52857 PyObject * obj1 = 0 ;
52858 PyObject * obj2 = 0 ;
52859 char * kwnames[] = {
52860 (char *) "self",(char *) "row",(char *) "col", NULL
52861 };
52862
52863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52865 if (!SWIG_IsOK(res1)) {
52866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52867 }
52868 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52869 if (obj1) {
52870 ecode2 = SWIG_AsVal_int(obj1, &val2);
52871 if (!SWIG_IsOK(ecode2)) {
52872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
52873 }
52874 arg2 = static_cast< int >(val2);
52875 }
52876 if (obj2) {
52877 ecode3 = SWIG_AsVal_int(obj2, &val3);
52878 if (!SWIG_IsOK(ecode3)) {
52879 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
52880 }
52881 arg3 = static_cast< int >(val3);
52882 }
52883 {
52884 PyThreadState* __tstate = wxPyBeginAllowThreads();
52885 wxGBPosition_Set(arg1,arg2,arg3);
52886 wxPyEndAllowThreads(__tstate);
52887 if (PyErr_Occurred()) SWIG_fail;
52888 }
52889 resultobj = SWIG_Py_Void();
52890 return resultobj;
52891 fail:
52892 return NULL;
52893 }
52894
52895
52896 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52897 PyObject *resultobj = 0;
52898 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52899 PyObject *result = 0 ;
52900 void *argp1 = 0 ;
52901 int res1 = 0 ;
52902 PyObject *swig_obj[1] ;
52903
52904 if (!args) SWIG_fail;
52905 swig_obj[0] = args;
52906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52907 if (!SWIG_IsOK(res1)) {
52908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52909 }
52910 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52911 {
52912 PyThreadState* __tstate = wxPyBeginAllowThreads();
52913 result = (PyObject *)wxGBPosition_Get(arg1);
52914 wxPyEndAllowThreads(__tstate);
52915 if (PyErr_Occurred()) SWIG_fail;
52916 }
52917 resultobj = result;
52918 return resultobj;
52919 fail:
52920 return NULL;
52921 }
52922
52923
52924 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52925 PyObject *obj;
52926 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52927 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
52928 return SWIG_Py_Void();
52929 }
52930
52931 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52932 return SWIG_Python_InitShadowInstance(args);
52933 }
52934
52935 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52936 PyObject *resultobj = 0;
52937 int arg1 = (int) 1 ;
52938 int arg2 = (int) 1 ;
52939 wxGBSpan *result = 0 ;
52940 int val1 ;
52941 int ecode1 = 0 ;
52942 int val2 ;
52943 int ecode2 = 0 ;
52944 PyObject * obj0 = 0 ;
52945 PyObject * obj1 = 0 ;
52946 char * kwnames[] = {
52947 (char *) "rowspan",(char *) "colspan", NULL
52948 };
52949
52950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
52951 if (obj0) {
52952 ecode1 = SWIG_AsVal_int(obj0, &val1);
52953 if (!SWIG_IsOK(ecode1)) {
52954 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
52955 }
52956 arg1 = static_cast< int >(val1);
52957 }
52958 if (obj1) {
52959 ecode2 = SWIG_AsVal_int(obj1, &val2);
52960 if (!SWIG_IsOK(ecode2)) {
52961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
52962 }
52963 arg2 = static_cast< int >(val2);
52964 }
52965 {
52966 PyThreadState* __tstate = wxPyBeginAllowThreads();
52967 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
52968 wxPyEndAllowThreads(__tstate);
52969 if (PyErr_Occurred()) SWIG_fail;
52970 }
52971 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
52972 return resultobj;
52973 fail:
52974 return NULL;
52975 }
52976
52977
52978 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52979 PyObject *resultobj = 0;
52980 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52981 void *argp1 = 0 ;
52982 int res1 = 0 ;
52983 PyObject *swig_obj[1] ;
52984
52985 if (!args) SWIG_fail;
52986 swig_obj[0] = args;
52987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
52988 if (!SWIG_IsOK(res1)) {
52989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
52990 }
52991 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
52992 {
52993 PyThreadState* __tstate = wxPyBeginAllowThreads();
52994 delete arg1;
52995
52996 wxPyEndAllowThreads(__tstate);
52997 if (PyErr_Occurred()) SWIG_fail;
52998 }
52999 resultobj = SWIG_Py_Void();
53000 return resultobj;
53001 fail:
53002 return NULL;
53003 }
53004
53005
53006 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53007 PyObject *resultobj = 0;
53008 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53009 int result;
53010 void *argp1 = 0 ;
53011 int res1 = 0 ;
53012 PyObject *swig_obj[1] ;
53013
53014 if (!args) SWIG_fail;
53015 swig_obj[0] = args;
53016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53017 if (!SWIG_IsOK(res1)) {
53018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
53019 }
53020 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53021 {
53022 PyThreadState* __tstate = wxPyBeginAllowThreads();
53023 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
53024 wxPyEndAllowThreads(__tstate);
53025 if (PyErr_Occurred()) SWIG_fail;
53026 }
53027 resultobj = SWIG_From_int(static_cast< int >(result));
53028 return resultobj;
53029 fail:
53030 return NULL;
53031 }
53032
53033
53034 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53035 PyObject *resultobj = 0;
53036 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53037 int result;
53038 void *argp1 = 0 ;
53039 int res1 = 0 ;
53040 PyObject *swig_obj[1] ;
53041
53042 if (!args) SWIG_fail;
53043 swig_obj[0] = args;
53044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53045 if (!SWIG_IsOK(res1)) {
53046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
53047 }
53048 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53049 {
53050 PyThreadState* __tstate = wxPyBeginAllowThreads();
53051 result = (int)((wxGBSpan const *)arg1)->GetColspan();
53052 wxPyEndAllowThreads(__tstate);
53053 if (PyErr_Occurred()) SWIG_fail;
53054 }
53055 resultobj = SWIG_From_int(static_cast< int >(result));
53056 return resultobj;
53057 fail:
53058 return NULL;
53059 }
53060
53061
53062 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53063 PyObject *resultobj = 0;
53064 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53065 int arg2 ;
53066 void *argp1 = 0 ;
53067 int res1 = 0 ;
53068 int val2 ;
53069 int ecode2 = 0 ;
53070 PyObject * obj0 = 0 ;
53071 PyObject * obj1 = 0 ;
53072 char * kwnames[] = {
53073 (char *) "self",(char *) "rowspan", NULL
53074 };
53075
53076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
53077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53078 if (!SWIG_IsOK(res1)) {
53079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53080 }
53081 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53082 ecode2 = SWIG_AsVal_int(obj1, &val2);
53083 if (!SWIG_IsOK(ecode2)) {
53084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
53085 }
53086 arg2 = static_cast< int >(val2);
53087 {
53088 PyThreadState* __tstate = wxPyBeginAllowThreads();
53089 (arg1)->SetRowspan(arg2);
53090 wxPyEndAllowThreads(__tstate);
53091 if (PyErr_Occurred()) SWIG_fail;
53092 }
53093 resultobj = SWIG_Py_Void();
53094 return resultobj;
53095 fail:
53096 return NULL;
53097 }
53098
53099
53100 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53101 PyObject *resultobj = 0;
53102 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53103 int arg2 ;
53104 void *argp1 = 0 ;
53105 int res1 = 0 ;
53106 int val2 ;
53107 int ecode2 = 0 ;
53108 PyObject * obj0 = 0 ;
53109 PyObject * obj1 = 0 ;
53110 char * kwnames[] = {
53111 (char *) "self",(char *) "colspan", NULL
53112 };
53113
53114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
53115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53116 if (!SWIG_IsOK(res1)) {
53117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53118 }
53119 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53120 ecode2 = SWIG_AsVal_int(obj1, &val2);
53121 if (!SWIG_IsOK(ecode2)) {
53122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
53123 }
53124 arg2 = static_cast< int >(val2);
53125 {
53126 PyThreadState* __tstate = wxPyBeginAllowThreads();
53127 (arg1)->SetColspan(arg2);
53128 wxPyEndAllowThreads(__tstate);
53129 if (PyErr_Occurred()) SWIG_fail;
53130 }
53131 resultobj = SWIG_Py_Void();
53132 return resultobj;
53133 fail:
53134 return NULL;
53135 }
53136
53137
53138 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53139 PyObject *resultobj = 0;
53140 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53141 PyObject *arg2 = (PyObject *) 0 ;
53142 bool result;
53143 void *argp1 = 0 ;
53144 int res1 = 0 ;
53145 PyObject * obj0 = 0 ;
53146 PyObject * obj1 = 0 ;
53147 char * kwnames[] = {
53148 (char *) "self",(char *) "other", NULL
53149 };
53150
53151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
53152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53153 if (!SWIG_IsOK(res1)) {
53154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53155 }
53156 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53157 arg2 = obj1;
53158 {
53159 result = (bool)wxGBSpan___eq__(arg1,arg2);
53160 if (PyErr_Occurred()) SWIG_fail;
53161 }
53162 {
53163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53164 }
53165 return resultobj;
53166 fail:
53167 return NULL;
53168 }
53169
53170
53171 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53172 PyObject *resultobj = 0;
53173 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53174 PyObject *arg2 = (PyObject *) 0 ;
53175 bool result;
53176 void *argp1 = 0 ;
53177 int res1 = 0 ;
53178 PyObject * obj0 = 0 ;
53179 PyObject * obj1 = 0 ;
53180 char * kwnames[] = {
53181 (char *) "self",(char *) "other", NULL
53182 };
53183
53184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
53185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53186 if (!SWIG_IsOK(res1)) {
53187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53188 }
53189 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53190 arg2 = obj1;
53191 {
53192 result = (bool)wxGBSpan___ne__(arg1,arg2);
53193 if (PyErr_Occurred()) SWIG_fail;
53194 }
53195 {
53196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53197 }
53198 return resultobj;
53199 fail:
53200 return NULL;
53201 }
53202
53203
53204 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53205 PyObject *resultobj = 0;
53206 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53207 int arg2 = (int) 1 ;
53208 int arg3 = (int) 1 ;
53209 void *argp1 = 0 ;
53210 int res1 = 0 ;
53211 int val2 ;
53212 int ecode2 = 0 ;
53213 int val3 ;
53214 int ecode3 = 0 ;
53215 PyObject * obj0 = 0 ;
53216 PyObject * obj1 = 0 ;
53217 PyObject * obj2 = 0 ;
53218 char * kwnames[] = {
53219 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
53220 };
53221
53222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53224 if (!SWIG_IsOK(res1)) {
53225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53226 }
53227 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53228 if (obj1) {
53229 ecode2 = SWIG_AsVal_int(obj1, &val2);
53230 if (!SWIG_IsOK(ecode2)) {
53231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
53232 }
53233 arg2 = static_cast< int >(val2);
53234 }
53235 if (obj2) {
53236 ecode3 = SWIG_AsVal_int(obj2, &val3);
53237 if (!SWIG_IsOK(ecode3)) {
53238 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
53239 }
53240 arg3 = static_cast< int >(val3);
53241 }
53242 {
53243 PyThreadState* __tstate = wxPyBeginAllowThreads();
53244 wxGBSpan_Set(arg1,arg2,arg3);
53245 wxPyEndAllowThreads(__tstate);
53246 if (PyErr_Occurred()) SWIG_fail;
53247 }
53248 resultobj = SWIG_Py_Void();
53249 return resultobj;
53250 fail:
53251 return NULL;
53252 }
53253
53254
53255 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53256 PyObject *resultobj = 0;
53257 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53258 PyObject *result = 0 ;
53259 void *argp1 = 0 ;
53260 int res1 = 0 ;
53261 PyObject *swig_obj[1] ;
53262
53263 if (!args) SWIG_fail;
53264 swig_obj[0] = args;
53265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53266 if (!SWIG_IsOK(res1)) {
53267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53268 }
53269 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53270 {
53271 PyThreadState* __tstate = wxPyBeginAllowThreads();
53272 result = (PyObject *)wxGBSpan_Get(arg1);
53273 wxPyEndAllowThreads(__tstate);
53274 if (PyErr_Occurred()) SWIG_fail;
53275 }
53276 resultobj = result;
53277 return resultobj;
53278 fail:
53279 return NULL;
53280 }
53281
53282
53283 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53284 PyObject *obj;
53285 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53286 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
53287 return SWIG_Py_Void();
53288 }
53289
53290 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53291 return SWIG_Python_InitShadowInstance(args);
53292 }
53293
53294 SWIGINTERN int DefaultSpan_set(PyObject *) {
53295 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
53296 return 1;
53297 }
53298
53299
53300 SWIGINTERN PyObject *DefaultSpan_get(void) {
53301 PyObject *pyobj = 0;
53302
53303 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
53304 return pyobj;
53305 }
53306
53307
53308 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53309 PyObject *resultobj = 0;
53310 wxGBSizerItem *result = 0 ;
53311
53312 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
53313 {
53314 PyThreadState* __tstate = wxPyBeginAllowThreads();
53315 result = (wxGBSizerItem *)new wxGBSizerItem();
53316 wxPyEndAllowThreads(__tstate);
53317 if (PyErr_Occurred()) SWIG_fail;
53318 }
53319 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
53320 return resultobj;
53321 fail:
53322 return NULL;
53323 }
53324
53325
53326 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53327 PyObject *resultobj = 0;
53328 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53329 void *argp1 = 0 ;
53330 int res1 = 0 ;
53331 PyObject *swig_obj[1] ;
53332
53333 if (!args) SWIG_fail;
53334 swig_obj[0] = args;
53335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
53336 if (!SWIG_IsOK(res1)) {
53337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53338 }
53339 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53340 {
53341 PyThreadState* __tstate = wxPyBeginAllowThreads();
53342 delete arg1;
53343
53344 wxPyEndAllowThreads(__tstate);
53345 if (PyErr_Occurred()) SWIG_fail;
53346 }
53347 resultobj = SWIG_Py_Void();
53348 return resultobj;
53349 fail:
53350 return NULL;
53351 }
53352
53353
53354 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53355 PyObject *resultobj = 0;
53356 wxWindow *arg1 = (wxWindow *) 0 ;
53357 wxGBPosition *arg2 = 0 ;
53358 wxGBSpan *arg3 = 0 ;
53359 int arg4 ;
53360 int arg5 ;
53361 PyObject *arg6 = (PyObject *) NULL ;
53362 wxGBSizerItem *result = 0 ;
53363 void *argp1 = 0 ;
53364 int res1 = 0 ;
53365 wxGBPosition temp2 ;
53366 wxGBSpan temp3 ;
53367 int val4 ;
53368 int ecode4 = 0 ;
53369 int val5 ;
53370 int ecode5 = 0 ;
53371 PyObject * obj0 = 0 ;
53372 PyObject * obj1 = 0 ;
53373 PyObject * obj2 = 0 ;
53374 PyObject * obj3 = 0 ;
53375 PyObject * obj4 = 0 ;
53376 PyObject * obj5 = 0 ;
53377 char * kwnames[] = {
53378 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53379 };
53380
53381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
53383 if (!SWIG_IsOK(res1)) {
53384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
53385 }
53386 arg1 = reinterpret_cast< wxWindow * >(argp1);
53387 {
53388 arg2 = &temp2;
53389 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53390 }
53391 {
53392 arg3 = &temp3;
53393 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53394 }
53395 ecode4 = SWIG_AsVal_int(obj3, &val4);
53396 if (!SWIG_IsOK(ecode4)) {
53397 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
53398 }
53399 arg4 = static_cast< int >(val4);
53400 ecode5 = SWIG_AsVal_int(obj4, &val5);
53401 if (!SWIG_IsOK(ecode5)) {
53402 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
53403 }
53404 arg5 = static_cast< int >(val5);
53405 if (obj5) {
53406 arg6 = obj5;
53407 }
53408 {
53409 PyThreadState* __tstate = wxPyBeginAllowThreads();
53410 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53411 wxPyEndAllowThreads(__tstate);
53412 if (PyErr_Occurred()) SWIG_fail;
53413 }
53414 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53415 return resultobj;
53416 fail:
53417 return NULL;
53418 }
53419
53420
53421 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53422 PyObject *resultobj = 0;
53423 wxSizer *arg1 = (wxSizer *) 0 ;
53424 wxGBPosition *arg2 = 0 ;
53425 wxGBSpan *arg3 = 0 ;
53426 int arg4 ;
53427 int arg5 ;
53428 PyObject *arg6 = (PyObject *) NULL ;
53429 wxGBSizerItem *result = 0 ;
53430 int res1 = 0 ;
53431 wxGBPosition temp2 ;
53432 wxGBSpan temp3 ;
53433 int val4 ;
53434 int ecode4 = 0 ;
53435 int val5 ;
53436 int ecode5 = 0 ;
53437 PyObject * obj0 = 0 ;
53438 PyObject * obj1 = 0 ;
53439 PyObject * obj2 = 0 ;
53440 PyObject * obj3 = 0 ;
53441 PyObject * obj4 = 0 ;
53442 PyObject * obj5 = 0 ;
53443 char * kwnames[] = {
53444 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53445 };
53446
53447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53448 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
53449 if (!SWIG_IsOK(res1)) {
53450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
53451 }
53452 {
53453 arg2 = &temp2;
53454 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53455 }
53456 {
53457 arg3 = &temp3;
53458 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53459 }
53460 ecode4 = SWIG_AsVal_int(obj3, &val4);
53461 if (!SWIG_IsOK(ecode4)) {
53462 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
53463 }
53464 arg4 = static_cast< int >(val4);
53465 ecode5 = SWIG_AsVal_int(obj4, &val5);
53466 if (!SWIG_IsOK(ecode5)) {
53467 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
53468 }
53469 arg5 = static_cast< int >(val5);
53470 if (obj5) {
53471 arg6 = obj5;
53472 }
53473 {
53474 PyThreadState* __tstate = wxPyBeginAllowThreads();
53475 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53476 wxPyEndAllowThreads(__tstate);
53477 if (PyErr_Occurred()) SWIG_fail;
53478 }
53479 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53480 return resultobj;
53481 fail:
53482 return NULL;
53483 }
53484
53485
53486 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53487 PyObject *resultobj = 0;
53488 int arg1 ;
53489 int arg2 ;
53490 wxGBPosition *arg3 = 0 ;
53491 wxGBSpan *arg4 = 0 ;
53492 int arg5 ;
53493 int arg6 ;
53494 PyObject *arg7 = (PyObject *) NULL ;
53495 wxGBSizerItem *result = 0 ;
53496 int val1 ;
53497 int ecode1 = 0 ;
53498 int val2 ;
53499 int ecode2 = 0 ;
53500 wxGBPosition temp3 ;
53501 wxGBSpan temp4 ;
53502 int val5 ;
53503 int ecode5 = 0 ;
53504 int val6 ;
53505 int ecode6 = 0 ;
53506 PyObject * obj0 = 0 ;
53507 PyObject * obj1 = 0 ;
53508 PyObject * obj2 = 0 ;
53509 PyObject * obj3 = 0 ;
53510 PyObject * obj4 = 0 ;
53511 PyObject * obj5 = 0 ;
53512 PyObject * obj6 = 0 ;
53513 char * kwnames[] = {
53514 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53515 };
53516
53517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
53518 ecode1 = SWIG_AsVal_int(obj0, &val1);
53519 if (!SWIG_IsOK(ecode1)) {
53520 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
53521 }
53522 arg1 = static_cast< int >(val1);
53523 ecode2 = SWIG_AsVal_int(obj1, &val2);
53524 if (!SWIG_IsOK(ecode2)) {
53525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
53526 }
53527 arg2 = static_cast< int >(val2);
53528 {
53529 arg3 = &temp3;
53530 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
53531 }
53532 {
53533 arg4 = &temp4;
53534 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
53535 }
53536 ecode5 = SWIG_AsVal_int(obj4, &val5);
53537 if (!SWIG_IsOK(ecode5)) {
53538 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
53539 }
53540 arg5 = static_cast< int >(val5);
53541 ecode6 = SWIG_AsVal_int(obj5, &val6);
53542 if (!SWIG_IsOK(ecode6)) {
53543 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
53544 }
53545 arg6 = static_cast< int >(val6);
53546 if (obj6) {
53547 arg7 = obj6;
53548 }
53549 {
53550 PyThreadState* __tstate = wxPyBeginAllowThreads();
53551 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
53552 wxPyEndAllowThreads(__tstate);
53553 if (PyErr_Occurred()) SWIG_fail;
53554 }
53555 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53556 return resultobj;
53557 fail:
53558 return NULL;
53559 }
53560
53561
53562 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53563 PyObject *resultobj = 0;
53564 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53565 wxGBPosition result;
53566 void *argp1 = 0 ;
53567 int res1 = 0 ;
53568 PyObject *swig_obj[1] ;
53569
53570 if (!args) SWIG_fail;
53571 swig_obj[0] = args;
53572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53573 if (!SWIG_IsOK(res1)) {
53574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53575 }
53576 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53577 {
53578 PyThreadState* __tstate = wxPyBeginAllowThreads();
53579 result = ((wxGBSizerItem const *)arg1)->GetPos();
53580 wxPyEndAllowThreads(__tstate);
53581 if (PyErr_Occurred()) SWIG_fail;
53582 }
53583 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53584 return resultobj;
53585 fail:
53586 return NULL;
53587 }
53588
53589
53590 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53591 PyObject *resultobj = 0;
53592 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53593 wxGBSpan result;
53594 void *argp1 = 0 ;
53595 int res1 = 0 ;
53596 PyObject *swig_obj[1] ;
53597
53598 if (!args) SWIG_fail;
53599 swig_obj[0] = args;
53600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53601 if (!SWIG_IsOK(res1)) {
53602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53603 }
53604 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53605 {
53606 PyThreadState* __tstate = wxPyBeginAllowThreads();
53607 result = ((wxGBSizerItem const *)arg1)->GetSpan();
53608 wxPyEndAllowThreads(__tstate);
53609 if (PyErr_Occurred()) SWIG_fail;
53610 }
53611 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
53612 return resultobj;
53613 fail:
53614 return NULL;
53615 }
53616
53617
53618 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53619 PyObject *resultobj = 0;
53620 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53621 wxGBPosition *arg2 = 0 ;
53622 bool result;
53623 void *argp1 = 0 ;
53624 int res1 = 0 ;
53625 wxGBPosition temp2 ;
53626 PyObject * obj0 = 0 ;
53627 PyObject * obj1 = 0 ;
53628 char * kwnames[] = {
53629 (char *) "self",(char *) "pos", NULL
53630 };
53631
53632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
53633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53634 if (!SWIG_IsOK(res1)) {
53635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53636 }
53637 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53638 {
53639 arg2 = &temp2;
53640 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53641 }
53642 {
53643 PyThreadState* __tstate = wxPyBeginAllowThreads();
53644 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
53645 wxPyEndAllowThreads(__tstate);
53646 if (PyErr_Occurred()) SWIG_fail;
53647 }
53648 {
53649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53650 }
53651 return resultobj;
53652 fail:
53653 return NULL;
53654 }
53655
53656
53657 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53658 PyObject *resultobj = 0;
53659 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53660 wxGBSpan *arg2 = 0 ;
53661 bool result;
53662 void *argp1 = 0 ;
53663 int res1 = 0 ;
53664 wxGBSpan temp2 ;
53665 PyObject * obj0 = 0 ;
53666 PyObject * obj1 = 0 ;
53667 char * kwnames[] = {
53668 (char *) "self",(char *) "span", NULL
53669 };
53670
53671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
53672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53673 if (!SWIG_IsOK(res1)) {
53674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53675 }
53676 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53677 {
53678 arg2 = &temp2;
53679 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
53680 }
53681 {
53682 PyThreadState* __tstate = wxPyBeginAllowThreads();
53683 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
53684 wxPyEndAllowThreads(__tstate);
53685 if (PyErr_Occurred()) SWIG_fail;
53686 }
53687 {
53688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53689 }
53690 return resultobj;
53691 fail:
53692 return NULL;
53693 }
53694
53695
53696 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53697 PyObject *resultobj = 0;
53698 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53699 wxGBSizerItem *arg2 = 0 ;
53700 bool result;
53701 void *argp1 = 0 ;
53702 int res1 = 0 ;
53703 void *argp2 = 0 ;
53704 int res2 = 0 ;
53705 PyObject * obj0 = 0 ;
53706 PyObject * obj1 = 0 ;
53707 char * kwnames[] = {
53708 (char *) "self",(char *) "other", NULL
53709 };
53710
53711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
53712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53713 if (!SWIG_IsOK(res1)) {
53714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53715 }
53716 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53717 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
53718 if (!SWIG_IsOK(res2)) {
53719 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53720 }
53721 if (!argp2) {
53722 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53723 }
53724 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
53725 {
53726 PyThreadState* __tstate = wxPyBeginAllowThreads();
53727 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
53728 wxPyEndAllowThreads(__tstate);
53729 if (PyErr_Occurred()) SWIG_fail;
53730 }
53731 {
53732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53733 }
53734 return resultobj;
53735 fail:
53736 return NULL;
53737 }
53738
53739
53740 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53741 PyObject *resultobj = 0;
53742 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53743 wxGBPosition *arg2 = 0 ;
53744 wxGBSpan *arg3 = 0 ;
53745 bool result;
53746 void *argp1 = 0 ;
53747 int res1 = 0 ;
53748 wxGBPosition temp2 ;
53749 wxGBSpan temp3 ;
53750 PyObject * obj0 = 0 ;
53751 PyObject * obj1 = 0 ;
53752 PyObject * obj2 = 0 ;
53753 char * kwnames[] = {
53754 (char *) "self",(char *) "pos",(char *) "span", NULL
53755 };
53756
53757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53759 if (!SWIG_IsOK(res1)) {
53760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53761 }
53762 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53763 {
53764 arg2 = &temp2;
53765 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53766 }
53767 {
53768 arg3 = &temp3;
53769 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53770 }
53771 {
53772 PyThreadState* __tstate = wxPyBeginAllowThreads();
53773 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
53774 wxPyEndAllowThreads(__tstate);
53775 if (PyErr_Occurred()) SWIG_fail;
53776 }
53777 {
53778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53779 }
53780 return resultobj;
53781 fail:
53782 return NULL;
53783 }
53784
53785
53786 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53787 PyObject *resultobj = 0;
53788 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53789 wxGBPosition result;
53790 void *argp1 = 0 ;
53791 int res1 = 0 ;
53792 PyObject *swig_obj[1] ;
53793
53794 if (!args) SWIG_fail;
53795 swig_obj[0] = args;
53796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53797 if (!SWIG_IsOK(res1)) {
53798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53799 }
53800 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53801 {
53802 PyThreadState* __tstate = wxPyBeginAllowThreads();
53803 result = wxGBSizerItem_GetEndPos(arg1);
53804 wxPyEndAllowThreads(__tstate);
53805 if (PyErr_Occurred()) SWIG_fail;
53806 }
53807 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53808 return resultobj;
53809 fail:
53810 return NULL;
53811 }
53812
53813
53814 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53815 PyObject *resultobj = 0;
53816 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53817 wxGridBagSizer *result = 0 ;
53818 void *argp1 = 0 ;
53819 int res1 = 0 ;
53820 PyObject *swig_obj[1] ;
53821
53822 if (!args) SWIG_fail;
53823 swig_obj[0] = args;
53824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53825 if (!SWIG_IsOK(res1)) {
53826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53827 }
53828 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53829 {
53830 PyThreadState* __tstate = wxPyBeginAllowThreads();
53831 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
53832 wxPyEndAllowThreads(__tstate);
53833 if (PyErr_Occurred()) SWIG_fail;
53834 }
53835 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53836 return resultobj;
53837 fail:
53838 return NULL;
53839 }
53840
53841
53842 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53843 PyObject *resultobj = 0;
53844 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53845 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
53846 void *argp1 = 0 ;
53847 int res1 = 0 ;
53848 void *argp2 = 0 ;
53849 int res2 = 0 ;
53850 PyObject * obj0 = 0 ;
53851 PyObject * obj1 = 0 ;
53852 char * kwnames[] = {
53853 (char *) "self",(char *) "sizer", NULL
53854 };
53855
53856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53858 if (!SWIG_IsOK(res1)) {
53859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53860 }
53861 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53862 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53863 if (!SWIG_IsOK(res2)) {
53864 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
53865 }
53866 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
53867 {
53868 PyThreadState* __tstate = wxPyBeginAllowThreads();
53869 (arg1)->SetGBSizer(arg2);
53870 wxPyEndAllowThreads(__tstate);
53871 if (PyErr_Occurred()) SWIG_fail;
53872 }
53873 resultobj = SWIG_Py_Void();
53874 return resultobj;
53875 fail:
53876 return NULL;
53877 }
53878
53879
53880 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53881 PyObject *obj;
53882 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53883 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
53884 return SWIG_Py_Void();
53885 }
53886
53887 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53888 return SWIG_Python_InitShadowInstance(args);
53889 }
53890
53891 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53892 PyObject *resultobj = 0;
53893 int arg1 = (int) 0 ;
53894 int arg2 = (int) 0 ;
53895 wxGridBagSizer *result = 0 ;
53896 int val1 ;
53897 int ecode1 = 0 ;
53898 int val2 ;
53899 int ecode2 = 0 ;
53900 PyObject * obj0 = 0 ;
53901 PyObject * obj1 = 0 ;
53902 char * kwnames[] = {
53903 (char *) "vgap",(char *) "hgap", NULL
53904 };
53905
53906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53907 if (obj0) {
53908 ecode1 = SWIG_AsVal_int(obj0, &val1);
53909 if (!SWIG_IsOK(ecode1)) {
53910 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
53911 }
53912 arg1 = static_cast< int >(val1);
53913 }
53914 if (obj1) {
53915 ecode2 = SWIG_AsVal_int(obj1, &val2);
53916 if (!SWIG_IsOK(ecode2)) {
53917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
53918 }
53919 arg2 = static_cast< int >(val2);
53920 }
53921 {
53922 PyThreadState* __tstate = wxPyBeginAllowThreads();
53923 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
53924 wxPyEndAllowThreads(__tstate);
53925 if (PyErr_Occurred()) SWIG_fail;
53926 }
53927 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
53928 return resultobj;
53929 fail:
53930 return NULL;
53931 }
53932
53933
53934 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53935 PyObject *resultobj = 0;
53936 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
53937 PyObject *arg2 = (PyObject *) 0 ;
53938 wxGBPosition *arg3 = 0 ;
53939 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
53940 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
53941 int arg5 = (int) 0 ;
53942 int arg6 = (int) 0 ;
53943 PyObject *arg7 = (PyObject *) NULL ;
53944 wxGBSizerItem *result = 0 ;
53945 void *argp1 = 0 ;
53946 int res1 = 0 ;
53947 wxGBPosition temp3 ;
53948 wxGBSpan temp4 ;
53949 int val5 ;
53950 int ecode5 = 0 ;
53951 int val6 ;
53952 int ecode6 = 0 ;
53953 PyObject * obj0 = 0 ;
53954 PyObject * obj1 = 0 ;
53955 PyObject * obj2 = 0 ;
53956 PyObject * obj3 = 0 ;
53957 PyObject * obj4 = 0 ;
53958 PyObject * obj5 = 0 ;
53959 PyObject * obj6 = 0 ;
53960 char * kwnames[] = {
53961 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53962 };
53963
53964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
53965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53966 if (!SWIG_IsOK(res1)) {
53967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
53968 }
53969 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
53970 arg2 = obj1;
53971 {
53972 arg3 = &temp3;
53973 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
53974 }
53975 if (obj3) {
53976 {
53977 arg4 = &temp4;
53978 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
53979 }
53980 }
53981 if (obj4) {
53982 ecode5 = SWIG_AsVal_int(obj4, &val5);
53983 if (!SWIG_IsOK(ecode5)) {
53984 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
53985 }
53986 arg5 = static_cast< int >(val5);
53987 }
53988 if (obj5) {
53989 ecode6 = SWIG_AsVal_int(obj5, &val6);
53990 if (!SWIG_IsOK(ecode6)) {
53991 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
53992 }
53993 arg6 = static_cast< int >(val6);
53994 }
53995 if (obj6) {
53996 arg7 = obj6;
53997 }
53998 {
53999 PyThreadState* __tstate = wxPyBeginAllowThreads();
54000 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
54001 wxPyEndAllowThreads(__tstate);
54002 if (PyErr_Occurred()) SWIG_fail;
54003 }
54004 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54005 return resultobj;
54006 fail:
54007 return NULL;
54008 }
54009
54010
54011 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54012 PyObject *resultobj = 0;
54013 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54014 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
54015 wxGBSizerItem *result = 0 ;
54016 void *argp1 = 0 ;
54017 int res1 = 0 ;
54018 int res2 = 0 ;
54019 PyObject * obj0 = 0 ;
54020 PyObject * obj1 = 0 ;
54021 char * kwnames[] = {
54022 (char *) "self",(char *) "item", NULL
54023 };
54024
54025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
54026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54027 if (!SWIG_IsOK(res1)) {
54028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54029 }
54030 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54031 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
54032 if (!SWIG_IsOK(res2)) {
54033 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
54034 }
54035 {
54036 PyThreadState* __tstate = wxPyBeginAllowThreads();
54037 result = (wxGBSizerItem *)(arg1)->Add(arg2);
54038 wxPyEndAllowThreads(__tstate);
54039 if (PyErr_Occurred()) SWIG_fail;
54040 }
54041 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54042 return resultobj;
54043 fail:
54044 return NULL;
54045 }
54046
54047
54048 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54049 PyObject *resultobj = 0;
54050 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54051 int arg2 ;
54052 int arg3 ;
54053 wxSize result;
54054 void *argp1 = 0 ;
54055 int res1 = 0 ;
54056 int val2 ;
54057 int ecode2 = 0 ;
54058 int val3 ;
54059 int ecode3 = 0 ;
54060 PyObject * obj0 = 0 ;
54061 PyObject * obj1 = 0 ;
54062 PyObject * obj2 = 0 ;
54063 char * kwnames[] = {
54064 (char *) "self",(char *) "row",(char *) "col", NULL
54065 };
54066
54067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54069 if (!SWIG_IsOK(res1)) {
54070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
54071 }
54072 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54073 ecode2 = SWIG_AsVal_int(obj1, &val2);
54074 if (!SWIG_IsOK(ecode2)) {
54075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
54076 }
54077 arg2 = static_cast< int >(val2);
54078 ecode3 = SWIG_AsVal_int(obj2, &val3);
54079 if (!SWIG_IsOK(ecode3)) {
54080 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
54081 }
54082 arg3 = static_cast< int >(val3);
54083 {
54084 PyThreadState* __tstate = wxPyBeginAllowThreads();
54085 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
54086 wxPyEndAllowThreads(__tstate);
54087 if (PyErr_Occurred()) SWIG_fail;
54088 }
54089 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
54090 return resultobj;
54091 fail:
54092 return NULL;
54093 }
54094
54095
54096 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54097 PyObject *resultobj = 0;
54098 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54099 wxSize result;
54100 void *argp1 = 0 ;
54101 int res1 = 0 ;
54102 PyObject *swig_obj[1] ;
54103
54104 if (!args) SWIG_fail;
54105 swig_obj[0] = args;
54106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54107 if (!SWIG_IsOK(res1)) {
54108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
54109 }
54110 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54111 {
54112 PyThreadState* __tstate = wxPyBeginAllowThreads();
54113 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
54114 wxPyEndAllowThreads(__tstate);
54115 if (PyErr_Occurred()) SWIG_fail;
54116 }
54117 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
54118 return resultobj;
54119 fail:
54120 return NULL;
54121 }
54122
54123
54124 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54125 PyObject *resultobj = 0;
54126 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54127 wxSize *arg2 = 0 ;
54128 void *argp1 = 0 ;
54129 int res1 = 0 ;
54130 wxSize temp2 ;
54131 PyObject * obj0 = 0 ;
54132 PyObject * obj1 = 0 ;
54133 char * kwnames[] = {
54134 (char *) "self",(char *) "sz", NULL
54135 };
54136
54137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
54138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54139 if (!SWIG_IsOK(res1)) {
54140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54141 }
54142 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54143 {
54144 arg2 = &temp2;
54145 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
54146 }
54147 {
54148 PyThreadState* __tstate = wxPyBeginAllowThreads();
54149 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
54150 wxPyEndAllowThreads(__tstate);
54151 if (PyErr_Occurred()) SWIG_fail;
54152 }
54153 resultobj = SWIG_Py_Void();
54154 return resultobj;
54155 fail:
54156 return NULL;
54157 }
54158
54159
54160 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54161 PyObject *resultobj = 0;
54162 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54163 wxWindow *arg2 = (wxWindow *) 0 ;
54164 wxGBPosition result;
54165 void *argp1 = 0 ;
54166 int res1 = 0 ;
54167 void *argp2 = 0 ;
54168 int res2 = 0 ;
54169
54170 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54172 if (!SWIG_IsOK(res1)) {
54173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54174 }
54175 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54176 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54177 if (!SWIG_IsOK(res2)) {
54178 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54179 }
54180 arg2 = reinterpret_cast< wxWindow * >(argp2);
54181 {
54182 PyThreadState* __tstate = wxPyBeginAllowThreads();
54183 result = (arg1)->GetItemPosition(arg2);
54184 wxPyEndAllowThreads(__tstate);
54185 if (PyErr_Occurred()) SWIG_fail;
54186 }
54187 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54188 return resultobj;
54189 fail:
54190 return NULL;
54191 }
54192
54193
54194 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54195 PyObject *resultobj = 0;
54196 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54197 wxSizer *arg2 = (wxSizer *) 0 ;
54198 wxGBPosition result;
54199 void *argp1 = 0 ;
54200 int res1 = 0 ;
54201 void *argp2 = 0 ;
54202 int res2 = 0 ;
54203
54204 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54206 if (!SWIG_IsOK(res1)) {
54207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54208 }
54209 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54210 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54211 if (!SWIG_IsOK(res2)) {
54212 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54213 }
54214 arg2 = reinterpret_cast< wxSizer * >(argp2);
54215 {
54216 PyThreadState* __tstate = wxPyBeginAllowThreads();
54217 result = (arg1)->GetItemPosition(arg2);
54218 wxPyEndAllowThreads(__tstate);
54219 if (PyErr_Occurred()) SWIG_fail;
54220 }
54221 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54222 return resultobj;
54223 fail:
54224 return NULL;
54225 }
54226
54227
54228 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54229 PyObject *resultobj = 0;
54230 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54231 size_t arg2 ;
54232 wxGBPosition result;
54233 void *argp1 = 0 ;
54234 int res1 = 0 ;
54235 size_t val2 ;
54236 int ecode2 = 0 ;
54237
54238 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54240 if (!SWIG_IsOK(res1)) {
54241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54242 }
54243 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54244 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54245 if (!SWIG_IsOK(ecode2)) {
54246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54247 }
54248 arg2 = static_cast< size_t >(val2);
54249 {
54250 PyThreadState* __tstate = wxPyBeginAllowThreads();
54251 result = (arg1)->GetItemPosition(arg2);
54252 wxPyEndAllowThreads(__tstate);
54253 if (PyErr_Occurred()) SWIG_fail;
54254 }
54255 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54256 return resultobj;
54257 fail:
54258 return NULL;
54259 }
54260
54261
54262 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
54263 int argc;
54264 PyObject *argv[3];
54265
54266 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
54267 --argc;
54268 if (argc == 2) {
54269 int _v = 0;
54270 {
54271 void *vptr = 0;
54272 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54273 _v = SWIG_CheckState(res);
54274 }
54275 if (!_v) goto check_1;
54276 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
54277 }
54278 check_1:
54279
54280 if (argc == 2) {
54281 int _v = 0;
54282 {
54283 void *vptr = 0;
54284 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54285 _v = SWIG_CheckState(res);
54286 }
54287 if (!_v) goto check_2;
54288 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
54289 }
54290 check_2:
54291
54292 if (argc == 2) {
54293 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
54294 }
54295
54296 fail:
54297 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
54298 return NULL;
54299 }
54300
54301
54302 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54303 PyObject *resultobj = 0;
54304 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54305 wxWindow *arg2 = (wxWindow *) 0 ;
54306 wxGBPosition *arg3 = 0 ;
54307 bool result;
54308 void *argp1 = 0 ;
54309 int res1 = 0 ;
54310 void *argp2 = 0 ;
54311 int res2 = 0 ;
54312 wxGBPosition temp3 ;
54313
54314 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54316 if (!SWIG_IsOK(res1)) {
54317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54318 }
54319 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54320 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54321 if (!SWIG_IsOK(res2)) {
54322 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54323 }
54324 arg2 = reinterpret_cast< wxWindow * >(argp2);
54325 {
54326 arg3 = &temp3;
54327 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54328 }
54329 {
54330 PyThreadState* __tstate = wxPyBeginAllowThreads();
54331 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54332 wxPyEndAllowThreads(__tstate);
54333 if (PyErr_Occurred()) SWIG_fail;
54334 }
54335 {
54336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54337 }
54338 return resultobj;
54339 fail:
54340 return NULL;
54341 }
54342
54343
54344 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54345 PyObject *resultobj = 0;
54346 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54347 wxSizer *arg2 = (wxSizer *) 0 ;
54348 wxGBPosition *arg3 = 0 ;
54349 bool result;
54350 void *argp1 = 0 ;
54351 int res1 = 0 ;
54352 void *argp2 = 0 ;
54353 int res2 = 0 ;
54354 wxGBPosition temp3 ;
54355
54356 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54358 if (!SWIG_IsOK(res1)) {
54359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54360 }
54361 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54362 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54363 if (!SWIG_IsOK(res2)) {
54364 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54365 }
54366 arg2 = reinterpret_cast< wxSizer * >(argp2);
54367 {
54368 arg3 = &temp3;
54369 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54370 }
54371 {
54372 PyThreadState* __tstate = wxPyBeginAllowThreads();
54373 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54374 wxPyEndAllowThreads(__tstate);
54375 if (PyErr_Occurred()) SWIG_fail;
54376 }
54377 {
54378 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54379 }
54380 return resultobj;
54381 fail:
54382 return NULL;
54383 }
54384
54385
54386 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54387 PyObject *resultobj = 0;
54388 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54389 size_t arg2 ;
54390 wxGBPosition *arg3 = 0 ;
54391 bool result;
54392 void *argp1 = 0 ;
54393 int res1 = 0 ;
54394 size_t val2 ;
54395 int ecode2 = 0 ;
54396 wxGBPosition temp3 ;
54397
54398 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54400 if (!SWIG_IsOK(res1)) {
54401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54402 }
54403 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54404 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54405 if (!SWIG_IsOK(ecode2)) {
54406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54407 }
54408 arg2 = static_cast< size_t >(val2);
54409 {
54410 arg3 = &temp3;
54411 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54412 }
54413 {
54414 PyThreadState* __tstate = wxPyBeginAllowThreads();
54415 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54416 wxPyEndAllowThreads(__tstate);
54417 if (PyErr_Occurred()) SWIG_fail;
54418 }
54419 {
54420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54421 }
54422 return resultobj;
54423 fail:
54424 return NULL;
54425 }
54426
54427
54428 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
54429 int argc;
54430 PyObject *argv[4];
54431
54432 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
54433 --argc;
54434 if (argc == 3) {
54435 int _v = 0;
54436 {
54437 void *vptr = 0;
54438 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54439 _v = SWIG_CheckState(res);
54440 }
54441 if (!_v) goto check_1;
54442 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
54443 }
54444 check_1:
54445
54446 if (argc == 3) {
54447 int _v = 0;
54448 {
54449 void *vptr = 0;
54450 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54451 _v = SWIG_CheckState(res);
54452 }
54453 if (!_v) goto check_2;
54454 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
54455 }
54456 check_2:
54457
54458 if (argc == 3) {
54459 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
54460 }
54461
54462 fail:
54463 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
54464 return NULL;
54465 }
54466
54467
54468 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54469 PyObject *resultobj = 0;
54470 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54471 wxWindow *arg2 = (wxWindow *) 0 ;
54472 wxGBSpan result;
54473 void *argp1 = 0 ;
54474 int res1 = 0 ;
54475 void *argp2 = 0 ;
54476 int res2 = 0 ;
54477
54478 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54480 if (!SWIG_IsOK(res1)) {
54481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54482 }
54483 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54484 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54485 if (!SWIG_IsOK(res2)) {
54486 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54487 }
54488 arg2 = reinterpret_cast< wxWindow * >(argp2);
54489 {
54490 PyThreadState* __tstate = wxPyBeginAllowThreads();
54491 result = (arg1)->GetItemSpan(arg2);
54492 wxPyEndAllowThreads(__tstate);
54493 if (PyErr_Occurred()) SWIG_fail;
54494 }
54495 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54496 return resultobj;
54497 fail:
54498 return NULL;
54499 }
54500
54501
54502 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54503 PyObject *resultobj = 0;
54504 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54505 wxSizer *arg2 = (wxSizer *) 0 ;
54506 wxGBSpan result;
54507 void *argp1 = 0 ;
54508 int res1 = 0 ;
54509 void *argp2 = 0 ;
54510 int res2 = 0 ;
54511
54512 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54514 if (!SWIG_IsOK(res1)) {
54515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54516 }
54517 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54518 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54519 if (!SWIG_IsOK(res2)) {
54520 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54521 }
54522 arg2 = reinterpret_cast< wxSizer * >(argp2);
54523 {
54524 PyThreadState* __tstate = wxPyBeginAllowThreads();
54525 result = (arg1)->GetItemSpan(arg2);
54526 wxPyEndAllowThreads(__tstate);
54527 if (PyErr_Occurred()) SWIG_fail;
54528 }
54529 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54530 return resultobj;
54531 fail:
54532 return NULL;
54533 }
54534
54535
54536 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54537 PyObject *resultobj = 0;
54538 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54539 size_t arg2 ;
54540 wxGBSpan result;
54541 void *argp1 = 0 ;
54542 int res1 = 0 ;
54543 size_t val2 ;
54544 int ecode2 = 0 ;
54545
54546 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54548 if (!SWIG_IsOK(res1)) {
54549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54550 }
54551 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54552 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54553 if (!SWIG_IsOK(ecode2)) {
54554 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54555 }
54556 arg2 = static_cast< size_t >(val2);
54557 {
54558 PyThreadState* __tstate = wxPyBeginAllowThreads();
54559 result = (arg1)->GetItemSpan(arg2);
54560 wxPyEndAllowThreads(__tstate);
54561 if (PyErr_Occurred()) SWIG_fail;
54562 }
54563 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54564 return resultobj;
54565 fail:
54566 return NULL;
54567 }
54568
54569
54570 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
54571 int argc;
54572 PyObject *argv[3];
54573
54574 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
54575 --argc;
54576 if (argc == 2) {
54577 int _v = 0;
54578 {
54579 void *vptr = 0;
54580 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54581 _v = SWIG_CheckState(res);
54582 }
54583 if (!_v) goto check_1;
54584 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
54585 }
54586 check_1:
54587
54588 if (argc == 2) {
54589 int _v = 0;
54590 {
54591 void *vptr = 0;
54592 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54593 _v = SWIG_CheckState(res);
54594 }
54595 if (!_v) goto check_2;
54596 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
54597 }
54598 check_2:
54599
54600 if (argc == 2) {
54601 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
54602 }
54603
54604 fail:
54605 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
54606 return NULL;
54607 }
54608
54609
54610 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54611 PyObject *resultobj = 0;
54612 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54613 wxWindow *arg2 = (wxWindow *) 0 ;
54614 wxGBSpan *arg3 = 0 ;
54615 bool result;
54616 void *argp1 = 0 ;
54617 int res1 = 0 ;
54618 void *argp2 = 0 ;
54619 int res2 = 0 ;
54620 wxGBSpan temp3 ;
54621
54622 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54624 if (!SWIG_IsOK(res1)) {
54625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54626 }
54627 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54628 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54629 if (!SWIG_IsOK(res2)) {
54630 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54631 }
54632 arg2 = reinterpret_cast< wxWindow * >(argp2);
54633 {
54634 arg3 = &temp3;
54635 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54636 }
54637 {
54638 PyThreadState* __tstate = wxPyBeginAllowThreads();
54639 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54640 wxPyEndAllowThreads(__tstate);
54641 if (PyErr_Occurred()) SWIG_fail;
54642 }
54643 {
54644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54645 }
54646 return resultobj;
54647 fail:
54648 return NULL;
54649 }
54650
54651
54652 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54653 PyObject *resultobj = 0;
54654 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54655 wxSizer *arg2 = (wxSizer *) 0 ;
54656 wxGBSpan *arg3 = 0 ;
54657 bool result;
54658 void *argp1 = 0 ;
54659 int res1 = 0 ;
54660 void *argp2 = 0 ;
54661 int res2 = 0 ;
54662 wxGBSpan temp3 ;
54663
54664 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54666 if (!SWIG_IsOK(res1)) {
54667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54668 }
54669 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54670 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54671 if (!SWIG_IsOK(res2)) {
54672 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54673 }
54674 arg2 = reinterpret_cast< wxSizer * >(argp2);
54675 {
54676 arg3 = &temp3;
54677 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54678 }
54679 {
54680 PyThreadState* __tstate = wxPyBeginAllowThreads();
54681 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54682 wxPyEndAllowThreads(__tstate);
54683 if (PyErr_Occurred()) SWIG_fail;
54684 }
54685 {
54686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54687 }
54688 return resultobj;
54689 fail:
54690 return NULL;
54691 }
54692
54693
54694 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54695 PyObject *resultobj = 0;
54696 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54697 size_t arg2 ;
54698 wxGBSpan *arg3 = 0 ;
54699 bool result;
54700 void *argp1 = 0 ;
54701 int res1 = 0 ;
54702 size_t val2 ;
54703 int ecode2 = 0 ;
54704 wxGBSpan temp3 ;
54705
54706 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54708 if (!SWIG_IsOK(res1)) {
54709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54710 }
54711 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54712 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54713 if (!SWIG_IsOK(ecode2)) {
54714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54715 }
54716 arg2 = static_cast< size_t >(val2);
54717 {
54718 arg3 = &temp3;
54719 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54720 }
54721 {
54722 PyThreadState* __tstate = wxPyBeginAllowThreads();
54723 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54724 wxPyEndAllowThreads(__tstate);
54725 if (PyErr_Occurred()) SWIG_fail;
54726 }
54727 {
54728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54729 }
54730 return resultobj;
54731 fail:
54732 return NULL;
54733 }
54734
54735
54736 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
54737 int argc;
54738 PyObject *argv[4];
54739
54740 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
54741 --argc;
54742 if (argc == 3) {
54743 int _v = 0;
54744 {
54745 void *vptr = 0;
54746 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54747 _v = SWIG_CheckState(res);
54748 }
54749 if (!_v) goto check_1;
54750 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
54751 }
54752 check_1:
54753
54754 if (argc == 3) {
54755 int _v = 0;
54756 {
54757 void *vptr = 0;
54758 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54759 _v = SWIG_CheckState(res);
54760 }
54761 if (!_v) goto check_2;
54762 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
54763 }
54764 check_2:
54765
54766 if (argc == 3) {
54767 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
54768 }
54769
54770 fail:
54771 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
54772 return NULL;
54773 }
54774
54775
54776 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54777 PyObject *resultobj = 0;
54778 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54779 wxWindow *arg2 = (wxWindow *) 0 ;
54780 wxGBSizerItem *result = 0 ;
54781 void *argp1 = 0 ;
54782 int res1 = 0 ;
54783 void *argp2 = 0 ;
54784 int res2 = 0 ;
54785
54786 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54788 if (!SWIG_IsOK(res1)) {
54789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54790 }
54791 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54792 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54793 if (!SWIG_IsOK(res2)) {
54794 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
54795 }
54796 arg2 = reinterpret_cast< wxWindow * >(argp2);
54797 {
54798 PyThreadState* __tstate = wxPyBeginAllowThreads();
54799 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54800 wxPyEndAllowThreads(__tstate);
54801 if (PyErr_Occurred()) SWIG_fail;
54802 }
54803 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54804 return resultobj;
54805 fail:
54806 return NULL;
54807 }
54808
54809
54810 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54811 PyObject *resultobj = 0;
54812 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54813 wxSizer *arg2 = (wxSizer *) 0 ;
54814 wxGBSizerItem *result = 0 ;
54815 void *argp1 = 0 ;
54816 int res1 = 0 ;
54817 void *argp2 = 0 ;
54818 int res2 = 0 ;
54819
54820 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54822 if (!SWIG_IsOK(res1)) {
54823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54824 }
54825 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54826 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54827 if (!SWIG_IsOK(res2)) {
54828 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
54829 }
54830 arg2 = reinterpret_cast< wxSizer * >(argp2);
54831 {
54832 PyThreadState* __tstate = wxPyBeginAllowThreads();
54833 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54834 wxPyEndAllowThreads(__tstate);
54835 if (PyErr_Occurred()) SWIG_fail;
54836 }
54837 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54838 return resultobj;
54839 fail:
54840 return NULL;
54841 }
54842
54843
54844 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
54845 int argc;
54846 PyObject *argv[3];
54847
54848 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
54849 --argc;
54850 if (argc == 2) {
54851 int _v = 0;
54852 {
54853 void *vptr = 0;
54854 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54855 _v = SWIG_CheckState(res);
54856 }
54857 if (!_v) goto check_1;
54858 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
54859 }
54860 check_1:
54861
54862 if (argc == 2) {
54863 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
54864 }
54865
54866 fail:
54867 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
54868 return NULL;
54869 }
54870
54871
54872 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54873 PyObject *resultobj = 0;
54874 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54875 wxGBPosition *arg2 = 0 ;
54876 wxGBSizerItem *result = 0 ;
54877 void *argp1 = 0 ;
54878 int res1 = 0 ;
54879 wxGBPosition temp2 ;
54880 PyObject * obj0 = 0 ;
54881 PyObject * obj1 = 0 ;
54882 char * kwnames[] = {
54883 (char *) "self",(char *) "pos", NULL
54884 };
54885
54886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
54887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54888 if (!SWIG_IsOK(res1)) {
54889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54890 }
54891 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54892 {
54893 arg2 = &temp2;
54894 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54895 }
54896 {
54897 PyThreadState* __tstate = wxPyBeginAllowThreads();
54898 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
54899 wxPyEndAllowThreads(__tstate);
54900 if (PyErr_Occurred()) SWIG_fail;
54901 }
54902 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54903 return resultobj;
54904 fail:
54905 return NULL;
54906 }
54907
54908
54909 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54910 PyObject *resultobj = 0;
54911 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54912 wxPoint *arg2 = 0 ;
54913 wxGBSizerItem *result = 0 ;
54914 void *argp1 = 0 ;
54915 int res1 = 0 ;
54916 wxPoint temp2 ;
54917 PyObject * obj0 = 0 ;
54918 PyObject * obj1 = 0 ;
54919 char * kwnames[] = {
54920 (char *) "self",(char *) "pt", NULL
54921 };
54922
54923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
54924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54925 if (!SWIG_IsOK(res1)) {
54926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54927 }
54928 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54929 {
54930 arg2 = &temp2;
54931 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
54932 }
54933 {
54934 PyThreadState* __tstate = wxPyBeginAllowThreads();
54935 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
54936 wxPyEndAllowThreads(__tstate);
54937 if (PyErr_Occurred()) SWIG_fail;
54938 }
54939 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54940 return resultobj;
54941 fail:
54942 return NULL;
54943 }
54944
54945
54946 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54947 PyObject *resultobj = 0;
54948 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54949 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
54950 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
54951 bool result;
54952 void *argp1 = 0 ;
54953 int res1 = 0 ;
54954 void *argp2 = 0 ;
54955 int res2 = 0 ;
54956 void *argp3 = 0 ;
54957 int res3 = 0 ;
54958 PyObject * obj0 = 0 ;
54959 PyObject * obj1 = 0 ;
54960 PyObject * obj2 = 0 ;
54961 char * kwnames[] = {
54962 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
54963 };
54964
54965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54967 if (!SWIG_IsOK(res1)) {
54968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54969 }
54970 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54971 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54972 if (!SWIG_IsOK(res2)) {
54973 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
54974 }
54975 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
54976 if (obj2) {
54977 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54978 if (!SWIG_IsOK(res3)) {
54979 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
54980 }
54981 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
54982 }
54983 {
54984 PyThreadState* __tstate = wxPyBeginAllowThreads();
54985 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
54986 wxPyEndAllowThreads(__tstate);
54987 if (PyErr_Occurred()) SWIG_fail;
54988 }
54989 {
54990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54991 }
54992 return resultobj;
54993 fail:
54994 return NULL;
54995 }
54996
54997
54998 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54999 PyObject *resultobj = 0;
55000 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55001 wxGBPosition *arg2 = 0 ;
55002 wxGBSpan *arg3 = 0 ;
55003 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
55004 bool result;
55005 void *argp1 = 0 ;
55006 int res1 = 0 ;
55007 wxGBPosition temp2 ;
55008 wxGBSpan temp3 ;
55009 void *argp4 = 0 ;
55010 int res4 = 0 ;
55011 PyObject * obj0 = 0 ;
55012 PyObject * obj1 = 0 ;
55013 PyObject * obj2 = 0 ;
55014 PyObject * obj3 = 0 ;
55015 char * kwnames[] = {
55016 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
55017 };
55018
55019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55021 if (!SWIG_IsOK(res1)) {
55022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55023 }
55024 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55025 {
55026 arg2 = &temp2;
55027 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55028 }
55029 {
55030 arg3 = &temp3;
55031 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
55032 }
55033 if (obj3) {
55034 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55035 if (!SWIG_IsOK(res4)) {
55036 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
55037 }
55038 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
55039 }
55040 {
55041 PyThreadState* __tstate = wxPyBeginAllowThreads();
55042 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
55043 wxPyEndAllowThreads(__tstate);
55044 if (PyErr_Occurred()) SWIG_fail;
55045 }
55046 {
55047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55048 }
55049 return resultobj;
55050 fail:
55051 return NULL;
55052 }
55053
55054
55055 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55056 PyObject *obj;
55057 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
55058 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
55059 return SWIG_Py_Void();
55060 }
55061
55062 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55063 return SWIG_Python_InitShadowInstance(args);
55064 }
55065
55066 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55067 PyObject *resultobj = 0;
55068 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55069 wxRelationship arg2 ;
55070 wxWindow *arg3 = (wxWindow *) 0 ;
55071 wxEdge arg4 ;
55072 int arg5 = (int) 0 ;
55073 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
55074 void *argp1 = 0 ;
55075 int res1 = 0 ;
55076 int val2 ;
55077 int ecode2 = 0 ;
55078 void *argp3 = 0 ;
55079 int res3 = 0 ;
55080 int val4 ;
55081 int ecode4 = 0 ;
55082 int val5 ;
55083 int ecode5 = 0 ;
55084 int val6 ;
55085 int ecode6 = 0 ;
55086 PyObject * obj0 = 0 ;
55087 PyObject * obj1 = 0 ;
55088 PyObject * obj2 = 0 ;
55089 PyObject * obj3 = 0 ;
55090 PyObject * obj4 = 0 ;
55091 PyObject * obj5 = 0 ;
55092 char * kwnames[] = {
55093 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
55094 };
55095
55096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
55097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55098 if (!SWIG_IsOK(res1)) {
55099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55100 }
55101 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55102 ecode2 = SWIG_AsVal_int(obj1, &val2);
55103 if (!SWIG_IsOK(ecode2)) {
55104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
55105 }
55106 arg2 = static_cast< wxRelationship >(val2);
55107 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
55108 if (!SWIG_IsOK(res3)) {
55109 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
55110 }
55111 arg3 = reinterpret_cast< wxWindow * >(argp3);
55112 ecode4 = SWIG_AsVal_int(obj3, &val4);
55113 if (!SWIG_IsOK(ecode4)) {
55114 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
55115 }
55116 arg4 = static_cast< wxEdge >(val4);
55117 if (obj4) {
55118 ecode5 = SWIG_AsVal_int(obj4, &val5);
55119 if (!SWIG_IsOK(ecode5)) {
55120 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
55121 }
55122 arg5 = static_cast< int >(val5);
55123 }
55124 if (obj5) {
55125 ecode6 = SWIG_AsVal_int(obj5, &val6);
55126 if (!SWIG_IsOK(ecode6)) {
55127 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
55128 }
55129 arg6 = static_cast< int >(val6);
55130 }
55131 {
55132 PyThreadState* __tstate = wxPyBeginAllowThreads();
55133 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
55134 wxPyEndAllowThreads(__tstate);
55135 if (PyErr_Occurred()) SWIG_fail;
55136 }
55137 resultobj = SWIG_Py_Void();
55138 return resultobj;
55139 fail:
55140 return NULL;
55141 }
55142
55143
55144 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55145 PyObject *resultobj = 0;
55146 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55147 wxWindow *arg2 = (wxWindow *) 0 ;
55148 int arg3 = (int) 0 ;
55149 void *argp1 = 0 ;
55150 int res1 = 0 ;
55151 void *argp2 = 0 ;
55152 int res2 = 0 ;
55153 int val3 ;
55154 int ecode3 = 0 ;
55155 PyObject * obj0 = 0 ;
55156 PyObject * obj1 = 0 ;
55157 PyObject * obj2 = 0 ;
55158 char * kwnames[] = {
55159 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55160 };
55161
55162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55164 if (!SWIG_IsOK(res1)) {
55165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55166 }
55167 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55168 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55169 if (!SWIG_IsOK(res2)) {
55170 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55171 }
55172 arg2 = reinterpret_cast< wxWindow * >(argp2);
55173 if (obj2) {
55174 ecode3 = SWIG_AsVal_int(obj2, &val3);
55175 if (!SWIG_IsOK(ecode3)) {
55176 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
55177 }
55178 arg3 = static_cast< int >(val3);
55179 }
55180 {
55181 PyThreadState* __tstate = wxPyBeginAllowThreads();
55182 (arg1)->LeftOf(arg2,arg3);
55183 wxPyEndAllowThreads(__tstate);
55184 if (PyErr_Occurred()) SWIG_fail;
55185 }
55186 resultobj = SWIG_Py_Void();
55187 return resultobj;
55188 fail:
55189 return NULL;
55190 }
55191
55192
55193 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55194 PyObject *resultobj = 0;
55195 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55196 wxWindow *arg2 = (wxWindow *) 0 ;
55197 int arg3 = (int) 0 ;
55198 void *argp1 = 0 ;
55199 int res1 = 0 ;
55200 void *argp2 = 0 ;
55201 int res2 = 0 ;
55202 int val3 ;
55203 int ecode3 = 0 ;
55204 PyObject * obj0 = 0 ;
55205 PyObject * obj1 = 0 ;
55206 PyObject * obj2 = 0 ;
55207 char * kwnames[] = {
55208 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55209 };
55210
55211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55213 if (!SWIG_IsOK(res1)) {
55214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55215 }
55216 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55217 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55218 if (!SWIG_IsOK(res2)) {
55219 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55220 }
55221 arg2 = reinterpret_cast< wxWindow * >(argp2);
55222 if (obj2) {
55223 ecode3 = SWIG_AsVal_int(obj2, &val3);
55224 if (!SWIG_IsOK(ecode3)) {
55225 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
55226 }
55227 arg3 = static_cast< int >(val3);
55228 }
55229 {
55230 PyThreadState* __tstate = wxPyBeginAllowThreads();
55231 (arg1)->RightOf(arg2,arg3);
55232 wxPyEndAllowThreads(__tstate);
55233 if (PyErr_Occurred()) SWIG_fail;
55234 }
55235 resultobj = SWIG_Py_Void();
55236 return resultobj;
55237 fail:
55238 return NULL;
55239 }
55240
55241
55242 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55243 PyObject *resultobj = 0;
55244 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55245 wxWindow *arg2 = (wxWindow *) 0 ;
55246 int arg3 = (int) 0 ;
55247 void *argp1 = 0 ;
55248 int res1 = 0 ;
55249 void *argp2 = 0 ;
55250 int res2 = 0 ;
55251 int val3 ;
55252 int ecode3 = 0 ;
55253 PyObject * obj0 = 0 ;
55254 PyObject * obj1 = 0 ;
55255 PyObject * obj2 = 0 ;
55256 char * kwnames[] = {
55257 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55258 };
55259
55260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55262 if (!SWIG_IsOK(res1)) {
55263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55264 }
55265 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55266 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55267 if (!SWIG_IsOK(res2)) {
55268 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
55269 }
55270 arg2 = reinterpret_cast< wxWindow * >(argp2);
55271 if (obj2) {
55272 ecode3 = SWIG_AsVal_int(obj2, &val3);
55273 if (!SWIG_IsOK(ecode3)) {
55274 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
55275 }
55276 arg3 = static_cast< int >(val3);
55277 }
55278 {
55279 PyThreadState* __tstate = wxPyBeginAllowThreads();
55280 (arg1)->Above(arg2,arg3);
55281 wxPyEndAllowThreads(__tstate);
55282 if (PyErr_Occurred()) SWIG_fail;
55283 }
55284 resultobj = SWIG_Py_Void();
55285 return resultobj;
55286 fail:
55287 return NULL;
55288 }
55289
55290
55291 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55292 PyObject *resultobj = 0;
55293 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55294 wxWindow *arg2 = (wxWindow *) 0 ;
55295 int arg3 = (int) 0 ;
55296 void *argp1 = 0 ;
55297 int res1 = 0 ;
55298 void *argp2 = 0 ;
55299 int res2 = 0 ;
55300 int val3 ;
55301 int ecode3 = 0 ;
55302 PyObject * obj0 = 0 ;
55303 PyObject * obj1 = 0 ;
55304 PyObject * obj2 = 0 ;
55305 char * kwnames[] = {
55306 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55307 };
55308
55309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55311 if (!SWIG_IsOK(res1)) {
55312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55313 }
55314 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55315 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55316 if (!SWIG_IsOK(res2)) {
55317 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
55318 }
55319 arg2 = reinterpret_cast< wxWindow * >(argp2);
55320 if (obj2) {
55321 ecode3 = SWIG_AsVal_int(obj2, &val3);
55322 if (!SWIG_IsOK(ecode3)) {
55323 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
55324 }
55325 arg3 = static_cast< int >(val3);
55326 }
55327 {
55328 PyThreadState* __tstate = wxPyBeginAllowThreads();
55329 (arg1)->Below(arg2,arg3);
55330 wxPyEndAllowThreads(__tstate);
55331 if (PyErr_Occurred()) SWIG_fail;
55332 }
55333 resultobj = SWIG_Py_Void();
55334 return resultobj;
55335 fail:
55336 return NULL;
55337 }
55338
55339
55340 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55341 PyObject *resultobj = 0;
55342 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55343 wxWindow *arg2 = (wxWindow *) 0 ;
55344 wxEdge arg3 ;
55345 int arg4 = (int) 0 ;
55346 void *argp1 = 0 ;
55347 int res1 = 0 ;
55348 void *argp2 = 0 ;
55349 int res2 = 0 ;
55350 int val3 ;
55351 int ecode3 = 0 ;
55352 int val4 ;
55353 int ecode4 = 0 ;
55354 PyObject * obj0 = 0 ;
55355 PyObject * obj1 = 0 ;
55356 PyObject * obj2 = 0 ;
55357 PyObject * obj3 = 0 ;
55358 char * kwnames[] = {
55359 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
55360 };
55361
55362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55364 if (!SWIG_IsOK(res1)) {
55365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55366 }
55367 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55368 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55369 if (!SWIG_IsOK(res2)) {
55370 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
55371 }
55372 arg2 = reinterpret_cast< wxWindow * >(argp2);
55373 ecode3 = SWIG_AsVal_int(obj2, &val3);
55374 if (!SWIG_IsOK(ecode3)) {
55375 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
55376 }
55377 arg3 = static_cast< wxEdge >(val3);
55378 if (obj3) {
55379 ecode4 = SWIG_AsVal_int(obj3, &val4);
55380 if (!SWIG_IsOK(ecode4)) {
55381 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
55382 }
55383 arg4 = static_cast< int >(val4);
55384 }
55385 {
55386 PyThreadState* __tstate = wxPyBeginAllowThreads();
55387 (arg1)->SameAs(arg2,arg3,arg4);
55388 wxPyEndAllowThreads(__tstate);
55389 if (PyErr_Occurred()) SWIG_fail;
55390 }
55391 resultobj = SWIG_Py_Void();
55392 return resultobj;
55393 fail:
55394 return NULL;
55395 }
55396
55397
55398 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55399 PyObject *resultobj = 0;
55400 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55401 wxWindow *arg2 = (wxWindow *) 0 ;
55402 wxEdge arg3 ;
55403 int arg4 ;
55404 void *argp1 = 0 ;
55405 int res1 = 0 ;
55406 void *argp2 = 0 ;
55407 int res2 = 0 ;
55408 int val3 ;
55409 int ecode3 = 0 ;
55410 int val4 ;
55411 int ecode4 = 0 ;
55412 PyObject * obj0 = 0 ;
55413 PyObject * obj1 = 0 ;
55414 PyObject * obj2 = 0 ;
55415 PyObject * obj3 = 0 ;
55416 char * kwnames[] = {
55417 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
55418 };
55419
55420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55422 if (!SWIG_IsOK(res1)) {
55423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55424 }
55425 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55426 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55427 if (!SWIG_IsOK(res2)) {
55428 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55429 }
55430 arg2 = reinterpret_cast< wxWindow * >(argp2);
55431 ecode3 = SWIG_AsVal_int(obj2, &val3);
55432 if (!SWIG_IsOK(ecode3)) {
55433 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
55434 }
55435 arg3 = static_cast< wxEdge >(val3);
55436 ecode4 = SWIG_AsVal_int(obj3, &val4);
55437 if (!SWIG_IsOK(ecode4)) {
55438 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
55439 }
55440 arg4 = static_cast< int >(val4);
55441 {
55442 PyThreadState* __tstate = wxPyBeginAllowThreads();
55443 (arg1)->PercentOf(arg2,arg3,arg4);
55444 wxPyEndAllowThreads(__tstate);
55445 if (PyErr_Occurred()) SWIG_fail;
55446 }
55447 resultobj = SWIG_Py_Void();
55448 return resultobj;
55449 fail:
55450 return NULL;
55451 }
55452
55453
55454 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55455 PyObject *resultobj = 0;
55456 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55457 int arg2 ;
55458 void *argp1 = 0 ;
55459 int res1 = 0 ;
55460 int val2 ;
55461 int ecode2 = 0 ;
55462 PyObject * obj0 = 0 ;
55463 PyObject * obj1 = 0 ;
55464 char * kwnames[] = {
55465 (char *) "self",(char *) "val", NULL
55466 };
55467
55468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
55469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55470 if (!SWIG_IsOK(res1)) {
55471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55472 }
55473 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55474 ecode2 = SWIG_AsVal_int(obj1, &val2);
55475 if (!SWIG_IsOK(ecode2)) {
55476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
55477 }
55478 arg2 = static_cast< int >(val2);
55479 {
55480 PyThreadState* __tstate = wxPyBeginAllowThreads();
55481 (arg1)->Absolute(arg2);
55482 wxPyEndAllowThreads(__tstate);
55483 if (PyErr_Occurred()) SWIG_fail;
55484 }
55485 resultobj = SWIG_Py_Void();
55486 return resultobj;
55487 fail:
55488 return NULL;
55489 }
55490
55491
55492 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55493 PyObject *resultobj = 0;
55494 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55495 void *argp1 = 0 ;
55496 int res1 = 0 ;
55497 PyObject *swig_obj[1] ;
55498
55499 if (!args) SWIG_fail;
55500 swig_obj[0] = args;
55501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55502 if (!SWIG_IsOK(res1)) {
55503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55504 }
55505 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55506 {
55507 PyThreadState* __tstate = wxPyBeginAllowThreads();
55508 (arg1)->Unconstrained();
55509 wxPyEndAllowThreads(__tstate);
55510 if (PyErr_Occurred()) SWIG_fail;
55511 }
55512 resultobj = SWIG_Py_Void();
55513 return resultobj;
55514 fail:
55515 return NULL;
55516 }
55517
55518
55519 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55520 PyObject *resultobj = 0;
55521 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55522 void *argp1 = 0 ;
55523 int res1 = 0 ;
55524 PyObject *swig_obj[1] ;
55525
55526 if (!args) SWIG_fail;
55527 swig_obj[0] = args;
55528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55529 if (!SWIG_IsOK(res1)) {
55530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55531 }
55532 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55533 {
55534 PyThreadState* __tstate = wxPyBeginAllowThreads();
55535 (arg1)->AsIs();
55536 wxPyEndAllowThreads(__tstate);
55537 if (PyErr_Occurred()) SWIG_fail;
55538 }
55539 resultobj = SWIG_Py_Void();
55540 return resultobj;
55541 fail:
55542 return NULL;
55543 }
55544
55545
55546 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55547 PyObject *resultobj = 0;
55548 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55549 wxWindow *result = 0 ;
55550 void *argp1 = 0 ;
55551 int res1 = 0 ;
55552 PyObject *swig_obj[1] ;
55553
55554 if (!args) SWIG_fail;
55555 swig_obj[0] = args;
55556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55557 if (!SWIG_IsOK(res1)) {
55558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55559 }
55560 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55561 {
55562 PyThreadState* __tstate = wxPyBeginAllowThreads();
55563 result = (wxWindow *)(arg1)->GetOtherWindow();
55564 wxPyEndAllowThreads(__tstate);
55565 if (PyErr_Occurred()) SWIG_fail;
55566 }
55567 {
55568 resultobj = wxPyMake_wxObject(result, 0);
55569 }
55570 return resultobj;
55571 fail:
55572 return NULL;
55573 }
55574
55575
55576 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55577 PyObject *resultobj = 0;
55578 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55579 wxEdge result;
55580 void *argp1 = 0 ;
55581 int res1 = 0 ;
55582 PyObject *swig_obj[1] ;
55583
55584 if (!args) SWIG_fail;
55585 swig_obj[0] = args;
55586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55587 if (!SWIG_IsOK(res1)) {
55588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55589 }
55590 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55591 {
55592 PyThreadState* __tstate = wxPyBeginAllowThreads();
55593 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
55594 wxPyEndAllowThreads(__tstate);
55595 if (PyErr_Occurred()) SWIG_fail;
55596 }
55597 resultobj = SWIG_From_int(static_cast< int >(result));
55598 return resultobj;
55599 fail:
55600 return NULL;
55601 }
55602
55603
55604 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55605 PyObject *resultobj = 0;
55606 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55607 wxEdge arg2 ;
55608 void *argp1 = 0 ;
55609 int res1 = 0 ;
55610 int val2 ;
55611 int ecode2 = 0 ;
55612 PyObject * obj0 = 0 ;
55613 PyObject * obj1 = 0 ;
55614 char * kwnames[] = {
55615 (char *) "self",(char *) "which", NULL
55616 };
55617
55618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
55619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55620 if (!SWIG_IsOK(res1)) {
55621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55622 }
55623 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55624 ecode2 = SWIG_AsVal_int(obj1, &val2);
55625 if (!SWIG_IsOK(ecode2)) {
55626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
55627 }
55628 arg2 = static_cast< wxEdge >(val2);
55629 {
55630 PyThreadState* __tstate = wxPyBeginAllowThreads();
55631 (arg1)->SetEdge(arg2);
55632 wxPyEndAllowThreads(__tstate);
55633 if (PyErr_Occurred()) SWIG_fail;
55634 }
55635 resultobj = SWIG_Py_Void();
55636 return resultobj;
55637 fail:
55638 return NULL;
55639 }
55640
55641
55642 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55643 PyObject *resultobj = 0;
55644 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55645 int arg2 ;
55646 void *argp1 = 0 ;
55647 int res1 = 0 ;
55648 int val2 ;
55649 int ecode2 = 0 ;
55650 PyObject * obj0 = 0 ;
55651 PyObject * obj1 = 0 ;
55652 char * kwnames[] = {
55653 (char *) "self",(char *) "v", NULL
55654 };
55655
55656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
55657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55658 if (!SWIG_IsOK(res1)) {
55659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55660 }
55661 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55662 ecode2 = SWIG_AsVal_int(obj1, &val2);
55663 if (!SWIG_IsOK(ecode2)) {
55664 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
55665 }
55666 arg2 = static_cast< int >(val2);
55667 {
55668 PyThreadState* __tstate = wxPyBeginAllowThreads();
55669 (arg1)->SetValue(arg2);
55670 wxPyEndAllowThreads(__tstate);
55671 if (PyErr_Occurred()) SWIG_fail;
55672 }
55673 resultobj = SWIG_Py_Void();
55674 return resultobj;
55675 fail:
55676 return NULL;
55677 }
55678
55679
55680 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55681 PyObject *resultobj = 0;
55682 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55683 int result;
55684 void *argp1 = 0 ;
55685 int res1 = 0 ;
55686 PyObject *swig_obj[1] ;
55687
55688 if (!args) SWIG_fail;
55689 swig_obj[0] = args;
55690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55691 if (!SWIG_IsOK(res1)) {
55692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55693 }
55694 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55695 {
55696 PyThreadState* __tstate = wxPyBeginAllowThreads();
55697 result = (int)(arg1)->GetMargin();
55698 wxPyEndAllowThreads(__tstate);
55699 if (PyErr_Occurred()) SWIG_fail;
55700 }
55701 resultobj = SWIG_From_int(static_cast< int >(result));
55702 return resultobj;
55703 fail:
55704 return NULL;
55705 }
55706
55707
55708 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55709 PyObject *resultobj = 0;
55710 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55711 int arg2 ;
55712 void *argp1 = 0 ;
55713 int res1 = 0 ;
55714 int val2 ;
55715 int ecode2 = 0 ;
55716 PyObject * obj0 = 0 ;
55717 PyObject * obj1 = 0 ;
55718 char * kwnames[] = {
55719 (char *) "self",(char *) "m", NULL
55720 };
55721
55722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
55723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55724 if (!SWIG_IsOK(res1)) {
55725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55726 }
55727 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55728 ecode2 = SWIG_AsVal_int(obj1, &val2);
55729 if (!SWIG_IsOK(ecode2)) {
55730 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
55731 }
55732 arg2 = static_cast< int >(val2);
55733 {
55734 PyThreadState* __tstate = wxPyBeginAllowThreads();
55735 (arg1)->SetMargin(arg2);
55736 wxPyEndAllowThreads(__tstate);
55737 if (PyErr_Occurred()) SWIG_fail;
55738 }
55739 resultobj = SWIG_Py_Void();
55740 return resultobj;
55741 fail:
55742 return NULL;
55743 }
55744
55745
55746 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55747 PyObject *resultobj = 0;
55748 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55749 int result;
55750 void *argp1 = 0 ;
55751 int res1 = 0 ;
55752 PyObject *swig_obj[1] ;
55753
55754 if (!args) SWIG_fail;
55755 swig_obj[0] = args;
55756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55757 if (!SWIG_IsOK(res1)) {
55758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55759 }
55760 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55761 {
55762 PyThreadState* __tstate = wxPyBeginAllowThreads();
55763 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
55764 wxPyEndAllowThreads(__tstate);
55765 if (PyErr_Occurred()) SWIG_fail;
55766 }
55767 resultobj = SWIG_From_int(static_cast< int >(result));
55768 return resultobj;
55769 fail:
55770 return NULL;
55771 }
55772
55773
55774 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55775 PyObject *resultobj = 0;
55776 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55777 int result;
55778 void *argp1 = 0 ;
55779 int res1 = 0 ;
55780 PyObject *swig_obj[1] ;
55781
55782 if (!args) SWIG_fail;
55783 swig_obj[0] = args;
55784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55785 if (!SWIG_IsOK(res1)) {
55786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55787 }
55788 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55789 {
55790 PyThreadState* __tstate = wxPyBeginAllowThreads();
55791 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
55792 wxPyEndAllowThreads(__tstate);
55793 if (PyErr_Occurred()) SWIG_fail;
55794 }
55795 resultobj = SWIG_From_int(static_cast< int >(result));
55796 return resultobj;
55797 fail:
55798 return NULL;
55799 }
55800
55801
55802 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55803 PyObject *resultobj = 0;
55804 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55805 int result;
55806 void *argp1 = 0 ;
55807 int res1 = 0 ;
55808 PyObject *swig_obj[1] ;
55809
55810 if (!args) SWIG_fail;
55811 swig_obj[0] = args;
55812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55813 if (!SWIG_IsOK(res1)) {
55814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55815 }
55816 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55817 {
55818 PyThreadState* __tstate = wxPyBeginAllowThreads();
55819 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
55820 wxPyEndAllowThreads(__tstate);
55821 if (PyErr_Occurred()) SWIG_fail;
55822 }
55823 resultobj = SWIG_From_int(static_cast< int >(result));
55824 return resultobj;
55825 fail:
55826 return NULL;
55827 }
55828
55829
55830 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55831 PyObject *resultobj = 0;
55832 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55833 bool result;
55834 void *argp1 = 0 ;
55835 int res1 = 0 ;
55836 PyObject *swig_obj[1] ;
55837
55838 if (!args) SWIG_fail;
55839 swig_obj[0] = args;
55840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55841 if (!SWIG_IsOK(res1)) {
55842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55843 }
55844 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55845 {
55846 PyThreadState* __tstate = wxPyBeginAllowThreads();
55847 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
55848 wxPyEndAllowThreads(__tstate);
55849 if (PyErr_Occurred()) SWIG_fail;
55850 }
55851 {
55852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55853 }
55854 return resultobj;
55855 fail:
55856 return NULL;
55857 }
55858
55859
55860 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55861 PyObject *resultobj = 0;
55862 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55863 bool arg2 ;
55864 void *argp1 = 0 ;
55865 int res1 = 0 ;
55866 bool val2 ;
55867 int ecode2 = 0 ;
55868 PyObject * obj0 = 0 ;
55869 PyObject * obj1 = 0 ;
55870 char * kwnames[] = {
55871 (char *) "self",(char *) "d", NULL
55872 };
55873
55874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
55875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55876 if (!SWIG_IsOK(res1)) {
55877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55878 }
55879 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55880 ecode2 = SWIG_AsVal_bool(obj1, &val2);
55881 if (!SWIG_IsOK(ecode2)) {
55882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
55883 }
55884 arg2 = static_cast< bool >(val2);
55885 {
55886 PyThreadState* __tstate = wxPyBeginAllowThreads();
55887 (arg1)->SetDone(arg2);
55888 wxPyEndAllowThreads(__tstate);
55889 if (PyErr_Occurred()) SWIG_fail;
55890 }
55891 resultobj = SWIG_Py_Void();
55892 return resultobj;
55893 fail:
55894 return NULL;
55895 }
55896
55897
55898 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55899 PyObject *resultobj = 0;
55900 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55901 wxRelationship result;
55902 void *argp1 = 0 ;
55903 int res1 = 0 ;
55904 PyObject *swig_obj[1] ;
55905
55906 if (!args) SWIG_fail;
55907 swig_obj[0] = args;
55908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55909 if (!SWIG_IsOK(res1)) {
55910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55911 }
55912 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55913 {
55914 PyThreadState* __tstate = wxPyBeginAllowThreads();
55915 result = (wxRelationship)(arg1)->GetRelationship();
55916 wxPyEndAllowThreads(__tstate);
55917 if (PyErr_Occurred()) SWIG_fail;
55918 }
55919 resultobj = SWIG_From_int(static_cast< int >(result));
55920 return resultobj;
55921 fail:
55922 return NULL;
55923 }
55924
55925
55926 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55927 PyObject *resultobj = 0;
55928 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55929 wxRelationship arg2 ;
55930 void *argp1 = 0 ;
55931 int res1 = 0 ;
55932 int val2 ;
55933 int ecode2 = 0 ;
55934 PyObject * obj0 = 0 ;
55935 PyObject * obj1 = 0 ;
55936 char * kwnames[] = {
55937 (char *) "self",(char *) "r", NULL
55938 };
55939
55940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
55941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55942 if (!SWIG_IsOK(res1)) {
55943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55944 }
55945 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55946 ecode2 = SWIG_AsVal_int(obj1, &val2);
55947 if (!SWIG_IsOK(ecode2)) {
55948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
55949 }
55950 arg2 = static_cast< wxRelationship >(val2);
55951 {
55952 PyThreadState* __tstate = wxPyBeginAllowThreads();
55953 (arg1)->SetRelationship(arg2);
55954 wxPyEndAllowThreads(__tstate);
55955 if (PyErr_Occurred()) SWIG_fail;
55956 }
55957 resultobj = SWIG_Py_Void();
55958 return resultobj;
55959 fail:
55960 return NULL;
55961 }
55962
55963
55964 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55965 PyObject *resultobj = 0;
55966 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55967 wxWindow *arg2 = (wxWindow *) 0 ;
55968 bool result;
55969 void *argp1 = 0 ;
55970 int res1 = 0 ;
55971 void *argp2 = 0 ;
55972 int res2 = 0 ;
55973 PyObject * obj0 = 0 ;
55974 PyObject * obj1 = 0 ;
55975 char * kwnames[] = {
55976 (char *) "self",(char *) "otherW", NULL
55977 };
55978
55979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
55980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55981 if (!SWIG_IsOK(res1)) {
55982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55983 }
55984 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55985 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55986 if (!SWIG_IsOK(res2)) {
55987 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
55988 }
55989 arg2 = reinterpret_cast< wxWindow * >(argp2);
55990 {
55991 PyThreadState* __tstate = wxPyBeginAllowThreads();
55992 result = (bool)(arg1)->ResetIfWin(arg2);
55993 wxPyEndAllowThreads(__tstate);
55994 if (PyErr_Occurred()) SWIG_fail;
55995 }
55996 {
55997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55998 }
55999 return resultobj;
56000 fail:
56001 return NULL;
56002 }
56003
56004
56005 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56006 PyObject *resultobj = 0;
56007 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56008 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
56009 wxWindow *arg3 = (wxWindow *) 0 ;
56010 bool result;
56011 void *argp1 = 0 ;
56012 int res1 = 0 ;
56013 void *argp2 = 0 ;
56014 int res2 = 0 ;
56015 void *argp3 = 0 ;
56016 int res3 = 0 ;
56017 PyObject * obj0 = 0 ;
56018 PyObject * obj1 = 0 ;
56019 PyObject * obj2 = 0 ;
56020 char * kwnames[] = {
56021 (char *) "self",(char *) "constraints",(char *) "win", NULL
56022 };
56023
56024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56026 if (!SWIG_IsOK(res1)) {
56027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56028 }
56029 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56030 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56031 if (!SWIG_IsOK(res2)) {
56032 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
56033 }
56034 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
56035 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
56036 if (!SWIG_IsOK(res3)) {
56037 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
56038 }
56039 arg3 = reinterpret_cast< wxWindow * >(argp3);
56040 {
56041 PyThreadState* __tstate = wxPyBeginAllowThreads();
56042 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
56043 wxPyEndAllowThreads(__tstate);
56044 if (PyErr_Occurred()) SWIG_fail;
56045 }
56046 {
56047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56048 }
56049 return resultobj;
56050 fail:
56051 return NULL;
56052 }
56053
56054
56055 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56056 PyObject *resultobj = 0;
56057 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56058 wxEdge arg2 ;
56059 wxWindow *arg3 = (wxWindow *) 0 ;
56060 wxWindow *arg4 = (wxWindow *) 0 ;
56061 int result;
56062 void *argp1 = 0 ;
56063 int res1 = 0 ;
56064 int val2 ;
56065 int ecode2 = 0 ;
56066 void *argp3 = 0 ;
56067 int res3 = 0 ;
56068 void *argp4 = 0 ;
56069 int res4 = 0 ;
56070 PyObject * obj0 = 0 ;
56071 PyObject * obj1 = 0 ;
56072 PyObject * obj2 = 0 ;
56073 PyObject * obj3 = 0 ;
56074 char * kwnames[] = {
56075 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
56076 };
56077
56078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
56079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56080 if (!SWIG_IsOK(res1)) {
56081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
56082 }
56083 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56084 ecode2 = SWIG_AsVal_int(obj1, &val2);
56085 if (!SWIG_IsOK(ecode2)) {
56086 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
56087 }
56088 arg2 = static_cast< wxEdge >(val2);
56089 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
56090 if (!SWIG_IsOK(res3)) {
56091 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
56092 }
56093 arg3 = reinterpret_cast< wxWindow * >(argp3);
56094 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
56095 if (!SWIG_IsOK(res4)) {
56096 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
56097 }
56098 arg4 = reinterpret_cast< wxWindow * >(argp4);
56099 {
56100 PyThreadState* __tstate = wxPyBeginAllowThreads();
56101 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
56102 wxPyEndAllowThreads(__tstate);
56103 if (PyErr_Occurred()) SWIG_fail;
56104 }
56105 resultobj = SWIG_From_int(static_cast< int >(result));
56106 return resultobj;
56107 fail:
56108 return NULL;
56109 }
56110
56111
56112 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56113 PyObject *obj;
56114 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56115 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
56116 return SWIG_Py_Void();
56117 }
56118
56119 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56120 PyObject *resultobj = 0;
56121 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56122 wxIndividualLayoutConstraint *result = 0 ;
56123 void *argp1 = 0 ;
56124 int res1 = 0 ;
56125 PyObject *swig_obj[1] ;
56126
56127 if (!args) SWIG_fail;
56128 swig_obj[0] = args;
56129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56130 if (!SWIG_IsOK(res1)) {
56131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56132 }
56133 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56134 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
56135 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56136 return resultobj;
56137 fail:
56138 return NULL;
56139 }
56140
56141
56142 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56143 PyObject *resultobj = 0;
56144 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56145 wxIndividualLayoutConstraint *result = 0 ;
56146 void *argp1 = 0 ;
56147 int res1 = 0 ;
56148 PyObject *swig_obj[1] ;
56149
56150 if (!args) SWIG_fail;
56151 swig_obj[0] = args;
56152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56153 if (!SWIG_IsOK(res1)) {
56154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56155 }
56156 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56157 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
56158 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56159 return resultobj;
56160 fail:
56161 return NULL;
56162 }
56163
56164
56165 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56166 PyObject *resultobj = 0;
56167 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56168 wxIndividualLayoutConstraint *result = 0 ;
56169 void *argp1 = 0 ;
56170 int res1 = 0 ;
56171 PyObject *swig_obj[1] ;
56172
56173 if (!args) SWIG_fail;
56174 swig_obj[0] = args;
56175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56176 if (!SWIG_IsOK(res1)) {
56177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56178 }
56179 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56180 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
56181 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56182 return resultobj;
56183 fail:
56184 return NULL;
56185 }
56186
56187
56188 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56189 PyObject *resultobj = 0;
56190 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56191 wxIndividualLayoutConstraint *result = 0 ;
56192 void *argp1 = 0 ;
56193 int res1 = 0 ;
56194 PyObject *swig_obj[1] ;
56195
56196 if (!args) SWIG_fail;
56197 swig_obj[0] = args;
56198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56199 if (!SWIG_IsOK(res1)) {
56200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56201 }
56202 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56203 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
56204 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56205 return resultobj;
56206 fail:
56207 return NULL;
56208 }
56209
56210
56211 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56212 PyObject *resultobj = 0;
56213 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56214 wxIndividualLayoutConstraint *result = 0 ;
56215 void *argp1 = 0 ;
56216 int res1 = 0 ;
56217 PyObject *swig_obj[1] ;
56218
56219 if (!args) SWIG_fail;
56220 swig_obj[0] = args;
56221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56222 if (!SWIG_IsOK(res1)) {
56223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56224 }
56225 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56226 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
56227 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56228 return resultobj;
56229 fail:
56230 return NULL;
56231 }
56232
56233
56234 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56235 PyObject *resultobj = 0;
56236 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56237 wxIndividualLayoutConstraint *result = 0 ;
56238 void *argp1 = 0 ;
56239 int res1 = 0 ;
56240 PyObject *swig_obj[1] ;
56241
56242 if (!args) SWIG_fail;
56243 swig_obj[0] = args;
56244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56245 if (!SWIG_IsOK(res1)) {
56246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56247 }
56248 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56249 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
56250 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56251 return resultobj;
56252 fail:
56253 return NULL;
56254 }
56255
56256
56257 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56258 PyObject *resultobj = 0;
56259 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56260 wxIndividualLayoutConstraint *result = 0 ;
56261 void *argp1 = 0 ;
56262 int res1 = 0 ;
56263 PyObject *swig_obj[1] ;
56264
56265 if (!args) SWIG_fail;
56266 swig_obj[0] = args;
56267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56268 if (!SWIG_IsOK(res1)) {
56269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56270 }
56271 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56272 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
56273 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56274 return resultobj;
56275 fail:
56276 return NULL;
56277 }
56278
56279
56280 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56281 PyObject *resultobj = 0;
56282 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56283 wxIndividualLayoutConstraint *result = 0 ;
56284 void *argp1 = 0 ;
56285 int res1 = 0 ;
56286 PyObject *swig_obj[1] ;
56287
56288 if (!args) SWIG_fail;
56289 swig_obj[0] = args;
56290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56291 if (!SWIG_IsOK(res1)) {
56292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56293 }
56294 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56295 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
56296 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56297 return resultobj;
56298 fail:
56299 return NULL;
56300 }
56301
56302
56303 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56304 PyObject *resultobj = 0;
56305 wxLayoutConstraints *result = 0 ;
56306
56307 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
56308 {
56309 PyThreadState* __tstate = wxPyBeginAllowThreads();
56310 result = (wxLayoutConstraints *)new wxLayoutConstraints();
56311 wxPyEndAllowThreads(__tstate);
56312 if (PyErr_Occurred()) SWIG_fail;
56313 }
56314 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
56315 return resultobj;
56316 fail:
56317 return NULL;
56318 }
56319
56320
56321 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56322 PyObject *resultobj = 0;
56323 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56324 void *argp1 = 0 ;
56325 int res1 = 0 ;
56326 PyObject *swig_obj[1] ;
56327
56328 if (!args) SWIG_fail;
56329 swig_obj[0] = args;
56330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
56331 if (!SWIG_IsOK(res1)) {
56332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56333 }
56334 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56335 {
56336 PyThreadState* __tstate = wxPyBeginAllowThreads();
56337 delete arg1;
56338
56339 wxPyEndAllowThreads(__tstate);
56340 if (PyErr_Occurred()) SWIG_fail;
56341 }
56342 resultobj = SWIG_Py_Void();
56343 return resultobj;
56344 fail:
56345 return NULL;
56346 }
56347
56348
56349 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56350 PyObject *resultobj = 0;
56351 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56352 wxWindow *arg2 = (wxWindow *) 0 ;
56353 int *arg3 = (int *) 0 ;
56354 bool result;
56355 void *argp1 = 0 ;
56356 int res1 = 0 ;
56357 void *argp2 = 0 ;
56358 int res2 = 0 ;
56359 int temp3 ;
56360 int res3 = SWIG_TMPOBJ ;
56361 PyObject * obj0 = 0 ;
56362 PyObject * obj1 = 0 ;
56363 char * kwnames[] = {
56364 (char *) "self",(char *) "win", NULL
56365 };
56366
56367 arg3 = &temp3;
56368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
56369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56370 if (!SWIG_IsOK(res1)) {
56371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56372 }
56373 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56374 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56375 if (!SWIG_IsOK(res2)) {
56376 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
56377 }
56378 arg2 = reinterpret_cast< wxWindow * >(argp2);
56379 {
56380 PyThreadState* __tstate = wxPyBeginAllowThreads();
56381 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
56382 wxPyEndAllowThreads(__tstate);
56383 if (PyErr_Occurred()) SWIG_fail;
56384 }
56385 {
56386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56387 }
56388 if (SWIG_IsTmpObj(res3)) {
56389 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
56390 } else {
56391 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
56392 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
56393 }
56394 return resultobj;
56395 fail:
56396 return NULL;
56397 }
56398
56399
56400 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56401 PyObject *resultobj = 0;
56402 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56403 bool result;
56404 void *argp1 = 0 ;
56405 int res1 = 0 ;
56406 PyObject *swig_obj[1] ;
56407
56408 if (!args) SWIG_fail;
56409 swig_obj[0] = args;
56410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56411 if (!SWIG_IsOK(res1)) {
56412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
56413 }
56414 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56415 {
56416 PyThreadState* __tstate = wxPyBeginAllowThreads();
56417 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
56418 wxPyEndAllowThreads(__tstate);
56419 if (PyErr_Occurred()) SWIG_fail;
56420 }
56421 {
56422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56423 }
56424 return resultobj;
56425 fail:
56426 return NULL;
56427 }
56428
56429
56430 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56431 PyObject *obj;
56432 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56433 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
56434 return SWIG_Py_Void();
56435 }
56436
56437 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56438 return SWIG_Python_InitShadowInstance(args);
56439 }
56440
56441 static PyMethodDef SwigMethods[] = {
56442 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
56443 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
56444 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
56445 { (char *)"Object_IsSameAs", (PyCFunction) _wrap_Object_IsSameAs, METH_VARARGS | METH_KEYWORDS, NULL},
56446 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
56447 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
56448 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
56449 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
56450 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
56451 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56452 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
56453 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56454 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56455 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56456 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56457 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
56458 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
56459 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
56460 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
56461 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
56462 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56463 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56464 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56465 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
56466 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
56467 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
56468 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
56469 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
56470 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
56471 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
56472 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
56473 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
56474 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
56475 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
56476 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56477 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
56478 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56479 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56480 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56481 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56482 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56483 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
56484 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
56485 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
56486 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
56487 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
56488 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
56489 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
56490 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
56491 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
56492 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56493 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56494 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56495 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56496 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56497 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56498 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56499 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
56500 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
56501 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
56502 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
56503 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
56504 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
56505 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
56506 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
56507 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
56508 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
56509 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
56510 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
56511 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
56512 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56513 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
56514 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56515 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
56516 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56517 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
56518 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
56519 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
56520 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
56521 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56522 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
56523 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
56524 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
56525 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
56526 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
56527 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56528 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
56529 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
56530 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
56531 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
56532 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56533 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56534 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56535 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56536 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
56537 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
56538 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
56539 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56540 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56541 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56542 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56543 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56544 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56545 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56546 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
56547 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56548 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56549 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56550 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
56551 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
56552 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
56553 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
56554 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
56555 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
56556 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
56557 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
56558 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
56559 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56560 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
56561 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
56562 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
56563 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
56564 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
56565 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
56566 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56567 { (char *)"delete_Point2D", (PyCFunction)_wrap_delete_Point2D, METH_O, NULL},
56568 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
56569 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
56570 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
56571 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
56572 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
56573 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
56574 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
56575 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
56576 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56577 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56578 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
56579 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56580 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56581 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
56582 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
56583 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56584 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56585 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
56586 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
56587 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
56588 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
56589 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56590 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
56591 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
56592 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
56593 { (char *)"new_Rect2D", (PyCFunction) _wrap_new_Rect2D, METH_VARARGS | METH_KEYWORDS, NULL},
56594 { (char *)"delete_Rect2D", (PyCFunction)_wrap_delete_Rect2D, METH_O, NULL},
56595 { (char *)"Rect2D_GetPosition", (PyCFunction)_wrap_Rect2D_GetPosition, METH_O, NULL},
56596 { (char *)"Rect2D_GetSize", (PyCFunction)_wrap_Rect2D_GetSize, METH_O, NULL},
56597 { (char *)"Rect2D_GetLeft", (PyCFunction)_wrap_Rect2D_GetLeft, METH_O, NULL},
56598 { (char *)"Rect2D_SetLeft", (PyCFunction) _wrap_Rect2D_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56599 { (char *)"Rect2D_MoveLeftTo", (PyCFunction) _wrap_Rect2D_MoveLeftTo, METH_VARARGS | METH_KEYWORDS, NULL},
56600 { (char *)"Rect2D_GetTop", (PyCFunction)_wrap_Rect2D_GetTop, METH_O, NULL},
56601 { (char *)"Rect2D_SetTop", (PyCFunction) _wrap_Rect2D_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56602 { (char *)"Rect2D_MoveTopTo", (PyCFunction) _wrap_Rect2D_MoveTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56603 { (char *)"Rect2D_GetBottom", (PyCFunction)_wrap_Rect2D_GetBottom, METH_O, NULL},
56604 { (char *)"Rect2D_SetBottom", (PyCFunction) _wrap_Rect2D_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56605 { (char *)"Rect2D_MoveBottomTo", (PyCFunction) _wrap_Rect2D_MoveBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56606 { (char *)"Rect2D_GetRight", (PyCFunction)_wrap_Rect2D_GetRight, METH_O, NULL},
56607 { (char *)"Rect2D_SetRight", (PyCFunction) _wrap_Rect2D_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56608 { (char *)"Rect2D_MoveRightTo", (PyCFunction) _wrap_Rect2D_MoveRightTo, METH_VARARGS | METH_KEYWORDS, NULL},
56609 { (char *)"Rect2D_GetLeftTop", (PyCFunction)_wrap_Rect2D_GetLeftTop, METH_O, NULL},
56610 { (char *)"Rect2D_SetLeftTop", (PyCFunction) _wrap_Rect2D_SetLeftTop, METH_VARARGS | METH_KEYWORDS, NULL},
56611 { (char *)"Rect2D_MoveLeftTopTo", (PyCFunction) _wrap_Rect2D_MoveLeftTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56612 { (char *)"Rect2D_GetLeftBottom", (PyCFunction)_wrap_Rect2D_GetLeftBottom, METH_O, NULL},
56613 { (char *)"Rect2D_SetLeftBottom", (PyCFunction) _wrap_Rect2D_SetLeftBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56614 { (char *)"Rect2D_MoveLeftBottomTo", (PyCFunction) _wrap_Rect2D_MoveLeftBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56615 { (char *)"Rect2D_GetRightTop", (PyCFunction)_wrap_Rect2D_GetRightTop, METH_O, NULL},
56616 { (char *)"Rect2D_SetRightTop", (PyCFunction) _wrap_Rect2D_SetRightTop, METH_VARARGS | METH_KEYWORDS, NULL},
56617 { (char *)"Rect2D_MoveRightTopTo", (PyCFunction) _wrap_Rect2D_MoveRightTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56618 { (char *)"Rect2D_GetRightBottom", (PyCFunction)_wrap_Rect2D_GetRightBottom, METH_O, NULL},
56619 { (char *)"Rect2D_SetRightBottom", (PyCFunction) _wrap_Rect2D_SetRightBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56620 { (char *)"Rect2D_MoveRightBottomTo", (PyCFunction) _wrap_Rect2D_MoveRightBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56621 { (char *)"Rect2D_GetCentre", (PyCFunction)_wrap_Rect2D_GetCentre, METH_O, NULL},
56622 { (char *)"Rect2D_SetCentre", (PyCFunction) _wrap_Rect2D_SetCentre, METH_VARARGS | METH_KEYWORDS, NULL},
56623 { (char *)"Rect2D_MoveCentreTo", (PyCFunction) _wrap_Rect2D_MoveCentreTo, METH_VARARGS | METH_KEYWORDS, NULL},
56624 { (char *)"Rect2D_GetOutcode", (PyCFunction) _wrap_Rect2D_GetOutcode, METH_VARARGS | METH_KEYWORDS, NULL},
56625 { (char *)"Rect2D_Contains", (PyCFunction) _wrap_Rect2D_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56626 { (char *)"Rect2D_ContainsRect", (PyCFunction) _wrap_Rect2D_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56627 { (char *)"Rect2D_IsEmpty", (PyCFunction)_wrap_Rect2D_IsEmpty, METH_O, NULL},
56628 { (char *)"Rect2D_HaveEqualSize", (PyCFunction) _wrap_Rect2D_HaveEqualSize, METH_VARARGS | METH_KEYWORDS, NULL},
56629 { (char *)"Rect2D_Inset", _wrap_Rect2D_Inset, METH_VARARGS, NULL},
56630 { (char *)"Rect2D_Offset", (PyCFunction) _wrap_Rect2D_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56631 { (char *)"Rect2D_ConstrainTo", (PyCFunction) _wrap_Rect2D_ConstrainTo, METH_VARARGS | METH_KEYWORDS, NULL},
56632 { (char *)"Rect2D_Interpolate", (PyCFunction) _wrap_Rect2D_Interpolate, METH_VARARGS | METH_KEYWORDS, NULL},
56633 { (char *)"Rect2D_Intersect", (PyCFunction) _wrap_Rect2D_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56634 { (char *)"Rect2D_CreateIntersection", (PyCFunction) _wrap_Rect2D_CreateIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
56635 { (char *)"Rect2D_Intersects", (PyCFunction) _wrap_Rect2D_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56636 { (char *)"Rect2D_Union", (PyCFunction) _wrap_Rect2D_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56637 { (char *)"Rect2D_CreateUnion", (PyCFunction) _wrap_Rect2D_CreateUnion, METH_VARARGS | METH_KEYWORDS, NULL},
56638 { (char *)"Rect2D_Scale", _wrap_Rect2D_Scale, METH_VARARGS, NULL},
56639 { (char *)"Rect2D___eq__", (PyCFunction) _wrap_Rect2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56640 { (char *)"Rect2D___ne__", (PyCFunction) _wrap_Rect2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56641 { (char *)"Rect2D_x_set", _wrap_Rect2D_x_set, METH_VARARGS, NULL},
56642 { (char *)"Rect2D_x_get", (PyCFunction)_wrap_Rect2D_x_get, METH_O, NULL},
56643 { (char *)"Rect2D_y_set", _wrap_Rect2D_y_set, METH_VARARGS, NULL},
56644 { (char *)"Rect2D_y_get", (PyCFunction)_wrap_Rect2D_y_get, METH_O, NULL},
56645 { (char *)"Rect2D_width_set", _wrap_Rect2D_width_set, METH_VARARGS, NULL},
56646 { (char *)"Rect2D_width_get", (PyCFunction)_wrap_Rect2D_width_get, METH_O, NULL},
56647 { (char *)"Rect2D_height_set", _wrap_Rect2D_height_set, METH_VARARGS, NULL},
56648 { (char *)"Rect2D_height_get", (PyCFunction)_wrap_Rect2D_height_get, METH_O, NULL},
56649 { (char *)"Rect2D_Set", (PyCFunction) _wrap_Rect2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56650 { (char *)"Rect2D_Get", (PyCFunction)_wrap_Rect2D_Get, METH_O, NULL},
56651 { (char *)"Rect2D_swigregister", Rect2D_swigregister, METH_VARARGS, NULL},
56652 { (char *)"Rect2D_swiginit", Rect2D_swiginit, METH_VARARGS, NULL},
56653 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
56654 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
56655 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
56656 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
56657 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
56658 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
56659 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
56660 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
56661 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
56662 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
56663 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
56664 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
56665 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
56666 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
56667 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
56668 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
56669 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
56670 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
56671 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
56672 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
56673 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
56674 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
56675 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
56676 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
56677 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
56678 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
56679 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
56680 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
56681 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
56682 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
56683 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
56684 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
56685 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
56686 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
56687 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
56688 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
56689 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
56690 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56691 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56692 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56693 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
56694 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
56695 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56696 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
56697 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56698 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
56699 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
56700 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
56701 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
56702 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
56703 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
56704 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
56705 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56706 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56707 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
56708 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56709 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56710 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
56711 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
56712 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
56713 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
56714 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
56715 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
56716 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56717 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56718 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
56719 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
56720 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
56721 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56722 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56723 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56724 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
56725 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
56726 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
56727 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
56728 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56729 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
56730 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
56731 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56732 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56733 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56734 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56735 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
56736 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
56737 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
56738 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
56739 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
56740 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
56741 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
56742 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56743 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56744 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
56745 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
56746 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
56747 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
56748 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
56749 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
56750 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
56751 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
56752 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
56753 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
56754 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
56755 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56756 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
56757 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56758 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
56759 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
56760 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
56761 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
56762 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
56763 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
56764 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
56765 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
56766 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
56767 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
56768 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
56769 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
56770 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
56771 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
56772 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
56773 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
56774 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
56775 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
56776 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
56777 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
56778 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
56779 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
56780 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
56781 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
56782 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
56783 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
56784 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
56785 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56786 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
56787 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56788 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
56789 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
56790 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
56791 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
56792 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
56793 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
56794 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
56795 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
56796 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
56797 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
56798 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
56799 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56800 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
56801 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
56802 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
56803 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
56804 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56805 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56806 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
56807 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
56808 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
56809 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56810 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
56811 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56812 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
56813 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56814 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
56815 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
56816 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56817 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56818 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56819 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56820 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56821 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
56822 { (char *)"Image_IsOk", (PyCFunction)_wrap_Image_IsOk, METH_O, NULL},
56823 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
56824 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
56825 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
56826 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
56827 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56828 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
56829 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
56830 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
56831 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
56832 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
56833 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56834 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
56835 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
56836 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
56837 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56838 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
56839 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
56840 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
56841 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
56842 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
56843 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
56844 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
56845 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
56846 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
56847 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
56848 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
56849 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
56850 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
56851 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
56852 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
56853 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
56854 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
56855 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
56856 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
56857 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
56858 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56859 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56860 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56861 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
56862 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
56863 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56864 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56865 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
56866 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
56867 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56868 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
56869 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
56870 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56871 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
56872 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
56873 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
56874 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
56875 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
56876 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
56877 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
56878 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
56879 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
56880 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
56881 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
56882 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
56883 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
56884 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
56885 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
56886 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
56887 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
56888 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
56889 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
56890 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
56891 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
56892 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
56893 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
56894 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
56895 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
56896 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
56897 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
56898 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
56899 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
56900 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
56901 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
56902 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
56903 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
56904 { (char *)"new_TGAHandler", (PyCFunction)_wrap_new_TGAHandler, METH_NOARGS, NULL},
56905 { (char *)"TGAHandler_swigregister", TGAHandler_swigregister, METH_VARARGS, NULL},
56906 { (char *)"TGAHandler_swiginit", TGAHandler_swiginit, METH_VARARGS, NULL},
56907 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
56908 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
56909 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
56910 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
56911 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
56912 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56913 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56914 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
56915 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
56916 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56917 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56918 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
56919 { (char *)"EvtHandler_AllowReentrance", (PyCFunction) _wrap_EvtHandler_AllowReentrance, METH_VARARGS | METH_KEYWORDS, NULL},
56920 { (char *)"EvtHandler_IsReentranceAllowed", (PyCFunction)_wrap_EvtHandler_IsReentranceAllowed, METH_O, NULL},
56921 { (char *)"EvtHandler_IsEventHandlingInProgress", (PyCFunction)_wrap_EvtHandler_IsEventHandlingInProgress, METH_O, NULL},
56922 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
56923 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
56924 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
56925 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
56926 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
56927 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
56928 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
56929 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
56930 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
56931 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
56932 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
56933 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
56934 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
56935 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
56936 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
56937 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
56938 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
56939 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
56940 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
56941 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
56942 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
56943 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
56944 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
56945 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
56946 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
56947 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
56948 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
56949 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
56950 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
56951 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
56952 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
56953 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56954 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
56955 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
56956 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
56957 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
56958 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
56959 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
56960 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
56961 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
56962 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
56963 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
56964 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
56965 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
56966 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
56967 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
56968 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56969 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
56970 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
56971 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
56972 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
56973 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
56974 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56975 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
56976 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
56977 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
56978 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56979 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
56980 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
56981 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56982 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
56983 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
56984 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
56985 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56986 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
56987 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
56988 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56989 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
56990 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
56991 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
56992 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
56993 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
56994 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
56995 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
56996 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
56997 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
56998 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
56999 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
57000 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
57001 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
57002 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
57003 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
57004 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
57005 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
57006 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
57007 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
57008 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
57009 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
57010 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
57011 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
57012 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
57013 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
57014 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
57015 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
57016 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
57017 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
57018 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
57019 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57020 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
57021 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
57022 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
57023 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
57024 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
57025 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
57026 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
57027 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
57028 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
57029 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
57030 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
57031 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
57032 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
57033 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
57034 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
57035 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
57036 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
57037 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
57038 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
57039 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
57040 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
57041 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
57042 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
57043 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
57044 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
57045 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
57046 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
57047 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
57048 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
57049 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
57050 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
57051 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
57052 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57053 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
57054 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
57055 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
57056 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
57057 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
57058 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
57059 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
57060 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57061 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
57062 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
57063 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
57064 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
57065 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
57066 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
57067 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
57068 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
57069 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
57070 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
57071 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
57072 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
57073 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
57074 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
57075 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
57076 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
57077 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
57078 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
57079 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
57080 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
57081 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
57082 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
57083 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
57084 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
57085 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
57086 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
57087 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
57088 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
57089 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
57090 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
57091 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
57092 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
57093 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
57094 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
57095 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
57096 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
57097 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
57098 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
57099 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57100 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
57101 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
57102 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57103 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57104 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
57105 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
57106 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
57107 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
57108 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
57109 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
57110 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57111 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
57112 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
57113 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57114 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57115 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
57116 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
57117 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57118 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
57119 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
57120 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57121 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
57122 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
57123 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57124 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
57125 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
57126 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
57127 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57128 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
57129 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57130 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
57131 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
57132 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57133 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
57134 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
57135 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
57136 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57137 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
57138 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
57139 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
57140 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57141 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
57142 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
57143 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57144 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
57145 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
57146 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
57147 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
57148 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
57149 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57150 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
57151 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
57152 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
57153 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
57154 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
57155 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
57156 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
57157 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
57158 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57159 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
57160 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
57161 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
57162 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
57163 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57164 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
57165 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
57166 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
57167 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57168 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
57169 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
57170 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
57171 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
57172 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
57173 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
57174 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57175 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
57176 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
57177 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
57178 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
57179 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
57180 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
57181 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
57182 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
57183 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57184 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57185 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57186 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57187 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
57188 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
57189 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
57190 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
57191 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57192 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
57193 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
57194 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
57195 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
57196 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
57197 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
57198 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57199 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
57200 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
57201 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
57202 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57203 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
57204 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
57205 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
57206 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
57207 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
57208 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57209 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57210 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
57211 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
57212 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
57213 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57214 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
57215 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
57216 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
57217 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
57218 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
57219 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
57220 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57221 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
57222 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
57223 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
57224 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
57225 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
57226 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
57227 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
57228 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
57229 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
57230 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57231 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
57232 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
57233 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
57234 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57235 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
57236 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
57237 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
57238 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57239 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
57240 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57241 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
57242 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
57243 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
57244 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
57245 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
57246 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57247 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
57248 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
57249 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
57250 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
57251 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57252 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
57253 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
57254 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57255 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
57256 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57257 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
57258 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
57259 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
57260 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57261 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
57262 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57263 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
57264 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
57265 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
57266 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57267 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
57268 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
57269 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
57270 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
57271 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
57272 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
57273 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57274 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
57275 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
57276 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
57277 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
57278 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
57279 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
57280 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
57281 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
57282 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
57283 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
57284 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
57285 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
57286 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
57287 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
57288 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
57289 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
57290 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
57291 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
57292 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
57293 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
57294 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57295 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
57296 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
57297 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
57298 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
57299 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
57300 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
57301 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
57302 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
57303 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
57304 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
57305 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
57306 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
57307 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
57308 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
57309 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
57310 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57311 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57312 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57313 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
57314 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
57315 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
57316 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
57317 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
57318 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
57319 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
57320 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
57321 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
57322 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
57323 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
57324 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57325 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
57326 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
57327 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
57328 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
57329 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
57330 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
57331 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
57332 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
57333 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
57334 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
57335 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
57336 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
57337 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
57338 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
57339 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
57340 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
57341 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
57342 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
57343 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
57344 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
57345 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
57346 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57347 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57348 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
57349 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
57350 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
57351 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
57352 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
57353 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
57354 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
57355 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
57356 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57357 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
57358 { (char *)"AcceleratorTable_IsOk", (PyCFunction)_wrap_AcceleratorTable_IsOk, METH_O, NULL},
57359 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
57360 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
57361 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
57362 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
57363 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
57364 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
57365 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
57366 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
57367 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
57368 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
57369 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
57370 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
57371 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
57372 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
57373 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
57374 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57375 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
57376 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
57377 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
57378 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
57379 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57380 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
57381 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
57382 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
57383 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
57384 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
57385 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57386 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
57387 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
57388 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57389 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57390 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
57391 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57392 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57393 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57394 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
57395 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57396 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57397 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
57398 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
57399 { (char *)"Window_SetInitialSize", (PyCFunction) _wrap_Window_SetInitialSize, METH_VARARGS | METH_KEYWORDS, NULL},
57400 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
57401 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
57402 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
57403 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57404 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
57405 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
57406 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
57407 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
57408 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
57409 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
57410 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
57411 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
57412 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
57413 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
57414 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
57415 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
57416 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
57417 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
57418 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
57419 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
57420 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
57421 { (char *)"Window_GetEffectiveMinSize", (PyCFunction)_wrap_Window_GetEffectiveMinSize, METH_O, NULL},
57422 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
57423 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
57424 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
57425 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
57426 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57427 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57428 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57429 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57430 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
57431 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
57432 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57433 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
57434 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
57435 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
57436 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
57437 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
57438 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
57439 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57440 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
57441 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
57442 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
57443 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57444 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
57445 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57446 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
57447 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
57448 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
57449 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
57450 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57451 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
57452 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57453 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
57454 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57455 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
57456 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
57457 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57458 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
57459 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
57460 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
57461 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
57462 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
57463 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
57464 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
57465 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57466 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57467 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
57468 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
57469 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
57470 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
57471 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
57472 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
57473 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
57474 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
57475 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57476 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57477 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
57478 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57479 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57480 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57481 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57482 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
57483 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
57484 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
57485 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
57486 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
57487 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
57488 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57489 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
57490 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57491 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57492 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57493 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57494 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
57495 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
57496 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57497 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57498 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
57499 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
57500 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
57501 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
57502 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
57503 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
57504 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
57505 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
57506 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
57507 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
57508 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
57509 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
57510 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
57511 { (char *)"Window_IsDoubleBuffered", (PyCFunction)_wrap_Window_IsDoubleBuffered, METH_O, NULL},
57512 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
57513 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
57514 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
57515 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57516 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
57517 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
57518 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57519 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57520 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57521 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57522 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57523 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
57524 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
57525 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
57526 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
57527 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57528 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
57529 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
57530 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
57531 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
57532 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57533 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
57534 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
57535 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
57536 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
57537 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
57538 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
57539 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57540 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57541 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
57542 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
57543 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
57544 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
57545 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
57546 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
57547 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
57548 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
57549 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
57550 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57551 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
57552 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
57553 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
57554 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
57555 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57556 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57557 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57558 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57559 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
57560 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
57561 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57562 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
57563 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
57564 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
57565 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
57566 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
57567 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
57568 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
57569 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
57570 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57571 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
57572 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
57573 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
57574 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
57575 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
57576 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
57577 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
57578 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
57579 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
57580 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
57581 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
57582 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
57583 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57584 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
57585 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
57586 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57587 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
57588 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
57589 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
57590 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
57591 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
57592 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
57593 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
57594 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57595 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57596 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57597 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
57598 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
57599 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
57600 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
57601 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
57602 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
57603 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
57604 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
57605 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57606 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
57607 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
57608 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
57609 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
57610 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
57611 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57612 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
57613 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
57614 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
57615 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57616 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
57617 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57618 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57619 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57620 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57621 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
57622 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57623 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57624 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
57625 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57626 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
57627 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57628 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57629 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57630 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57631 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
57632 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57633 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57634 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57635 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57636 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
57637 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57638 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
57639 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
57640 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
57641 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
57642 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
57643 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
57644 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
57645 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57646 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57647 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57648 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57649 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57650 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57651 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57652 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57653 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57654 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57655 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
57656 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
57657 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57658 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
57659 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57660 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
57661 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
57662 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
57663 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
57664 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57665 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
57666 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
57667 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
57668 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
57669 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
57670 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
57671 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
57672 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57673 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57674 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
57675 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57676 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
57677 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57678 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
57679 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
57680 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57681 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57682 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57683 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57684 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57685 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57686 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57687 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57688 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57689 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57690 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57691 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57692 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57693 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
57694 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
57695 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57696 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
57697 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
57698 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57699 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
57700 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
57701 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
57702 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57703 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
57704 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
57705 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57706 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57707 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
57708 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
57709 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57710 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
57711 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
57712 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
57713 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
57714 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
57715 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
57716 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
57717 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
57718 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57719 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
57720 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57721 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
57722 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57723 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
57724 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
57725 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
57726 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
57727 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
57728 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
57729 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57730 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
57731 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57732 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
57733 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
57734 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
57735 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57736 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
57737 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
57738 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57739 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
57740 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
57741 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
57742 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
57743 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
57744 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
57745 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
57746 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
57747 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
57748 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
57749 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
57750 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57751 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
57752 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
57753 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
57754 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57755 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
57756 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
57757 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57758 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
57759 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57760 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
57761 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57762 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57763 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57764 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
57765 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
57766 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
57767 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
57768 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
57769 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
57770 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57771 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
57772 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57773 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
57774 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
57775 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
57776 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
57777 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
57778 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
57779 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57780 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57781 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57782 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
57783 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
57784 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
57785 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
57786 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57787 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
57788 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
57789 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
57790 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
57791 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
57792 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
57793 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
57794 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
57795 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
57796 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
57797 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
57798 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
57799 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
57800 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57801 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
57802 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
57803 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
57804 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
57805 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57806 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
57807 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57808 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
57809 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57810 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57811 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
57812 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
57813 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
57814 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
57815 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
57816 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
57817 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
57818 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57819 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
57820 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57821 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57822 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57823 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
57824 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
57825 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57826 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
57827 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57828 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
57829 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57830 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
57831 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
57832 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57833 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57834 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57835 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57836 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
57837 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
57838 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
57839 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
57840 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
57841 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
57842 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
57843 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
57844 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57845 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57846 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
57847 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
57848 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
57849 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57850 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
57851 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
57852 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
57853 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
57854 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57855 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
57856 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
57857 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57858 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
57859 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
57860 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
57861 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
57862 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57863 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
57864 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
57865 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
57866 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57867 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
57868 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
57869 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
57870 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
57871 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
57872 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
57873 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
57874 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
57875 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
57876 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
57877 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57878 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
57879 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
57880 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
57881 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
57882 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57883 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
57884 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
57885 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
57886 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
57887 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
57888 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
57889 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
57890 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
57891 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
57892 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
57893 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
57894 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
57895 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
57896 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
57897 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
57898 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
57899 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
57900 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
57901 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
57902 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
57903 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57904 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
57905 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
57906 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
57907 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
57908 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
57909 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57910 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57911 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57912 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
57913 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
57914 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
57915 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
57916 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
57917 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
57918 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
57919 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
57920 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
57921 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57922 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57923 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57924 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
57925 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
57926 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
57927 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
57928 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
57929 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57930 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57931 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57932 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
57933 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
57934 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
57935 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
57936 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
57937 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
57938 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
57939 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
57940 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57941 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
57942 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
57943 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57944 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
57945 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
57946 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
57947 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
57948 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
57949 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
57950 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
57951 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
57952 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
57953 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
57954 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57955 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57956 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
57957 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
57958 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
57959 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
57960 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57961 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
57962 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
57963 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
57964 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
57965 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
57966 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
57967 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
57968 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
57969 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
57970 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
57971 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
57972 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
57973 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
57974 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
57975 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
57976 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
57977 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
57978 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
57979 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
57980 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
57981 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
57982 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
57983 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
57984 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
57985 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
57986 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
57987 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
57988 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
57989 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
57990 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
57991 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
57992 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
57993 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
57994 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
57995 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
57996 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
57997 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
57998 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
57999 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
58000 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
58001 { NULL, NULL, 0, NULL }
58002 };
58003
58004
58005 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
58006
58007 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
58008 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
58009 }
58010 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
58011 return (void *)((wxSizer *) ((wxBoxSizer *) x));
58012 }
58013 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
58014 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
58015 }
58016 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
58017 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58018 }
58019 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
58020 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
58021 }
58022 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
58023 return (void *)((wxSizer *) ((wxGridSizer *) x));
58024 }
58025 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
58026 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
58027 }
58028 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
58029 return (void *)((wxSizer *) ((wxPySizer *) x));
58030 }
58031 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
58032 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
58033 }
58034 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
58035 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58036 }
58037 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
58038 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
58039 }
58040 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
58041 return (void *)((wxEvent *) ((wxMenuEvent *) x));
58042 }
58043 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
58044 return (void *)((wxEvent *) ((wxCloseEvent *) x));
58045 }
58046 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
58047 return (void *)((wxEvent *) ((wxMouseEvent *) x));
58048 }
58049 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
58050 return (void *)((wxEvent *) ((wxEraseEvent *) x));
58051 }
58052 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
58053 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
58054 }
58055 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
58056 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
58057 }
58058 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
58059 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
58060 }
58061 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
58062 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
58063 }
58064 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
58065 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
58066 }
58067 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
58068 return (void *)((wxEvent *) ((wxPyEvent *) x));
58069 }
58070 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
58071 return (void *)((wxEvent *) ((wxIdleEvent *) x));
58072 }
58073 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
58074 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
58075 }
58076 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
58077 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
58078 }
58079 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
58080 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
58081 }
58082 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
58083 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
58084 }
58085 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
58086 return (void *)((wxEvent *) ((wxActivateEvent *) x));
58087 }
58088 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
58089 return (void *)((wxEvent *) ((wxSizeEvent *) x));
58090 }
58091 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
58092 return (void *)((wxEvent *) ((wxMoveEvent *) x));
58093 }
58094 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
58095 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
58096 }
58097 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
58098 return (void *)((wxEvent *) ((wxPaintEvent *) x));
58099 }
58100 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
58101 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
58102 }
58103 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
58104 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
58105 }
58106 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
58107 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
58108 }
58109 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
58110 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
58111 }
58112 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
58113 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
58114 }
58115 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
58116 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58117 }
58118 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
58119 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
58120 }
58121 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
58122 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
58123 }
58124 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
58125 return (void *)((wxEvent *) ((wxFocusEvent *) x));
58126 }
58127 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
58128 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
58129 }
58130 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
58131 return (void *)((wxEvent *) ((wxShowEvent *) x));
58132 }
58133 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
58134 return (void *)((wxEvent *) ((wxCommandEvent *) x));
58135 }
58136 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
58137 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
58138 }
58139 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
58140 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58141 }
58142 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
58143 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
58144 }
58145 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
58146 return (void *)((wxEvent *) ((wxKeyEvent *) x));
58147 }
58148 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
58149 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
58150 }
58151 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
58152 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
58153 }
58154 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
58155 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
58156 }
58157 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
58158 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
58159 }
58160 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
58161 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
58162 }
58163 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
58164 return (void *)((wxControl *) ((wxControlWithItems *) x));
58165 }
58166 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
58167 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
58168 }
58169 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
58170 return (void *)((wxEvtHandler *) ((wxWindow *) x));
58171 }
58172 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
58173 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58174 }
58175 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
58176 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
58177 }
58178 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
58179 return (void *)((wxEvtHandler *) ((wxValidator *) x));
58180 }
58181 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
58182 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
58183 }
58184 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
58185 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
58186 }
58187 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
58188 return (void *)((wxEvtHandler *) ((wxMenu *) x));
58189 }
58190 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
58191 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
58192 }
58193 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
58194 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
58195 }
58196 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
58197 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
58198 }
58199 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
58200 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
58201 }
58202 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
58203 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
58204 }
58205 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
58206 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58207 }
58208 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
58209 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
58210 }
58211 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
58212 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
58213 }
58214 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
58215 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
58216 }
58217 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
58218 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58219 }
58220 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
58221 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58222 }
58223 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
58224 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
58225 }
58226 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
58227 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
58228 }
58229 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
58230 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
58231 }
58232 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
58233 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
58234 }
58235 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
58236 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
58237 }
58238 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
58239 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
58240 }
58241 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
58242 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
58243 }
58244 static void *_p_wxTGAHandlerTo_p_wxImageHandler(void *x) {
58245 return (void *)((wxImageHandler *) ((wxTGAHandler *) x));
58246 }
58247 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
58248 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
58249 }
58250 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
58251 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
58252 }
58253 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
58254 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
58255 }
58256 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
58257 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
58258 }
58259 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
58260 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
58261 }
58262 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
58263 return (void *)((wxObject *) ((wxSizerItem *) x));
58264 }
58265 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
58266 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
58267 }
58268 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
58269 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
58270 }
58271 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
58272 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
58273 }
58274 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
58275 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
58276 }
58277 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
58278 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
58279 }
58280 static void *_p_wxSizerTo_p_wxObject(void *x) {
58281 return (void *)((wxObject *) ((wxSizer *) x));
58282 }
58283 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
58284 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
58285 }
58286 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
58287 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
58288 }
58289 static void *_p_wxEventTo_p_wxObject(void *x) {
58290 return (void *)((wxObject *) ((wxEvent *) x));
58291 }
58292 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
58293 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
58294 }
58295 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
58296 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
58297 }
58298 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
58299 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
58300 }
58301 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
58302 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
58303 }
58304 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
58305 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
58306 }
58307 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
58308 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
58309 }
58310 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
58311 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
58312 }
58313 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
58314 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
58315 }
58316 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
58317 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58318 }
58319 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
58320 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
58321 }
58322 static void *_p_wxControlTo_p_wxObject(void *x) {
58323 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
58324 }
58325 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
58326 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
58327 }
58328 static void *_p_wxFSFileTo_p_wxObject(void *x) {
58329 return (void *)((wxObject *) ((wxFSFile *) x));
58330 }
58331 static void *_p_wxPySizerTo_p_wxObject(void *x) {
58332 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
58333 }
58334 static void *_p_wxPyEventTo_p_wxObject(void *x) {
58335 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
58336 }
58337 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
58338 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
58339 }
58340 static void *_p_wxShowEventTo_p_wxObject(void *x) {
58341 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
58342 }
58343 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
58344 return (void *)((wxObject *) ((wxMenuItem *) x));
58345 }
58346 static void *_p_wxDateEventTo_p_wxObject(void *x) {
58347 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
58348 }
58349 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
58350 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
58351 }
58352 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
58353 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
58354 }
58355 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
58356 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
58357 }
58358 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
58359 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
58360 }
58361 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
58362 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
58363 }
58364 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
58365 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
58366 }
58367 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
58368 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
58369 }
58370 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
58371 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
58372 }
58373 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
58374 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
58375 }
58376 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
58377 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
58378 }
58379 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
58380 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
58381 }
58382 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
58383 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
58384 }
58385 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
58386 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
58387 }
58388 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
58389 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58390 }
58391 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
58392 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58393 }
58394 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
58395 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
58396 }
58397 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
58398 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
58399 }
58400 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
58401 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
58402 }
58403 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
58404 return (void *)((wxObject *) ((wxImageHandler *) x));
58405 }
58406 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
58407 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
58408 }
58409 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
58410 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
58411 }
58412 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
58413 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
58414 }
58415 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
58416 return (void *)((wxObject *) ((wxEvtHandler *) x));
58417 }
58418 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
58419 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
58420 }
58421 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
58422 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
58423 }
58424 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
58425 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58426 }
58427 static void *_p_wxImageTo_p_wxObject(void *x) {
58428 return (void *)((wxObject *) ((wxImage *) x));
58429 }
58430 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
58431 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
58432 }
58433 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
58434 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58435 }
58436 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
58437 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
58438 }
58439 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
58440 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
58441 }
58442 static void *_p_wxWindowTo_p_wxObject(void *x) {
58443 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
58444 }
58445 static void *_p_wxMenuTo_p_wxObject(void *x) {
58446 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
58447 }
58448 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
58449 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
58450 }
58451 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
58452 return (void *)((wxObject *) ((wxFileSystem *) x));
58453 }
58454 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
58455 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
58456 }
58457 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
58458 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
58459 }
58460 static void *_p_wxPyAppTo_p_wxObject(void *x) {
58461 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
58462 }
58463 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
58464 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
58465 }
58466 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
58467 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
58468 }
58469 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
58470 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
58471 }
58472 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
58473 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
58474 }
58475 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
58476 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
58477 }
58478 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
58479 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
58480 }
58481 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
58482 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
58483 }
58484 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
58485 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
58486 }
58487 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
58488 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58489 }
58490 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
58491 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
58492 }
58493 static void *_p_wxValidatorTo_p_wxObject(void *x) {
58494 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
58495 }
58496 static void *_p_wxControlTo_p_wxWindow(void *x) {
58497 return (void *)((wxWindow *) ((wxControl *) x));
58498 }
58499 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
58500 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
58501 }
58502 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
58503 return (void *)((wxWindow *) ((wxMenuBar *) x));
58504 }
58505 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
58506 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
58507 }
58508 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
58509 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
58510 }
58511 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
58512 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
58513 }
58514 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
58515 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
58516 }
58517 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
58518 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
58519 }
58520 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
58521 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
58522 }
58523 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
58524 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58525 }
58526 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
58527 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
58528 }
58529 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
58530 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
58531 }
58532 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
58533 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
58534 }
58535 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
58536 return (void *)((wxValidator *) ((wxPyValidator *) x));
58537 }
58538 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
58539 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
58540 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};
58541 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
58542 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
58543 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
58544 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
58545 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
58546 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
58547 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
58548 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
58549 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
58550 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
58551 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
58552 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
58553 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
58554 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
58555 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
58556 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
58557 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
58558 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
58559 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
58560 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
58561 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
58562 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
58563 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
58564 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
58565 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
58566 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
58567 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
58568 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
58569 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
58570 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
58571 static swig_type_info _swigt__p_wxDouble = {"_p_wxDouble", "wxDouble *", 0, 0, (void*)0, 0};
58572 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
58573 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
58574 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
58575 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
58576 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
58577 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
58578 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
58579 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
58580 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
58581 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
58582 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
58583 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
58584 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
58585 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
58586 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
58587 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
58588 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
58589 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
58590 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
58591 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
58592 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
58593 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
58594 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
58595 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
58596 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
58597 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
58598 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
58599 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
58600 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
58601 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
58602 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
58603 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
58604 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
58605 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
58606 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
58607 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
58608 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
58609 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
58610 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
58611 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
58612 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
58613 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
58614 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
58615 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
58616 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
58617 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
58618 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
58619 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
58620 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
58621 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
58622 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
58623 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
58624 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
58625 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
58626 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
58627 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
58628 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
58629 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
58630 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
58631 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
58632 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
58633 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
58634 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
58635 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
58636 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
58637 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
58638 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
58639 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
58640 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
58641 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
58642 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
58643 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
58644 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
58645 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
58646 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
58647 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
58648 static swig_type_info _swigt__p_wxRect2D = {"_p_wxRect2D", "wxRect2D *", 0, 0, (void*)0, 0};
58649 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
58650 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
58651 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
58652 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
58653 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
58654 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
58655 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
58656 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
58657 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
58658 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
58659 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
58660 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
58661 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
58662 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", "wxTGAHandler *", 0, 0, (void*)0, 0};
58663 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
58664 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
58665 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
58666 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
58667 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
58668 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
58669 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
58670 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
58671 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
58672 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
58673
58674 static swig_type_info *swig_type_initial[] = {
58675 &_swigt__p_buffer,
58676 &_swigt__p_char,
58677 &_swigt__p_form_ops_t,
58678 &_swigt__p_int,
58679 &_swigt__p_long,
58680 &_swigt__p_unsigned_char,
58681 &_swigt__p_unsigned_int,
58682 &_swigt__p_unsigned_long,
58683 &_swigt__p_wxANIHandler,
58684 &_swigt__p_wxAcceleratorEntry,
58685 &_swigt__p_wxAcceleratorTable,
58686 &_swigt__p_wxActivateEvent,
58687 &_swigt__p_wxAppTraits,
58688 &_swigt__p_wxArrayString,
58689 &_swigt__p_wxBMPHandler,
58690 &_swigt__p_wxBitmap,
58691 &_swigt__p_wxBoxSizer,
58692 &_swigt__p_wxButton,
58693 &_swigt__p_wxCURHandler,
58694 &_swigt__p_wxCaret,
58695 &_swigt__p_wxChildFocusEvent,
58696 &_swigt__p_wxClipboardTextEvent,
58697 &_swigt__p_wxCloseEvent,
58698 &_swigt__p_wxColour,
58699 &_swigt__p_wxCommandEvent,
58700 &_swigt__p_wxContextMenuEvent,
58701 &_swigt__p_wxControl,
58702 &_swigt__p_wxControlWithItems,
58703 &_swigt__p_wxCursor,
58704 &_swigt__p_wxDC,
58705 &_swigt__p_wxDateEvent,
58706 &_swigt__p_wxDateTime,
58707 &_swigt__p_wxDisplayChangedEvent,
58708 &_swigt__p_wxDouble,
58709 &_swigt__p_wxDropFilesEvent,
58710 &_swigt__p_wxDuplexMode,
58711 &_swigt__p_wxEraseEvent,
58712 &_swigt__p_wxEvent,
58713 &_swigt__p_wxEventLoop,
58714 &_swigt__p_wxEventLoopActivator,
58715 &_swigt__p_wxEvtHandler,
58716 &_swigt__p_wxFSFile,
58717 &_swigt__p_wxFileSystem,
58718 &_swigt__p_wxFileSystemHandler,
58719 &_swigt__p_wxFlexGridSizer,
58720 &_swigt__p_wxFocusEvent,
58721 &_swigt__p_wxFont,
58722 &_swigt__p_wxFrame,
58723 &_swigt__p_wxGBPosition,
58724 &_swigt__p_wxGBSizerItem,
58725 &_swigt__p_wxGBSpan,
58726 &_swigt__p_wxGIFHandler,
58727 &_swigt__p_wxGridBagSizer,
58728 &_swigt__p_wxGridSizer,
58729 &_swigt__p_wxHelpEvent__Origin,
58730 &_swigt__p_wxICOHandler,
58731 &_swigt__p_wxIconizeEvent,
58732 &_swigt__p_wxIdleEvent,
58733 &_swigt__p_wxImage,
58734 &_swigt__p_wxImageHandler,
58735 &_swigt__p_wxImageHistogram,
58736 &_swigt__p_wxImage_HSVValue,
58737 &_swigt__p_wxImage_RGBValue,
58738 &_swigt__p_wxIndividualLayoutConstraint,
58739 &_swigt__p_wxInitDialogEvent,
58740 &_swigt__p_wxInputStream,
58741 &_swigt__p_wxInternetFSHandler,
58742 &_swigt__p_wxItemContainer,
58743 &_swigt__p_wxJPEGHandler,
58744 &_swigt__p_wxKeyEvent,
58745 &_swigt__p_wxLayoutConstraints,
58746 &_swigt__p_wxMaximizeEvent,
58747 &_swigt__p_wxMemoryFSHandler,
58748 &_swigt__p_wxMenu,
58749 &_swigt__p_wxMenuBar,
58750 &_swigt__p_wxMenuBarBase,
58751 &_swigt__p_wxMenuEvent,
58752 &_swigt__p_wxMenuItem,
58753 &_swigt__p_wxMouseCaptureChangedEvent,
58754 &_swigt__p_wxMouseCaptureLostEvent,
58755 &_swigt__p_wxMouseEvent,
58756 &_swigt__p_wxMoveEvent,
58757 &_swigt__p_wxNavigationKeyEvent,
58758 &_swigt__p_wxNcPaintEvent,
58759 &_swigt__p_wxNotifyEvent,
58760 &_swigt__p_wxObject,
58761 &_swigt__p_wxOutputStream,
58762 &_swigt__p_wxPCXHandler,
58763 &_swigt__p_wxPNGHandler,
58764 &_swigt__p_wxPNMHandler,
58765 &_swigt__p_wxPaintEvent,
58766 &_swigt__p_wxPaletteChangedEvent,
58767 &_swigt__p_wxPaperSize,
58768 &_swigt__p_wxPoint,
58769 &_swigt__p_wxPoint2D,
58770 &_swigt__p_wxPropagateOnce,
58771 &_swigt__p_wxPropagationDisabler,
58772 &_swigt__p_wxPyApp,
58773 &_swigt__p_wxPyCommandEvent,
58774 &_swigt__p_wxPyDropTarget,
58775 &_swigt__p_wxPyEvent,
58776 &_swigt__p_wxPyFileSystemHandler,
58777 &_swigt__p_wxPyImageHandler,
58778 &_swigt__p_wxPyInputStream,
58779 &_swigt__p_wxPySizer,
58780 &_swigt__p_wxPyValidator,
58781 &_swigt__p_wxQuantize,
58782 &_swigt__p_wxQueryNewPaletteEvent,
58783 &_swigt__p_wxRealPoint,
58784 &_swigt__p_wxRect,
58785 &_swigt__p_wxRect2D,
58786 &_swigt__p_wxRegion,
58787 &_swigt__p_wxScrollEvent,
58788 &_swigt__p_wxScrollWinEvent,
58789 &_swigt__p_wxSetCursorEvent,
58790 &_swigt__p_wxShowEvent,
58791 &_swigt__p_wxSize,
58792 &_swigt__p_wxSizeEvent,
58793 &_swigt__p_wxSizer,
58794 &_swigt__p_wxSizerItem,
58795 &_swigt__p_wxStaticBox,
58796 &_swigt__p_wxStaticBoxSizer,
58797 &_swigt__p_wxStdDialogButtonSizer,
58798 &_swigt__p_wxSysColourChangedEvent,
58799 &_swigt__p_wxTGAHandler,
58800 &_swigt__p_wxTIFFHandler,
58801 &_swigt__p_wxToolTip,
58802 &_swigt__p_wxUpdateUIEvent,
58803 &_swigt__p_wxValidator,
58804 &_swigt__p_wxVisualAttributes,
58805 &_swigt__p_wxWindow,
58806 &_swigt__p_wxWindowCreateEvent,
58807 &_swigt__p_wxWindowDestroyEvent,
58808 &_swigt__p_wxXPMHandler,
58809 &_swigt__p_wxZipFSHandler,
58810 };
58811
58812 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
58813 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
58814 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
58815 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
58816 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
58817 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
58818 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
58819 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
58820 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
58821 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
58822 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
58823 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
58824 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
58825 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
58826 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}};
58827 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
58828 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}};
58829 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
58830 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}};
58831 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
58832 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
58833 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
58834 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
58835 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
58836 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}};
58837 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
58838 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}};
58839 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
58840 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
58841 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
58842 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
58843 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
58844 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58845 static swig_cast_info _swigc__p_wxDouble[] = { {&_swigt__p_wxDouble, 0, 0, 0},{0, 0, 0, 0}};
58846 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
58847 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
58848 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
58849 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}};
58850 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
58851 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
58852 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}};
58853 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
58854 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
58855 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}};
58856 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}};
58857 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
58858 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
58859 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
58860 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
58861 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
58862 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
58863 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
58864 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
58865 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}};
58866 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
58867 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}};
58868 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58869 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
58870 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
58871 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}};
58872 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
58873 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
58874 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
58875 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
58876 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
58877 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
58878 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58879 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}};
58880 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
58881 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
58882 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
58883 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58884 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58885 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
58886 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
58887 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
58888 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
58889 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
58890 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58891 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
58892 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
58893 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
58894 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
58895 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
58896 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
58897 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}};
58898 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
58899 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
58900 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
58901 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
58902 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
58903 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58904 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
58905 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
58906 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
58907 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
58908 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
58909 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
58910 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
58911 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
58912 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
58913 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
58914 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
58915 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
58916 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
58917 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
58918 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
58919 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
58920 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
58921 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
58922 static swig_cast_info _swigc__p_wxRect2D[] = { {&_swigt__p_wxRect2D, 0, 0, 0},{0, 0, 0, 0}};
58923 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
58924 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
58925 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
58926 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
58927 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
58928 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
58929 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58930 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}};
58931 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}};
58932 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
58933 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
58934 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
58935 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58936 static swig_cast_info _swigc__p_wxTGAHandler[] = { {&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
58937 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
58938 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
58939 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
58940 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}};
58941 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
58942 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}};
58943 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
58944 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
58945 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
58946 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58947
58948 static swig_cast_info *swig_cast_initial[] = {
58949 _swigc__p_buffer,
58950 _swigc__p_char,
58951 _swigc__p_form_ops_t,
58952 _swigc__p_int,
58953 _swigc__p_long,
58954 _swigc__p_unsigned_char,
58955 _swigc__p_unsigned_int,
58956 _swigc__p_unsigned_long,
58957 _swigc__p_wxANIHandler,
58958 _swigc__p_wxAcceleratorEntry,
58959 _swigc__p_wxAcceleratorTable,
58960 _swigc__p_wxActivateEvent,
58961 _swigc__p_wxAppTraits,
58962 _swigc__p_wxArrayString,
58963 _swigc__p_wxBMPHandler,
58964 _swigc__p_wxBitmap,
58965 _swigc__p_wxBoxSizer,
58966 _swigc__p_wxButton,
58967 _swigc__p_wxCURHandler,
58968 _swigc__p_wxCaret,
58969 _swigc__p_wxChildFocusEvent,
58970 _swigc__p_wxClipboardTextEvent,
58971 _swigc__p_wxCloseEvent,
58972 _swigc__p_wxColour,
58973 _swigc__p_wxCommandEvent,
58974 _swigc__p_wxContextMenuEvent,
58975 _swigc__p_wxControl,
58976 _swigc__p_wxControlWithItems,
58977 _swigc__p_wxCursor,
58978 _swigc__p_wxDC,
58979 _swigc__p_wxDateEvent,
58980 _swigc__p_wxDateTime,
58981 _swigc__p_wxDisplayChangedEvent,
58982 _swigc__p_wxDouble,
58983 _swigc__p_wxDropFilesEvent,
58984 _swigc__p_wxDuplexMode,
58985 _swigc__p_wxEraseEvent,
58986 _swigc__p_wxEvent,
58987 _swigc__p_wxEventLoop,
58988 _swigc__p_wxEventLoopActivator,
58989 _swigc__p_wxEvtHandler,
58990 _swigc__p_wxFSFile,
58991 _swigc__p_wxFileSystem,
58992 _swigc__p_wxFileSystemHandler,
58993 _swigc__p_wxFlexGridSizer,
58994 _swigc__p_wxFocusEvent,
58995 _swigc__p_wxFont,
58996 _swigc__p_wxFrame,
58997 _swigc__p_wxGBPosition,
58998 _swigc__p_wxGBSizerItem,
58999 _swigc__p_wxGBSpan,
59000 _swigc__p_wxGIFHandler,
59001 _swigc__p_wxGridBagSizer,
59002 _swigc__p_wxGridSizer,
59003 _swigc__p_wxHelpEvent__Origin,
59004 _swigc__p_wxICOHandler,
59005 _swigc__p_wxIconizeEvent,
59006 _swigc__p_wxIdleEvent,
59007 _swigc__p_wxImage,
59008 _swigc__p_wxImageHandler,
59009 _swigc__p_wxImageHistogram,
59010 _swigc__p_wxImage_HSVValue,
59011 _swigc__p_wxImage_RGBValue,
59012 _swigc__p_wxIndividualLayoutConstraint,
59013 _swigc__p_wxInitDialogEvent,
59014 _swigc__p_wxInputStream,
59015 _swigc__p_wxInternetFSHandler,
59016 _swigc__p_wxItemContainer,
59017 _swigc__p_wxJPEGHandler,
59018 _swigc__p_wxKeyEvent,
59019 _swigc__p_wxLayoutConstraints,
59020 _swigc__p_wxMaximizeEvent,
59021 _swigc__p_wxMemoryFSHandler,
59022 _swigc__p_wxMenu,
59023 _swigc__p_wxMenuBar,
59024 _swigc__p_wxMenuBarBase,
59025 _swigc__p_wxMenuEvent,
59026 _swigc__p_wxMenuItem,
59027 _swigc__p_wxMouseCaptureChangedEvent,
59028 _swigc__p_wxMouseCaptureLostEvent,
59029 _swigc__p_wxMouseEvent,
59030 _swigc__p_wxMoveEvent,
59031 _swigc__p_wxNavigationKeyEvent,
59032 _swigc__p_wxNcPaintEvent,
59033 _swigc__p_wxNotifyEvent,
59034 _swigc__p_wxObject,
59035 _swigc__p_wxOutputStream,
59036 _swigc__p_wxPCXHandler,
59037 _swigc__p_wxPNGHandler,
59038 _swigc__p_wxPNMHandler,
59039 _swigc__p_wxPaintEvent,
59040 _swigc__p_wxPaletteChangedEvent,
59041 _swigc__p_wxPaperSize,
59042 _swigc__p_wxPoint,
59043 _swigc__p_wxPoint2D,
59044 _swigc__p_wxPropagateOnce,
59045 _swigc__p_wxPropagationDisabler,
59046 _swigc__p_wxPyApp,
59047 _swigc__p_wxPyCommandEvent,
59048 _swigc__p_wxPyDropTarget,
59049 _swigc__p_wxPyEvent,
59050 _swigc__p_wxPyFileSystemHandler,
59051 _swigc__p_wxPyImageHandler,
59052 _swigc__p_wxPyInputStream,
59053 _swigc__p_wxPySizer,
59054 _swigc__p_wxPyValidator,
59055 _swigc__p_wxQuantize,
59056 _swigc__p_wxQueryNewPaletteEvent,
59057 _swigc__p_wxRealPoint,
59058 _swigc__p_wxRect,
59059 _swigc__p_wxRect2D,
59060 _swigc__p_wxRegion,
59061 _swigc__p_wxScrollEvent,
59062 _swigc__p_wxScrollWinEvent,
59063 _swigc__p_wxSetCursorEvent,
59064 _swigc__p_wxShowEvent,
59065 _swigc__p_wxSize,
59066 _swigc__p_wxSizeEvent,
59067 _swigc__p_wxSizer,
59068 _swigc__p_wxSizerItem,
59069 _swigc__p_wxStaticBox,
59070 _swigc__p_wxStaticBoxSizer,
59071 _swigc__p_wxStdDialogButtonSizer,
59072 _swigc__p_wxSysColourChangedEvent,
59073 _swigc__p_wxTGAHandler,
59074 _swigc__p_wxTIFFHandler,
59075 _swigc__p_wxToolTip,
59076 _swigc__p_wxUpdateUIEvent,
59077 _swigc__p_wxValidator,
59078 _swigc__p_wxVisualAttributes,
59079 _swigc__p_wxWindow,
59080 _swigc__p_wxWindowCreateEvent,
59081 _swigc__p_wxWindowDestroyEvent,
59082 _swigc__p_wxXPMHandler,
59083 _swigc__p_wxZipFSHandler,
59084 };
59085
59086
59087 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
59088
59089 static swig_const_info swig_const_table[] = {
59090 {0, 0, 0, 0.0, 0, 0}};
59091
59092 #ifdef __cplusplus
59093 }
59094 #endif
59095 /* -----------------------------------------------------------------------------
59096 * Type initialization:
59097 * This problem is tough by the requirement that no dynamic
59098 * memory is used. Also, since swig_type_info structures store pointers to
59099 * swig_cast_info structures and swig_cast_info structures store pointers back
59100 * to swig_type_info structures, we need some lookup code at initialization.
59101 * The idea is that swig generates all the structures that are needed.
59102 * The runtime then collects these partially filled structures.
59103 * The SWIG_InitializeModule function takes these initial arrays out of
59104 * swig_module, and does all the lookup, filling in the swig_module.types
59105 * array with the correct data and linking the correct swig_cast_info
59106 * structures together.
59107 *
59108 * The generated swig_type_info structures are assigned staticly to an initial
59109 * array. We just loop though that array, and handle each type individually.
59110 * First we lookup if this type has been already loaded, and if so, use the
59111 * loaded structure instead of the generated one. Then we have to fill in the
59112 * cast linked list. The cast data is initially stored in something like a
59113 * two-dimensional array. Each row corresponds to a type (there are the same
59114 * number of rows as there are in the swig_type_initial array). Each entry in
59115 * a column is one of the swig_cast_info structures for that type.
59116 * The cast_initial array is actually an array of arrays, because each row has
59117 * a variable number of columns. So to actually build the cast linked list,
59118 * we find the array of casts associated with the type, and loop through it
59119 * adding the casts to the list. The one last trick we need to do is making
59120 * sure the type pointer in the swig_cast_info struct is correct.
59121 *
59122 * First off, we lookup the cast->type name to see if it is already loaded.
59123 * There are three cases to handle:
59124 * 1) If the cast->type has already been loaded AND the type we are adding
59125 * casting info to has not been loaded (it is in this module), THEN we
59126 * replace the cast->type pointer with the type pointer that has already
59127 * been loaded.
59128 * 2) If BOTH types (the one we are adding casting info to, and the
59129 * cast->type) are loaded, THEN the cast info has already been loaded by
59130 * the previous module so we just ignore it.
59131 * 3) Finally, if cast->type has not already been loaded, then we add that
59132 * swig_cast_info to the linked list (because the cast->type) pointer will
59133 * be correct.
59134 * ----------------------------------------------------------------------------- */
59135
59136 #ifdef __cplusplus
59137 extern "C" {
59138 #if 0
59139 } /* c-mode */
59140 #endif
59141 #endif
59142
59143 #if 0
59144 #define SWIGRUNTIME_DEBUG
59145 #endif
59146
59147 SWIGRUNTIME void
59148 SWIG_InitializeModule(void *clientdata) {
59149 size_t i;
59150 swig_module_info *module_head;
59151 static int init_run = 0;
59152
59153 clientdata = clientdata;
59154
59155 if (init_run) return;
59156 init_run = 1;
59157
59158 /* Initialize the swig_module */
59159 swig_module.type_initial = swig_type_initial;
59160 swig_module.cast_initial = swig_cast_initial;
59161
59162 /* Try and load any already created modules */
59163 module_head = SWIG_GetModule(clientdata);
59164 if (module_head) {
59165 swig_module.next = module_head->next;
59166 module_head->next = &swig_module;
59167 } else {
59168 /* This is the first module loaded */
59169 swig_module.next = &swig_module;
59170 SWIG_SetModule(clientdata, &swig_module);
59171 }
59172
59173 /* Now work on filling in swig_module.types */
59174 #ifdef SWIGRUNTIME_DEBUG
59175 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
59176 #endif
59177 for (i = 0; i < swig_module.size; ++i) {
59178 swig_type_info *type = 0;
59179 swig_type_info *ret;
59180 swig_cast_info *cast;
59181
59182 #ifdef SWIGRUNTIME_DEBUG
59183 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59184 #endif
59185
59186 /* if there is another module already loaded */
59187 if (swig_module.next != &swig_module) {
59188 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
59189 }
59190 if (type) {
59191 /* Overwrite clientdata field */
59192 #ifdef SWIGRUNTIME_DEBUG
59193 printf("SWIG_InitializeModule: found type %s\n", type->name);
59194 #endif
59195 if (swig_module.type_initial[i]->clientdata) {
59196 type->clientdata = swig_module.type_initial[i]->clientdata;
59197 #ifdef SWIGRUNTIME_DEBUG
59198 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
59199 #endif
59200 }
59201 } else {
59202 type = swig_module.type_initial[i];
59203 }
59204
59205 /* Insert casting types */
59206 cast = swig_module.cast_initial[i];
59207 while (cast->type) {
59208 /* Don't need to add information already in the list */
59209 ret = 0;
59210 #ifdef SWIGRUNTIME_DEBUG
59211 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
59212 #endif
59213 if (swig_module.next != &swig_module) {
59214 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
59215 #ifdef SWIGRUNTIME_DEBUG
59216 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
59217 #endif
59218 }
59219 if (ret) {
59220 if (type == swig_module.type_initial[i]) {
59221 #ifdef SWIGRUNTIME_DEBUG
59222 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
59223 #endif
59224 cast->type = ret;
59225 ret = 0;
59226 } else {
59227 /* Check for casting already in the list */
59228 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
59229 #ifdef SWIGRUNTIME_DEBUG
59230 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
59231 #endif
59232 if (!ocast) ret = 0;
59233 }
59234 }
59235
59236 if (!ret) {
59237 #ifdef SWIGRUNTIME_DEBUG
59238 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
59239 #endif
59240 if (type->cast) {
59241 type->cast->prev = cast;
59242 cast->next = type->cast;
59243 }
59244 type->cast = cast;
59245 }
59246 cast++;
59247 }
59248 /* Set entry in modules->types array equal to the type */
59249 swig_module.types[i] = type;
59250 }
59251 swig_module.types[i] = 0;
59252
59253 #ifdef SWIGRUNTIME_DEBUG
59254 printf("**** SWIG_InitializeModule: Cast List ******\n");
59255 for (i = 0; i < swig_module.size; ++i) {
59256 int j = 0;
59257 swig_cast_info *cast = swig_module.cast_initial[i];
59258 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59259 while (cast->type) {
59260 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
59261 cast++;
59262 ++j;
59263 }
59264 printf("---- Total casts: %d\n",j);
59265 }
59266 printf("**** SWIG_InitializeModule: Cast List ******\n");
59267 #endif
59268 }
59269
59270 /* This function will propagate the clientdata field of type to
59271 * any new swig_type_info structures that have been added into the list
59272 * of equivalent types. It is like calling
59273 * SWIG_TypeClientData(type, clientdata) a second time.
59274 */
59275 SWIGRUNTIME void
59276 SWIG_PropagateClientData(void) {
59277 size_t i;
59278 swig_cast_info *equiv;
59279 static int init_run = 0;
59280
59281 if (init_run) return;
59282 init_run = 1;
59283
59284 for (i = 0; i < swig_module.size; i++) {
59285 if (swig_module.types[i]->clientdata) {
59286 equiv = swig_module.types[i]->cast;
59287 while (equiv) {
59288 if (!equiv->converter) {
59289 if (equiv->type && !equiv->type->clientdata)
59290 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
59291 }
59292 equiv = equiv->next;
59293 }
59294 }
59295 }
59296 }
59297
59298 #ifdef __cplusplus
59299 #if 0
59300 {
59301 /* c-mode */
59302 #endif
59303 }
59304 #endif
59305
59306
59307
59308 #ifdef __cplusplus
59309 extern "C" {
59310 #endif
59311
59312 /* Python-specific SWIG API */
59313 #define SWIG_newvarlink() SWIG_Python_newvarlink()
59314 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
59315 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
59316
59317 /* -----------------------------------------------------------------------------
59318 * global variable support code.
59319 * ----------------------------------------------------------------------------- */
59320
59321 typedef struct swig_globalvar {
59322 char *name; /* Name of global variable */
59323 PyObject *(*get_attr)(void); /* Return the current value */
59324 int (*set_attr)(PyObject *); /* Set the value */
59325 struct swig_globalvar *next;
59326 } swig_globalvar;
59327
59328 typedef struct swig_varlinkobject {
59329 PyObject_HEAD
59330 swig_globalvar *vars;
59331 } swig_varlinkobject;
59332
59333 SWIGINTERN PyObject *
59334 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
59335 return PyString_FromString("<Swig global variables>");
59336 }
59337
59338 SWIGINTERN PyObject *
59339 swig_varlink_str(swig_varlinkobject *v) {
59340 PyObject *str = PyString_FromString("(");
59341 swig_globalvar *var;
59342 for (var = v->vars; var; var=var->next) {
59343 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
59344 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
59345 }
59346 PyString_ConcatAndDel(&str,PyString_FromString(")"));
59347 return str;
59348 }
59349
59350 SWIGINTERN int
59351 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
59352 PyObject *str = swig_varlink_str(v);
59353 fprintf(fp,"Swig global variables ");
59354 fprintf(fp,"%s\n", PyString_AsString(str));
59355 Py_DECREF(str);
59356 return 0;
59357 }
59358
59359 SWIGINTERN void
59360 swig_varlink_dealloc(swig_varlinkobject *v) {
59361 swig_globalvar *var = v->vars;
59362 while (var) {
59363 swig_globalvar *n = var->next;
59364 free(var->name);
59365 free(var);
59366 var = n;
59367 }
59368 }
59369
59370 SWIGINTERN PyObject *
59371 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
59372 PyObject *res = NULL;
59373 swig_globalvar *var = v->vars;
59374 while (var) {
59375 if (strcmp(var->name,n) == 0) {
59376 res = (*var->get_attr)();
59377 break;
59378 }
59379 var = var->next;
59380 }
59381 if (res == NULL && !PyErr_Occurred()) {
59382 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
59383 }
59384 return res;
59385 }
59386
59387 SWIGINTERN int
59388 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
59389 int res = 1;
59390 swig_globalvar *var = v->vars;
59391 while (var) {
59392 if (strcmp(var->name,n) == 0) {
59393 res = (*var->set_attr)(p);
59394 break;
59395 }
59396 var = var->next;
59397 }
59398 if (res == 1 && !PyErr_Occurred()) {
59399 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
59400 }
59401 return res;
59402 }
59403
59404 SWIGINTERN PyTypeObject*
59405 swig_varlink_type(void) {
59406 static char varlink__doc__[] = "Swig var link object";
59407 static PyTypeObject varlink_type;
59408 static int type_init = 0;
59409 if (!type_init) {
59410 const PyTypeObject tmp
59411 = {
59412 PyObject_HEAD_INIT(NULL)
59413 0, /* Number of items in variable part (ob_size) */
59414 (char *)"swigvarlink", /* Type name (tp_name) */
59415 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
59416 0, /* Itemsize (tp_itemsize) */
59417 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
59418 (printfunc) swig_varlink_print, /* Print (tp_print) */
59419 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
59420 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
59421 0, /* tp_compare */
59422 (reprfunc) swig_varlink_repr, /* tp_repr */
59423 0, /* tp_as_number */
59424 0, /* tp_as_sequence */
59425 0, /* tp_as_mapping */
59426 0, /* tp_hash */
59427 0, /* tp_call */
59428 (reprfunc)swig_varlink_str, /* tp_str */
59429 0, /* tp_getattro */
59430 0, /* tp_setattro */
59431 0, /* tp_as_buffer */
59432 0, /* tp_flags */
59433 varlink__doc__, /* tp_doc */
59434 0, /* tp_traverse */
59435 0, /* tp_clear */
59436 0, /* tp_richcompare */
59437 0, /* tp_weaklistoffset */
59438 #if PY_VERSION_HEX >= 0x02020000
59439 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
59440 #endif
59441 #if PY_VERSION_HEX >= 0x02030000
59442 0, /* tp_del */
59443 #endif
59444 #ifdef COUNT_ALLOCS
59445 0,0,0,0 /* tp_alloc -> tp_next */
59446 #endif
59447 };
59448 varlink_type = tmp;
59449 varlink_type.ob_type = &PyType_Type;
59450 type_init = 1;
59451 }
59452 return &varlink_type;
59453 }
59454
59455 /* Create a variable linking object for use later */
59456 SWIGINTERN PyObject *
59457 SWIG_Python_newvarlink(void) {
59458 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
59459 if (result) {
59460 result->vars = 0;
59461 }
59462 return ((PyObject*) result);
59463 }
59464
59465 SWIGINTERN void
59466 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
59467 swig_varlinkobject *v = (swig_varlinkobject *) p;
59468 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
59469 if (gv) {
59470 size_t size = strlen(name)+1;
59471 gv->name = (char *)malloc(size);
59472 if (gv->name) {
59473 strncpy(gv->name,name,size);
59474 gv->get_attr = get_attr;
59475 gv->set_attr = set_attr;
59476 gv->next = v->vars;
59477 }
59478 }
59479 v->vars = gv;
59480 }
59481
59482 SWIGINTERN PyObject *
59483 SWIG_globals() {
59484 static PyObject *_SWIG_globals = 0;
59485 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
59486 return _SWIG_globals;
59487 }
59488
59489 /* -----------------------------------------------------------------------------
59490 * constants/methods manipulation
59491 * ----------------------------------------------------------------------------- */
59492
59493 /* Install Constants */
59494 SWIGINTERN void
59495 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
59496 PyObject *obj = 0;
59497 size_t i;
59498 for (i = 0; constants[i].type; ++i) {
59499 switch(constants[i].type) {
59500 case SWIG_PY_POINTER:
59501 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
59502 break;
59503 case SWIG_PY_BINARY:
59504 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
59505 break;
59506 default:
59507 obj = 0;
59508 break;
59509 }
59510 if (obj) {
59511 PyDict_SetItemString(d, constants[i].name, obj);
59512 Py_DECREF(obj);
59513 }
59514 }
59515 }
59516
59517 /* -----------------------------------------------------------------------------*/
59518 /* Fix SwigMethods to carry the callback ptrs when needed */
59519 /* -----------------------------------------------------------------------------*/
59520
59521 SWIGINTERN void
59522 SWIG_Python_FixMethods(PyMethodDef *methods,
59523 swig_const_info *const_table,
59524 swig_type_info **types,
59525 swig_type_info **types_initial) {
59526 size_t i;
59527 for (i = 0; methods[i].ml_name; ++i) {
59528 const char *c = methods[i].ml_doc;
59529 if (c && (c = strstr(c, "swig_ptr: "))) {
59530 int j;
59531 swig_const_info *ci = 0;
59532 const char *name = c + 10;
59533 for (j = 0; const_table[j].type; ++j) {
59534 if (strncmp(const_table[j].name, name,
59535 strlen(const_table[j].name)) == 0) {
59536 ci = &(const_table[j]);
59537 break;
59538 }
59539 }
59540 if (ci) {
59541 size_t shift = (ci->ptype) - types;
59542 swig_type_info *ty = types_initial[shift];
59543 size_t ldoc = (c - methods[i].ml_doc);
59544 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
59545 char *ndoc = (char*)malloc(ldoc + lptr + 10);
59546 if (ndoc) {
59547 char *buff = ndoc;
59548 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
59549 if (ptr) {
59550 strncpy(buff, methods[i].ml_doc, ldoc);
59551 buff += ldoc;
59552 strncpy(buff, "swig_ptr: ", 10);
59553 buff += 10;
59554 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
59555 methods[i].ml_doc = ndoc;
59556 }
59557 }
59558 }
59559 }
59560 }
59561 }
59562
59563 #ifdef __cplusplus
59564 }
59565 #endif
59566
59567 /* -----------------------------------------------------------------------------*
59568 * Partial Init method
59569 * -----------------------------------------------------------------------------*/
59570
59571 #ifdef __cplusplus
59572 extern "C"
59573 #endif
59574 SWIGEXPORT void SWIG_init(void) {
59575 PyObject *m, *d;
59576
59577 /* Fix SwigMethods to carry the callback ptrs when needed */
59578 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
59579
59580 m = Py_InitModule((char *) SWIG_name, SwigMethods);
59581 d = PyModule_GetDict(m);
59582
59583 SWIG_InitializeModule(0);
59584 SWIG_InstallConstants(d,swig_const_table);
59585
59586
59587
59588 #ifndef wxPyUSE_EXPORT
59589 // Make our API structure a CObject so other modules can import it
59590 // from this module.
59591 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
59592 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
59593 Py_XDECREF(cobj);
59594 #endif
59595
59596 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
59597 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
59598 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
59599 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
59600 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
59601 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
59602 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
59603 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
59604 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
59605 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
59606 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
59607 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
59608 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
59609 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
59610 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
59611 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
59612 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
59613 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
59614 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
59615 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
59616 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
59617 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
59618 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
59619 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
59620 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
59621 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
59622 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
59623 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
59624 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
59625 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
59626 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
59627 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
59628 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
59629 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
59630 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
59631 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
59632 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
59633 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
59634 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
59635 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
59636 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
59637 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
59638 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
59639 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
59640 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
59641 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
59642 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
59643 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
59644 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
59645 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
59646 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
59647 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
59648 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
59649 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
59650 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
59651 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
59652 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
59653 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
59654 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
59655 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
59656 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
59657 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
59658 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
59659 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
59660 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
59661 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
59662 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
59663 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
59664 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
59665 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
59666 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
59667 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
59668 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
59669 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
59670 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
59671 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
59672 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
59673 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
59674 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
59675 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
59676 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
59677 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
59678 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
59679 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
59680 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
59681 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
59682 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
59683 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
59684 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
59685 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
59686 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
59687 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
59688 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
59689 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
59690 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
59691 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
59692 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
59693 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
59694 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
59695 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
59696 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
59697 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
59698 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
59699 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
59700 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
59701 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
59702 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
59703 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
59704 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
59705 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
59706 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
59707 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
59708 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
59709 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
59710 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
59711 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
59712 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
59713 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
59714 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
59715 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
59716 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
59717 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
59718 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
59719 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
59720 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
59721 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
59722 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
59723 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
59724 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
59725 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
59726 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
59727 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
59728 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
59729 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
59730 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
59731 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
59732 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
59733 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
59734 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
59735 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
59736 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
59737 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
59738 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
59739 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
59740 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
59741 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
59742 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
59743 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
59744 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
59745 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
59746 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
59747 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
59748 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
59749 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
59750 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
59751 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
59752 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
59753 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
59754 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
59755 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
59756 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
59757 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
59758 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
59759 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
59760 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
59761 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
59762 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
59763 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
59764 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
59765 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
59766 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
59767 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
59768 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
59769 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
59770 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
59771 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
59772 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
59773 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
59774 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
59775 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
59776 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
59777 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
59778 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
59779 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
59780 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
59781 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
59782 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
59783 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
59784 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
59785 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
59786 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
59787 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
59788 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
59789 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
59790 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
59791 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
59792 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
59793 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
59794 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
59795 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
59796 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
59797 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
59798 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
59799 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
59800 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
59801 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
59802 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
59803 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
59804 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
59805 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
59806 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
59807 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
59808 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
59809 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
59810 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
59811 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
59812 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
59813 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
59814 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
59815 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
59816 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
59817 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
59818 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
59819 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
59820 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
59821 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
59822 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
59823 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
59824 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
59825 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
59826 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
59827 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
59828 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
59829 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
59830 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
59831 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
59832 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
59833 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
59834 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
59835 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
59836 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
59837 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
59838 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
59839 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
59840 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
59841 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
59842 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
59843 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
59844 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
59845 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
59846 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
59847 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
59848 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
59849 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
59850 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
59851 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
59852 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
59853 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
59854 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
59855 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
59856 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
59857 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
59858 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
59859 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
59860 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
59861 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
59862 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
59863 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
59864 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
59865 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
59866 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
59867 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
59868 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
59869 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
59870 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
59871 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
59872 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
59873 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
59874 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
59875 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
59876 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
59877 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
59878 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
59879 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
59880 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
59881 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
59882 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
59883 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
59884 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
59885 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
59886 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
59887 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
59888 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
59889 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
59890 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
59891 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
59892 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
59893 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
59894 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
59895 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
59896 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
59897 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
59898 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
59899 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
59900 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
59901 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
59902 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
59903 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
59904 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
59905 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
59906 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
59907 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
59908 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
59909 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
59910 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
59911 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
59912 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
59913 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
59914 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
59915 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
59916 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
59917 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
59918 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
59919 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
59920 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
59921 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
59922 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
59923 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
59924 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
59925 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
59926 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
59927 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
59928 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
59929 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
59930 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
59931 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
59932 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
59933 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
59934 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
59935 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
59936 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
59937 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
59938 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
59939 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
59940 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
59941 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
59942 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
59943 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
59944 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
59945 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
59946 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
59947 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
59948 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
59949 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
59950 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
59951 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
59952 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
59953 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
59954 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
59955 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
59956 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
59957 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
59958 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
59959 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
59960 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
59961 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
59962 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
59963 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
59964 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
59965 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
59966 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
59967 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
59968 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
59969 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
59970 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
59971 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
59972 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
59973 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
59974 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
59975 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
59976 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
59977 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
59978 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
59979 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
59980 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
59981 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
59982 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
59983 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
59984 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
59985 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
59986 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
59987 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
59988 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
59989 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
59990 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
59991 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
59992 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
59993 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
59994 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
59995 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
59996 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
59997 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
59998 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
59999 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
60000 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
60001 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
60002 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
60003 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
60004 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
60005 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
60006 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
60007 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
60008 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
60009 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
60010 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
60011 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
60012 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
60013 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
60014 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
60015 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
60016 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
60017 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
60018 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
60019 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
60020 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
60021 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
60022 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
60023 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
60024 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
60025 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
60026 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
60027 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
60028 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
60029 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
60030 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
60031 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
60032 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
60033 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
60034 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
60035 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
60036 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
60037 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
60038 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
60039 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
60040 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
60041 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
60042 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
60043 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
60044 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
60045 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
60046 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
60047 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
60048 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
60049 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
60050 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
60051 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
60052 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
60053 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
60054 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
60055 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
60056 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
60057 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
60058 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
60059 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
60060 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
60061 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
60062 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
60063 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
60064 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
60065 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
60066 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
60067 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
60068 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
60069 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
60070 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
60071 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
60072 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
60073 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
60074 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
60075 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
60076 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
60077 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
60078 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
60079 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
60080 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
60081 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
60082 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
60083 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
60084 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
60085 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
60086 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
60087 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
60088 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
60089 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
60090 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
60091 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
60092 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
60093 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
60094 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
60095 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
60096 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
60097 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
60098 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
60099 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
60100 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
60101 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
60102 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
60103 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
60104 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
60105 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
60106 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
60107 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
60108 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
60109 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
60110 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
60111 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
60112 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
60113 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
60114 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
60115 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
60116 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
60117 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
60118 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
60119 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
60120 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
60121 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
60122 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
60123 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
60124 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
60125 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
60126 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
60127 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
60128 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
60129 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
60130 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
60131 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
60132 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
60133 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
60134 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
60135 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
60136 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
60137 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
60138 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
60139 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
60140 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
60141 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
60142 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
60143 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
60144 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
60145 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
60146 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
60147 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
60148 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
60149 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
60150 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
60151 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
60152 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
60153 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
60154 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
60155 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
60156 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
60157 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
60158 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
60159 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
60160 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
60161 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
60162 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
60163 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
60164 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
60165 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
60166 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
60167 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
60168 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
60169 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
60170 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
60171 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
60172 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
60173 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
60174 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
60175 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
60176 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
60177 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
60178 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
60179 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
60180 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
60181 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
60182 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
60183 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
60184 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
60185 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
60186 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
60187 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
60188 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
60189 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
60190 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
60191 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
60192 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
60193 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
60194 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
60195 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
60196 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
60197 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
60198 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
60199 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
60200 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
60201 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
60202 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
60203 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
60204 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
60205 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
60206 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
60207 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
60208 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
60209 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
60210 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
60211 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
60212 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
60213 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
60214 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
60215 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
60216 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
60217 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TGA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TGA)));
60218 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
60219 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
60220 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
60221 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
60222 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
60223 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
60224 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
60225 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
60226 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
60227 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
60228 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
60229 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
60230 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
60231 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
60232 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
60233 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
60234 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
60235 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
60236 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
60237 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
60238 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
60239 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
60240 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
60241 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
60242 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
60243 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
60244 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
60245 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
60246 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
60247 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
60248 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
60249 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
60250 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
60251 SWIG_Python_SetConstant(d, "Inside",SWIG_From_int(static_cast< int >(wxInside)));
60252 SWIG_Python_SetConstant(d, "OutLeft",SWIG_From_int(static_cast< int >(wxOutLeft)));
60253 SWIG_Python_SetConstant(d, "OutRight",SWIG_From_int(static_cast< int >(wxOutRight)));
60254 SWIG_Python_SetConstant(d, "OutTop",SWIG_From_int(static_cast< int >(wxOutTop)));
60255 SWIG_Python_SetConstant(d, "OutBottom",SWIG_From_int(static_cast< int >(wxOutBottom)));
60256 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
60257 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
60258 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
60259 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
60260 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
60261
60262 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
60263
60264
60265 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
60266
60267 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
60268 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
60269 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
60270 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
60271 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
60272 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
60273 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
60274 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
60275 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
60276 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
60277 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
60278 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
60279 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
60280 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
60281 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
60282 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
60283 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
60284 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
60285 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
60286 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
60287 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
60288 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
60289 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
60290 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
60291 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
60292 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
60293 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
60294 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
60295 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
60296 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
60297 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
60298 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
60299 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
60300 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
60301 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
60302 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
60303 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
60304 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
60305 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
60306 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
60307 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
60308 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
60309 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
60310 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
60311 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
60312 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
60313 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
60314 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
60315 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
60316 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
60317 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
60318 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
60319 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
60320 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
60321 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
60322 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
60323 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
60324 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
60325 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
60326 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
60327 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
60328 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
60329 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
60330 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
60331 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
60332 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
60333 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
60334 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
60335 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
60336 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
60337 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
60338 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
60339 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
60340 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
60341 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
60342 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
60343 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
60344 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
60345 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
60346 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
60347 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
60348 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
60349 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
60350 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
60351 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
60352 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
60353 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
60354 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
60355 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
60356 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
60357 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
60358 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
60359 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
60360 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
60361 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
60362 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
60363 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
60364 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
60365 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
60366 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
60367 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
60368 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
60369 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
60370 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
60371 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
60372 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
60373 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
60374 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
60375 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
60376 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
60377 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
60378 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
60379 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
60380 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
60381 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
60382 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
60383 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
60384 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
60385 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
60386 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
60387 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
60388 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
60389 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
60390 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
60391 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
60392 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
60393 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
60394 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
60395 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
60396 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
60397 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
60398 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
60399 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
60400 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
60401 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
60402 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
60403 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
60404 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
60405 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
60406 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
60407 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
60408 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
60409 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
60410 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
60411 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
60412 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
60413 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
60414 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
60415 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
60416 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
60417 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
60418 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
60419 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
60420 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
60421 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
60422 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
60423 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
60424 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
60425 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
60426 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
60427 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
60428 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
60429 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
60430 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
60431 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
60432 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
60433 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
60434 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
60435 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
60436 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
60437 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
60438 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
60439 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
60440 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
60441 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
60442 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
60443 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
60444 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
60445 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
60446 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
60447 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
60448 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
60449 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
60450 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
60451 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
60452 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
60453 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
60454 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
60455 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
60456 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
60457 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
60458 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
60459 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
60460 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
60461 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
60462 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
60463 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
60464 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
60465 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
60466 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
60467 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
60468 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
60469 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
60470 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
60471 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
60472 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
60473 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
60474 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
60475 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
60476 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
60477 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
60478 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
60479 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
60480 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
60481
60482 // Initialize threading, some globals and such
60483 __wxPyPreStart(d);
60484
60485
60486 // Although these are defined in __version__ they need to be here too so
60487 // that an assert can be done to ensure that the wxPython and the wxWindows
60488 // versions match.
60489 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
60490 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
60491 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
60492
60493 }
60494
wxWidgets (Impactor)