]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Forward port recent changes on the 2.8 branch to HEAD
[wxWidgets.git] / wxPython / src / mac / _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_wxEventBlocker swig_types[38]
2505 #define SWIGTYPE_p_wxEventLoop swig_types[39]
2506 #define SWIGTYPE_p_wxEventLoopActivator swig_types[40]
2507 #define SWIGTYPE_p_wxEvtHandler swig_types[41]
2508 #define SWIGTYPE_p_wxFSFile swig_types[42]
2509 #define SWIGTYPE_p_wxFileSystem swig_types[43]
2510 #define SWIGTYPE_p_wxFileSystemHandler swig_types[44]
2511 #define SWIGTYPE_p_wxFlexGridSizer swig_types[45]
2512 #define SWIGTYPE_p_wxFocusEvent swig_types[46]
2513 #define SWIGTYPE_p_wxFont swig_types[47]
2514 #define SWIGTYPE_p_wxFrame swig_types[48]
2515 #define SWIGTYPE_p_wxGBPosition swig_types[49]
2516 #define SWIGTYPE_p_wxGBSizerItem swig_types[50]
2517 #define SWIGTYPE_p_wxGBSpan swig_types[51]
2518 #define SWIGTYPE_p_wxGIFHandler swig_types[52]
2519 #define SWIGTYPE_p_wxGridBagSizer swig_types[53]
2520 #define SWIGTYPE_p_wxGridSizer swig_types[54]
2521 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[55]
2522 #define SWIGTYPE_p_wxICOHandler swig_types[56]
2523 #define SWIGTYPE_p_wxIconizeEvent swig_types[57]
2524 #define SWIGTYPE_p_wxIdleEvent swig_types[58]
2525 #define SWIGTYPE_p_wxImage swig_types[59]
2526 #define SWIGTYPE_p_wxImageHandler swig_types[60]
2527 #define SWIGTYPE_p_wxImageHistogram swig_types[61]
2528 #define SWIGTYPE_p_wxImage_HSVValue swig_types[62]
2529 #define SWIGTYPE_p_wxImage_RGBValue swig_types[63]
2530 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[64]
2531 #define SWIGTYPE_p_wxInitDialogEvent swig_types[65]
2532 #define SWIGTYPE_p_wxInputStream swig_types[66]
2533 #define SWIGTYPE_p_wxInternetFSHandler swig_types[67]
2534 #define SWIGTYPE_p_wxItemContainer swig_types[68]
2535 #define SWIGTYPE_p_wxJPEGHandler swig_types[69]
2536 #define SWIGTYPE_p_wxKeyEvent swig_types[70]
2537 #define SWIGTYPE_p_wxLayoutConstraints swig_types[71]
2538 #define SWIGTYPE_p_wxMaximizeEvent swig_types[72]
2539 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[73]
2540 #define SWIGTYPE_p_wxMenu swig_types[74]
2541 #define SWIGTYPE_p_wxMenuBar swig_types[75]
2542 #define SWIGTYPE_p_wxMenuBarBase swig_types[76]
2543 #define SWIGTYPE_p_wxMenuEvent swig_types[77]
2544 #define SWIGTYPE_p_wxMenuItem swig_types[78]
2545 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[80]
2547 #define SWIGTYPE_p_wxMouseEvent swig_types[81]
2548 #define SWIGTYPE_p_wxMoveEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[83]
2550 #define SWIGTYPE_p_wxNcPaintEvent swig_types[84]
2551 #define SWIGTYPE_p_wxNotifyEvent swig_types[85]
2552 #define SWIGTYPE_p_wxObject swig_types[86]
2553 #define SWIGTYPE_p_wxOutputStream swig_types[87]
2554 #define SWIGTYPE_p_wxPCXHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPNGHandler swig_types[89]
2556 #define SWIGTYPE_p_wxPNMHandler swig_types[90]
2557 #define SWIGTYPE_p_wxPaintEvent swig_types[91]
2558 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[92]
2559 #define SWIGTYPE_p_wxPaperSize swig_types[93]
2560 #define SWIGTYPE_p_wxPoint swig_types[94]
2561 #define SWIGTYPE_p_wxPoint2D swig_types[95]
2562 #define SWIGTYPE_p_wxPosition swig_types[96]
2563 #define SWIGTYPE_p_wxPropagateOnce swig_types[97]
2564 #define SWIGTYPE_p_wxPropagationDisabler swig_types[98]
2565 #define SWIGTYPE_p_wxPyApp swig_types[99]
2566 #define SWIGTYPE_p_wxPyCommandEvent swig_types[100]
2567 #define SWIGTYPE_p_wxPyDropTarget swig_types[101]
2568 #define SWIGTYPE_p_wxPyEvent swig_types[102]
2569 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[103]
2570 #define SWIGTYPE_p_wxPyImageHandler swig_types[104]
2571 #define SWIGTYPE_p_wxPyInputStream swig_types[105]
2572 #define SWIGTYPE_p_wxPySizer swig_types[106]
2573 #define SWIGTYPE_p_wxPyValidator swig_types[107]
2574 #define SWIGTYPE_p_wxQuantize swig_types[108]
2575 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[109]
2576 #define SWIGTYPE_p_wxRealPoint swig_types[110]
2577 #define SWIGTYPE_p_wxRect swig_types[111]
2578 #define SWIGTYPE_p_wxRect2D swig_types[112]
2579 #define SWIGTYPE_p_wxRegion swig_types[113]
2580 #define SWIGTYPE_p_wxScrollEvent swig_types[114]
2581 #define SWIGTYPE_p_wxScrollWinEvent swig_types[115]
2582 #define SWIGTYPE_p_wxSetCursorEvent swig_types[116]
2583 #define SWIGTYPE_p_wxShowEvent swig_types[117]
2584 #define SWIGTYPE_p_wxSize swig_types[118]
2585 #define SWIGTYPE_p_wxSizeEvent swig_types[119]
2586 #define SWIGTYPE_p_wxSizer swig_types[120]
2587 #define SWIGTYPE_p_wxSizerFlags swig_types[121]
2588 #define SWIGTYPE_p_wxSizerItem swig_types[122]
2589 #define SWIGTYPE_p_wxStaticBox swig_types[123]
2590 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[124]
2591 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[125]
2592 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[126]
2593 #define SWIGTYPE_p_wxTGAHandler swig_types[127]
2594 #define SWIGTYPE_p_wxTIFFHandler swig_types[128]
2595 #define SWIGTYPE_p_wxToolTip swig_types[129]
2596 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[130]
2597 #define SWIGTYPE_p_wxValidator swig_types[131]
2598 #define SWIGTYPE_p_wxVisualAttributes swig_types[132]
2599 #define SWIGTYPE_p_wxWindow swig_types[133]
2600 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[134]
2601 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[135]
2602 #define SWIGTYPE_p_wxXPMHandler swig_types[136]
2603 #define SWIGTYPE_p_wxZipFSHandler swig_types[137]
2604 static swig_type_info *swig_types[139];
2605 static swig_module_info swig_module = {swig_types, 138, 0, 0, 0, 0};
2606 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2607 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2608
2609 /* -------- TYPES TABLE (END) -------- */
2610
2611 #if (PY_VERSION_HEX <= 0x02000000)
2612 # if !defined(SWIG_PYTHON_CLASSIC)
2613 # error "This python version requires to use swig with the '-classic' option"
2614 # endif
2615 #endif
2616 #if (PY_VERSION_HEX <= 0x02020000)
2617 # error "This python version requires to use swig with the '-nomodern' option"
2618 #endif
2619 #if (PY_VERSION_HEX <= 0x02020000)
2620 # error "This python version requires to use swig with the '-nomodernargs' option"
2621 #endif
2622 #ifndef METH_O
2623 # error "This python version requires to use swig with the '-nofastunpack' option"
2624 #endif
2625
2626 /*-----------------------------------------------
2627 @(target):= _core_.so
2628 ------------------------------------------------*/
2629 #define SWIG_init init_core_
2630
2631 #define SWIG_name "_core_"
2632
2633 #define SWIGVERSION 0x010329
2634
2635
2636 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2637 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2638
2639
2640 #include <stdexcept>
2641
2642
2643 namespace swig {
2644 class PyObject_ptr {
2645 protected:
2646 PyObject *_obj;
2647
2648 public:
2649 PyObject_ptr() :_obj(0)
2650 {
2651 }
2652
2653 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2654 {
2655 Py_XINCREF(_obj);
2656 }
2657
2658 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2659 {
2660 if (initial_ref) Py_XINCREF(_obj);
2661 }
2662
2663 PyObject_ptr & operator=(const PyObject_ptr& item)
2664 {
2665 Py_XINCREF(item._obj);
2666 Py_XDECREF(_obj);
2667 _obj = item._obj;
2668 return *this;
2669 }
2670
2671 ~PyObject_ptr()
2672 {
2673 Py_XDECREF(_obj);
2674 }
2675
2676 operator PyObject *() const
2677 {
2678 return _obj;
2679 }
2680
2681 PyObject *operator->() const
2682 {
2683 return _obj;
2684 }
2685 };
2686 }
2687
2688
2689 namespace swig {
2690 struct PyObject_var : PyObject_ptr {
2691 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2692
2693 PyObject_var & operator = (PyObject* obj)
2694 {
2695 Py_XDECREF(_obj);
2696 _obj = obj;
2697 return *this;
2698 }
2699 };
2700 }
2701
2702
2703 #include "wx/wxPython/wxPython_int.h"
2704 #include "wx/wxPython/pyclasses.h"
2705 #include "wx/wxPython/twoitem.h"
2706
2707
2708 #ifndef wxPyUSE_EXPORT
2709 // Helper functions for dealing with SWIG objects and such. These are
2710 // located here so they know about the SWIG types and functions declared
2711 // in the wrapper code.
2712
2713 #include <wx/hashmap.h>
2714 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2715
2716
2717 // Maintains a hashmap of className to swig_type_info pointers. Given the
2718 // name of a class either looks up the type info in the cache, or scans the
2719 // SWIG tables for it.
2720 extern PyObject* wxPyPtrTypeMap;
2721 static
2722 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2723
2724 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2725
2726 if (typeInfoCache == NULL)
2727 typeInfoCache = new wxPyTypeInfoHashMap;
2728
2729 wxString name(className);
2730 swig_type_info* swigType = (*typeInfoCache)[name];
2731
2732 if (! swigType) {
2733 // it wasn't in the cache, so look it up from SWIG
2734 name.Append(wxT(" *"));
2735 swigType = SWIG_TypeQuery(name.mb_str());
2736
2737 // if it still wasn't found, try looking for a mapped name
2738 if (!swigType) {
2739 PyObject* item;
2740 name = className;
2741
2742 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2743 (char*)(const char*)name.mbc_str())) != NULL) {
2744 name = wxString(PyString_AsString(item), *wxConvCurrent);
2745 name.Append(wxT(" *"));
2746 swigType = SWIG_TypeQuery(name.mb_str());
2747 }
2748 }
2749 if (swigType) {
2750 // and add it to the map if found
2751 (*typeInfoCache)[className] = swigType;
2752 }
2753 }
2754 return swigType;
2755 }
2756
2757
2758 // Check if a class name is a type known to SWIG
2759 bool wxPyCheckSwigType(const wxChar* className) {
2760
2761 swig_type_info* swigType = wxPyFindSwigType(className);
2762 return swigType != NULL;
2763 }
2764
2765
2766 // Given a pointer to a C++ object and a class name, construct a Python proxy
2767 // object for it.
2768 PyObject* wxPyConstructObject(void* ptr,
2769 const wxChar* className,
2770 int setThisOwn) {
2771
2772 swig_type_info* swigType = wxPyFindSwigType(className);
2773 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2774
2775 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2776 }
2777
2778
2779 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2780 // Ensures that the proxy object is of the specified (or derived) type. If
2781 // not able to perform the conversion then a Python exception is set and the
2782 // error should be handled properly in the caller. Returns True on success.
2783 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2784 const wxChar* className) {
2785
2786 swig_type_info* swigType = wxPyFindSwigType(className);
2787 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2788
2789 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2790 }
2791
2792
2793
2794 // Make a SWIGified pointer object suitable for a .this attribute
2795 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2796
2797 PyObject* robj = NULL;
2798
2799 swig_type_info* swigType = wxPyFindSwigType(className);
2800 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2801
2802 robj = PySwigObject_New(ptr, swigType, 0);
2803 return robj;
2804 }
2805
2806
2807 // Python's PyInstance_Check does not return True for instances of new-style
2808 // classes. This should get close enough for both new and old classes but I
2809 // should re-evaluate the need for doing instance checks...
2810 bool wxPyInstance_Check(PyObject* obj) {
2811 return PyObject_HasAttrString(obj, "__class__") != 0;
2812 }
2813
2814
2815 // This one checks if the object is an instance of a SWIG proxy class (it has
2816 // a .this attribute, and the .this attribute is a PySwigObject.)
2817 bool wxPySwigInstance_Check(PyObject* obj) {
2818 static PyObject* this_str = NULL;
2819 if (this_str == NULL)
2820 this_str = PyString_FromString("this");
2821
2822 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2823 if (this_attr) {
2824 bool retval = (PySwigObject_Check(this_attr) != 0);
2825 Py_DECREF(this_attr);
2826 return retval;
2827 }
2828
2829 PyErr_Clear();
2830 return false;
2831 }
2832
2833
2834 // Export a C API in a struct. Other modules will be able to load this from
2835 // the wx._core_ module and will then have safe access to these functions,
2836 // even if they are located in another shared library.
2837 static wxPyCoreAPI API = {
2838
2839 wxPyCheckSwigType,
2840 wxPyConstructObject,
2841 wxPyConvertSwigPtr,
2842 wxPyMakeSwigPtr,
2843
2844 wxPyBeginAllowThreads,
2845 wxPyEndAllowThreads,
2846 wxPyBeginBlockThreads,
2847 wxPyEndBlockThreads,
2848
2849 wxPy_ConvertList,
2850
2851 wxString_in_helper,
2852 Py2wxString,
2853 wx2PyString,
2854
2855 byte_LIST_helper,
2856 int_LIST_helper,
2857 long_LIST_helper,
2858 string_LIST_helper,
2859 wxPoint_LIST_helper,
2860 wxBitmap_LIST_helper,
2861 wxString_LIST_helper,
2862 wxAcceleratorEntry_LIST_helper,
2863
2864 wxSize_helper,
2865 wxPoint_helper,
2866 wxRealPoint_helper,
2867 wxRect_helper,
2868 wxColour_helper,
2869 wxPoint2D_helper,
2870
2871 wxPySimple_typecheck,
2872 wxColour_typecheck,
2873
2874 wxPyCBH_setCallbackInfo,
2875 wxPyCBH_findCallback,
2876 wxPyCBH_callCallback,
2877 wxPyCBH_callCallbackObj,
2878 wxPyCBH_delete,
2879
2880 wxPyMake_wxObject,
2881 wxPyMake_wxSizer,
2882 wxPyPtrTypeMap_Add,
2883 wxPy2int_seq_helper,
2884 wxPy4int_seq_helper,
2885 wxArrayString2PyList_helper,
2886 wxArrayInt2PyList_helper,
2887
2888 wxPyClientData_dtor,
2889 wxPyUserData_dtor,
2890 wxPyOORClientData_dtor,
2891
2892 wxPyCBInputStream_create,
2893 wxPyCBInputStream_copy,
2894
2895 wxPyInstance_Check,
2896 wxPySwigInstance_Check,
2897
2898 wxPyCheckForApp,
2899
2900 wxArrayDouble2PyList_helper,
2901 wxPoint2D_LIST_helper,
2902 wxRect2D_helper,
2903 wxPosition_helper,
2904
2905 };
2906
2907 #endif
2908
2909
2910 #if !WXWIN_COMPATIBILITY_2_4
2911 #define wxHIDE_READONLY 0
2912 #endif
2913
2914
2915 #define SWIG_From_long PyInt_FromLong
2916
2917
2918 SWIGINTERNINLINE PyObject *
2919 SWIG_From_int (int value)
2920 {
2921 return SWIG_From_long (value);
2922 }
2923
2924 static const wxString wxPyEmptyString(wxEmptyString);
2925 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2926 return self->GetClassInfo()->GetClassName();
2927 }
2928 SWIGINTERN void wxObject_Destroy(wxObject *self){
2929 delete self;
2930 }
2931
2932 #ifndef __WXMAC__
2933 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2934 #endif
2935
2936
2937 #include <limits.h>
2938 #ifndef LLONG_MIN
2939 # define LLONG_MIN LONG_LONG_MIN
2940 #endif
2941 #ifndef LLONG_MAX
2942 # define LLONG_MAX LONG_LONG_MAX
2943 #endif
2944 #ifndef ULLONG_MAX
2945 # define ULLONG_MAX ULONG_LONG_MAX
2946 #endif
2947
2948
2949 SWIGINTERN int
2950 SWIG_AsVal_long (PyObject* obj, long* val)
2951 {
2952 if (PyNumber_Check(obj)) {
2953 if (val) *val = PyInt_AsLong(obj);
2954 return SWIG_OK;
2955 }
2956 return SWIG_TypeError;
2957 }
2958
2959
2960 SWIGINTERN int
2961 SWIG_AsVal_int (PyObject * obj, int *val)
2962 {
2963 long v;
2964 int res = SWIG_AsVal_long (obj, &v);
2965 if (SWIG_IsOK(res)) {
2966 if ((v < INT_MIN || v > INT_MAX)) {
2967 return SWIG_OverflowError;
2968 } else {
2969 if (val) *val = static_cast< int >(v);
2970 }
2971 }
2972 return res;
2973 }
2974
2975 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2976 wxSize temp, *obj = &temp;
2977 if ( other == Py_None ) return false;
2978 if ( ! wxSize_helper(other, &obj) ) {
2979 PyErr_Clear();
2980 return false;
2981 }
2982 return self->operator==(*obj);
2983 }
2984 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2985 wxSize temp, *obj = &temp;
2986 if ( other == Py_None ) return true;
2987 if ( ! wxSize_helper(other, &obj)) {
2988 PyErr_Clear();
2989 return true;
2990 }
2991 return self->operator!=(*obj);
2992 }
2993
2994 #include <float.h>
2995
2996
2997 SWIGINTERN int
2998 SWIG_AsVal_double (PyObject *obj, double* val)
2999 {
3000 if (PyNumber_Check(obj)) {
3001 if (val) *val = PyFloat_AsDouble(obj);
3002 return SWIG_OK;
3003 }
3004 return SWIG_TypeError;
3005 }
3006
3007
3008 SWIGINTERN int
3009 SWIG_AsVal_float (PyObject * obj, float *val)
3010 {
3011 double v;
3012 int res = SWIG_AsVal_double (obj, &v);
3013 if (SWIG_IsOK(res)) {
3014 if ((v < -FLT_MAX || v > FLT_MAX)) {
3015 return SWIG_OverflowError;
3016 } else {
3017 if (val) *val = static_cast< float >(v);
3018 }
3019 }
3020 return res;
3021 }
3022
3023 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3024 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3025 PyObject* tup = PyTuple_New(2);
3026 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3027 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3028 //wxPyEndBlockThreads(blocked);
3029 return tup;
3030 }
3031
3032 #define SWIG_From_double PyFloat_FromDouble
3033
3034 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3035 wxRealPoint temp, *obj = &temp;
3036 if ( other == Py_None ) return false;
3037 if ( ! wxRealPoint_helper(other, &obj) ) {
3038 PyErr_Clear();
3039 return false;
3040 }
3041 return self->operator==(*obj);
3042 }
3043 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3044 wxRealPoint temp, *obj = &temp;
3045 if ( other == Py_None ) return true;
3046 if ( ! wxRealPoint_helper(other, &obj)) {
3047 PyErr_Clear();
3048 return true;
3049 }
3050 return self->operator!=(*obj);
3051 }
3052 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3053 self->x = x;
3054 self->y = y;
3055 }
3056 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3057 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3058 PyObject* tup = PyTuple_New(2);
3059 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3060 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3061 //PyEndBlockThreads(blocked);
3062 return tup;
3063 }
3064 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3065 wxPoint temp, *obj = &temp;
3066 if ( other == Py_None ) return false;
3067 if ( ! wxPoint_helper(other, &obj) ) {
3068 PyErr_Clear();
3069 return false;
3070 }
3071 return self->operator==(*obj);
3072 }
3073 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3074 wxPoint temp, *obj = &temp;
3075 if ( other == Py_None ) return true;
3076 if ( ! wxPoint_helper(other, &obj)) {
3077 PyErr_Clear();
3078 return true;
3079 }
3080 return self->operator!=(*obj);
3081 }
3082 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3083 self->x = x;
3084 self->y = y;
3085 }
3086 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3087 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3088 PyObject* tup = PyTuple_New(2);
3089 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3090 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3091 //wxPyEndBlockThreads(blocked);
3092 return tup;
3093 }
3094 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3095 wxRect temp, *obj = &temp;
3096 if ( other == Py_None ) return false;
3097 if ( ! wxRect_helper(other, &obj) ) {
3098 PyErr_Clear();
3099 return false;
3100 }
3101 return self->operator==(*obj);
3102 }
3103 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3104 wxRect temp, *obj = &temp;
3105 if ( other == Py_None ) return true;
3106 if ( ! wxRect_helper(other, &obj)) {
3107 PyErr_Clear();
3108 return true;
3109 }
3110 return self->operator!=(*obj);
3111 }
3112 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3113 self->x = x;
3114 self->y = y;
3115 self->width = width;
3116 self->height = height;
3117 }
3118 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3119 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3120 PyObject* tup = PyTuple_New(4);
3121 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3122 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3123 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3124 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3125 //wxPyEndBlockThreads(blocked);
3126 return tup;
3127 }
3128
3129 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3130 wxRegion reg1(*r1);
3131 wxRegion reg2(*r2);
3132 wxRect dest(0,0,0,0);
3133 PyObject* obj;
3134
3135 reg1.Intersect(reg2);
3136 dest = reg1.GetBox();
3137
3138 if (dest != wxRect(0,0,0,0)) {
3139 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3140 wxRect* newRect = new wxRect(dest);
3141 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3142 //wxPyEndBlockThreads(blocked);
3143 return obj;
3144 }
3145 Py_INCREF(Py_None);
3146 return Py_None;
3147 }
3148
3149 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3150 wxPoint2D temp, *obj = &temp;
3151 if ( other == Py_None ) return false;
3152 if ( ! wxPoint2D_helper(other, &obj) ) {
3153 PyErr_Clear();
3154 return false;
3155 }
3156 return self->operator==(*obj);
3157 }
3158 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3159 wxPoint2D temp, *obj = &temp;
3160 if ( other == Py_None ) return true;
3161 if ( ! wxPoint2D_helper(other, &obj)) {
3162 PyErr_Clear();
3163 return true;
3164 }
3165 return self->operator!=(*obj);
3166 }
3167 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3168 self->m_x = x;
3169 self->m_y = y;
3170 }
3171 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3172 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3173 PyObject* tup = PyTuple_New(2);
3174 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3175 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3176 //wxPyEndBlockThreads(blocked);
3177 return tup;
3178 }
3179 SWIGINTERN bool wxRect2D___eq__(wxRect2D *self,PyObject *other){
3180 wxRect2D temp, *obj = &temp;
3181 if ( other == Py_None ) return false;
3182 if ( ! wxRect2D_helper(other, &obj) ) {
3183 PyErr_Clear();
3184 return false;
3185 }
3186 return self->operator==(*obj);
3187 }
3188 SWIGINTERN bool wxRect2D___ne__(wxRect2D *self,PyObject *other){
3189 wxRect2D temp, *obj = &temp;
3190 if ( other == Py_None ) return true;
3191 if ( ! wxRect2D_helper(other, &obj)) {
3192 PyErr_Clear();
3193 return true;
3194 }
3195 return self->operator!=(*obj);
3196 }
3197 SWIGINTERN void wxRect2D_Set(wxRect2D *self,wxDouble x=0,wxDouble y=0,wxDouble width=0,wxDouble height=0){
3198 self->m_x = x;
3199 self->m_y = y;
3200 self->m_width = width;
3201 self->m_height = height;
3202 }
3203 SWIGINTERN PyObject *wxRect2D_Get(wxRect2D *self){
3204 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3205 PyObject* tup = PyTuple_New(4);
3206 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3207 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3208 PyTuple_SET_ITEM(tup, 2, PyFloat_FromDouble(self->m_width));
3209 PyTuple_SET_ITEM(tup, 3, PyFloat_FromDouble(self->m_height));
3210 //wxPyEndBlockThreads(blocked);
3211 return tup;
3212 }
3213 SWIGINTERN bool wxPosition___eq__(wxPosition *self,PyObject *other){
3214 wxPosition temp, *obj = &temp;
3215 if ( other == Py_None ) return false;
3216 if ( ! wxPosition_helper(other, &obj) ) {
3217 PyErr_Clear();
3218 return false;
3219 }
3220 return self->operator==(*obj);
3221 }
3222 SWIGINTERN bool wxPosition___ne__(wxPosition *self,PyObject *other){
3223 wxPosition temp, *obj = &temp;
3224 if ( other == Py_None ) return true;
3225 if ( ! wxPosition_helper(other, &obj)) {
3226 PyErr_Clear();
3227 return true;
3228 }
3229 return self->operator!=(*obj);
3230 }
3231
3232 #include "wx/wxPython/pyistream.h"
3233
3234 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3235 wxInputStream* wxis = wxPyCBInputStream::create(p);
3236 if (wxis)
3237 return new wxPyInputStream(wxis);
3238 else
3239 return NULL;
3240 }
3241
3242 SWIGINTERN swig_type_info*
3243 SWIG_pchar_descriptor()
3244 {
3245 static int init = 0;
3246 static swig_type_info* info = 0;
3247 if (!init) {
3248 info = SWIG_TypeQuery("_p_char");
3249 init = 1;
3250 }
3251 return info;
3252 }
3253
3254
3255 SWIGINTERNINLINE PyObject *
3256 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3257 {
3258 if (carray) {
3259 if (size > INT_MAX) {
3260 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3261 return pchar_descriptor ?
3262 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3263 } else {
3264 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3265 }
3266 } else {
3267 return SWIG_Py_Void();
3268 }
3269 }
3270
3271
3272 SWIGINTERNINLINE PyObject *
3273 SWIG_From_char (char c)
3274 {
3275 return SWIG_FromCharPtrAndSize(&c,1);
3276 }
3277
3278
3279 SWIGINTERNINLINE PyObject*
3280 SWIG_From_unsigned_SS_long (unsigned long value)
3281 {
3282 return (value > LONG_MAX) ?
3283 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3284 }
3285
3286
3287 SWIGINTERNINLINE PyObject *
3288 SWIG_From_size_t (size_t value)
3289 {
3290 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3291 }
3292
3293
3294 SWIGINTERN int
3295 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3296 {
3297 if (PyString_Check(obj)) {
3298 char *cstr; Py_ssize_t len;
3299 PyString_AsStringAndSize(obj, &cstr, &len);
3300 if (cptr) {
3301 if (alloc) {
3302 /*
3303 In python the user should not be able to modify the inner
3304 string representation. To warranty that, if you define
3305 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3306 buffer is always returned.
3307
3308 The default behavior is just to return the pointer value,
3309 so, be careful.
3310 */
3311 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3312 if (*alloc != SWIG_OLDOBJ)
3313 #else
3314 if (*alloc == SWIG_NEWOBJ)
3315 #endif
3316 {
3317 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3318 *alloc = SWIG_NEWOBJ;
3319 }
3320 else {
3321 *cptr = cstr;
3322 *alloc = SWIG_OLDOBJ;
3323 }
3324 } else {
3325 *cptr = PyString_AsString(obj);
3326 }
3327 }
3328 if (psize) *psize = len + 1;
3329 return SWIG_OK;
3330 } else {
3331 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3332 if (pchar_descriptor) {
3333 void* vptr = 0;
3334 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3335 if (cptr) *cptr = (char *) vptr;
3336 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3337 if (alloc) *alloc = SWIG_OLDOBJ;
3338 return SWIG_OK;
3339 }
3340 }
3341 }
3342 return SWIG_TypeError;
3343 }
3344
3345
3346 SWIGINTERN int
3347 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3348 {
3349 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3350 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3351 if (SWIG_IsOK(res)) {
3352 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3353 if (csize <= size) {
3354 if (val) {
3355 if (csize) memcpy(val, cptr, csize*sizeof(char));
3356 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3357 }
3358 if (alloc == SWIG_NEWOBJ) {
3359 delete[] cptr;
3360 res = SWIG_DelNewMask(res);
3361 }
3362 return res;
3363 }
3364 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3365 }
3366 return SWIG_TypeError;
3367 }
3368
3369
3370 SWIGINTERN int
3371 SWIG_AsVal_char (PyObject * obj, char *val)
3372 {
3373 int res = SWIG_AsCharArray(obj, val, 1);
3374 if (!SWIG_IsOK(res)) {
3375 long v;
3376 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3377 if (SWIG_IsOK(res)) {
3378 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3379 if (val) *val = static_cast< char >(v);
3380 } else {
3381 res = SWIG_OverflowError;
3382 }
3383 }
3384 }
3385 return res;
3386 }
3387
3388 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3389 // We use only strings for the streams, not unicode
3390 PyObject* str = PyObject_Str(obj);
3391 if (! str) {
3392 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3393 return;
3394 }
3395 self->Write(PyString_AS_STRING(str),
3396 PyString_GET_SIZE(str));
3397 Py_DECREF(str);
3398 }
3399
3400 #include "wx/wxPython/pyistream.h"
3401
3402
3403 class wxPyFileSystemHandler : public wxFileSystemHandler
3404 {
3405 public:
3406 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3407
3408 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3409 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3410 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3411 DEC_PYCALLBACK_STRING__pure(FindNext);
3412
3413 wxString GetProtocol(const wxString& location) {
3414 return wxFileSystemHandler::GetProtocol(location);
3415 }
3416
3417 wxString GetLeftLocation(const wxString& location) {
3418 return wxFileSystemHandler::GetLeftLocation(location);
3419 }
3420
3421 wxString GetAnchor(const wxString& location) {
3422 return wxFileSystemHandler::GetAnchor(location);
3423 }
3424
3425 wxString GetRightLocation(const wxString& location) {
3426 return wxFileSystemHandler::GetRightLocation(location);
3427 }
3428
3429 wxString GetMimeTypeFromExt(const wxString& location) {
3430 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3431 }
3432
3433 PYPRIVATE;
3434 };
3435
3436
3437 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3438 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3439 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3440 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3441
3442
3443 SWIGINTERN int
3444 SWIG_AsVal_bool (PyObject *obj, bool *val)
3445 {
3446 if (obj == Py_True) {
3447 if (val) *val = true;
3448 return SWIG_OK;
3449 } else if (obj == Py_False) {
3450 if (val) *val = false;
3451 return SWIG_OK;
3452 } else {
3453 long v = 0;
3454 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3455 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3456 return res;
3457 }
3458 }
3459
3460 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3461 wxFileName fname = wxFileSystem::URLToFileName(url);
3462 return fname.GetFullPath();
3463 }
3464
3465 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3466 wxImage& image,
3467 long type) {
3468 wxMemoryFSHandler::AddFile(filename, image, type);
3469 }
3470
3471 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3472 const wxBitmap& bitmap,
3473 long type) {
3474 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3475 }
3476
3477 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3478 PyObject* data) {
3479 if (! PyString_Check(data)) {
3480 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3481 "Expected string object"));
3482 return;
3483 }
3484
3485 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3486 void* ptr = (void*)PyString_AsString(data);
3487 size_t size = PyString_Size(data);
3488 wxPyEndBlockThreads(blocked);
3489
3490 wxMemoryFSHandler::AddFile(filename, ptr, size);
3491 }
3492
3493
3494 #include "wx/wxPython/pyistream.h"
3495
3496
3497 SWIGINTERN int
3498 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3499 {
3500 long v = 0;
3501 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3502 return SWIG_TypeError;
3503 }
3504 else if (val)
3505 *val = (unsigned long)v;
3506 return SWIG_OK;
3507 }
3508
3509
3510 SWIGINTERN int
3511 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3512 {
3513 unsigned long v;
3514 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3515 if (SWIG_IsOK(res)) {
3516 if ((v > UCHAR_MAX)) {
3517 return SWIG_OverflowError;
3518 } else {
3519 if (val) *val = static_cast< unsigned char >(v);
3520 }
3521 }
3522 return res;
3523 }
3524
3525
3526 SWIGINTERNINLINE PyObject *
3527 SWIG_From_unsigned_SS_char (unsigned char value)
3528 {
3529 return SWIG_From_unsigned_SS_long (value);
3530 }
3531
3532 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3533 wxImageHistogramEntry e = (*self)[key];
3534 return e.value;
3535 }
3536 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3537 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3538 wxImageHistogramEntry e = (*self)[key];
3539 return e.value;
3540 }
3541 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3542 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3543 colour.Green(),
3544 colour.Blue());
3545 wxImageHistogramEntry e = (*self)[key];
3546 return e.value;
3547 }
3548
3549 // Pull the nested class out to the top level for SWIG's sake
3550 #define wxImage_RGBValue wxImage::RGBValue
3551 #define wxImage_HSVValue wxImage::HSVValue
3552
3553 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3554 if (width > 0 && height > 0)
3555 return new wxImage(width, height, clear);
3556 else
3557 return new wxImage;
3558 }
3559 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3560 return new wxImage(bitmap.ConvertToImage());
3561 }
3562 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3563 if (DATASIZE != width*height*3) {
3564 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3565 return NULL;
3566 }
3567
3568 // Copy the source data so the wxImage can clean it up later
3569 buffer copy = (buffer)malloc(DATASIZE);
3570 if (copy == NULL) {
3571 wxPyBLOCK_THREADS(PyErr_NoMemory());
3572 return NULL;
3573 }
3574 memcpy(copy, data, DATASIZE);
3575 return new wxImage(width, height, copy, false);
3576 }
3577 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3578 if (DATASIZE != width*height*3) {
3579 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3580 return NULL;
3581 }
3582 if (ALPHASIZE != width*height) {
3583 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3584 return NULL;
3585 }
3586
3587 // Copy the source data so the wxImage can clean it up later
3588 buffer dcopy = (buffer)malloc(DATASIZE);
3589 if (dcopy == NULL) {
3590 wxPyBLOCK_THREADS(PyErr_NoMemory());
3591 return NULL;
3592 }
3593 memcpy(dcopy, data, DATASIZE);
3594
3595 buffer acopy = (buffer)malloc(ALPHASIZE);
3596 if (acopy == NULL) {
3597 wxPyBLOCK_THREADS(PyErr_NoMemory());
3598 return NULL;
3599 }
3600 memcpy(acopy, alpha, ALPHASIZE);
3601
3602 return new wxImage(width, height, dcopy, acopy, false);
3603 }
3604 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3605 wxSize size(self->GetWidth(), self->GetHeight());
3606 return size;
3607 }
3608 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3609 buffer data = self->GetData();
3610 int len = self->GetWidth() * self->GetHeight() * 3;
3611 PyObject* rv;
3612 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3613 return rv;
3614 }
3615 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3616 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3617 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3618 return;
3619 }
3620 buffer copy = (buffer)malloc(DATASIZE);
3621 if (copy == NULL) {
3622 wxPyBLOCK_THREADS(PyErr_NoMemory());
3623 return;
3624 }
3625 memcpy(copy, data, DATASIZE);
3626 self->SetData(copy, false);
3627 // wxImage takes ownership of copy...
3628 }
3629 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3630 buffer data = self->GetData();
3631 int len = self->GetWidth() * self->GetHeight() * 3;
3632 PyObject* rv;
3633 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3634 return rv;
3635 }
3636 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3637 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3638 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3639 return;
3640 }
3641 self->SetData(data, true);
3642 }
3643 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3644 buffer data = self->GetAlpha();
3645 if (! data) {
3646 RETURN_NONE();
3647 } else {
3648 int len = self->GetWidth() * self->GetHeight();
3649 PyObject* rv;
3650 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3651 return rv;
3652 }
3653 }
3654 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3655 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3656 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3657 return;
3658 }
3659 buffer acopy = (buffer)malloc(ALPHASIZE);
3660 if (acopy == NULL) {
3661 wxPyBLOCK_THREADS(PyErr_NoMemory());
3662 return;
3663 }
3664 memcpy(acopy, alpha, ALPHASIZE);
3665 self->SetAlpha(acopy, false);
3666 // wxImage takes ownership of acopy...
3667 }
3668 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3669 buffer data = self->GetAlpha();
3670 int len = self->GetWidth() * self->GetHeight();
3671 PyObject* rv;
3672 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3673 return rv;
3674 }
3675 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3676 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3677 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3678 return;
3679 }
3680 self->SetAlpha(alpha, true);
3681 }
3682 SWIGINTERN PyObject *wxImage_GetHandlers(){
3683 wxList& list = wxImage::GetHandlers();
3684 return wxPy_ConvertList(&list);
3685 }
3686 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3687 wxBitmap bitmap(*self, depth);
3688 return bitmap;
3689 }
3690 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3691 wxImage mono = self->ConvertToMono( red, green, blue );
3692 wxBitmap bitmap( mono, 1 );
3693 return bitmap;
3694 }
3695
3696 wxImage* _ImageFromBuffer(int width, int height,
3697 buffer data, int DATASIZE,
3698 buffer alpha=NULL, int ALPHASIZE=0)
3699 {
3700 if (DATASIZE != width*height*3) {
3701 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3702 return NULL;
3703 }
3704 if (alpha != NULL) {
3705 if (ALPHASIZE != width*height) {
3706 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3707 return NULL;
3708 }
3709 return new wxImage(width, height, data, alpha, true);
3710 }
3711 return new wxImage(width, height, data, true);
3712 }
3713
3714 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3715 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3716 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3717 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3718 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3719 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3720 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3721 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3722 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3723 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3724 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3725 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3726 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3727 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3728 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3729
3730 #include <wx/imagtga.h>
3731
3732
3733 #include <wx/quantize.h>
3734
3735 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3736 return wxQuantize::Quantize(src, dest,
3737 //NULL, // palette
3738 desiredNoColours,
3739 NULL, // eightBitData
3740 flags);
3741 }
3742 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3743 if (PyCallable_Check(func)) {
3744 self->Connect(id, lastId, eventType,
3745 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3746 new wxPyCallback(func));
3747 }
3748 else if (func == Py_None) {
3749 self->Disconnect(id, lastId, eventType,
3750 (wxObjectEventFunction)
3751 &wxPyCallback::EventThunker);
3752 }
3753 else {
3754 wxPyBLOCK_THREADS(
3755 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3756 }
3757 }
3758 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3759 return self->Disconnect(id, lastId, eventType,
3760 (wxObjectEventFunction)
3761 &wxPyCallback::EventThunker);
3762 }
3763 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3764 if (_self && _self != Py_None) {
3765 self->SetClientObject(new wxPyOORClientData(_self, incref));
3766 }
3767 else {
3768 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3769 if (data) {
3770 self->SetClientObject(NULL); // This will delete it too
3771 }
3772 }
3773 }
3774
3775 #if ! wxUSE_HOTKEY
3776 #define wxEVT_HOTKEY -9999
3777 #endif
3778
3779 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3780 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3781 if (data) {
3782 Py_INCREF(data->m_obj);
3783 return data->m_obj;
3784 } else {
3785 Py_INCREF(Py_None);
3786 return Py_None;
3787 }
3788 }
3789 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3790 wxPyClientData* data = new wxPyClientData(clientData);
3791 self->SetClientObject(data);
3792 }
3793 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3794 #if wxUSE_UNICODE
3795 return self->GetUnicodeKey();
3796 #else
3797 return 0;
3798 #endif
3799 }
3800 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3801 #if wxUSE_UNICODE
3802 self->m_uniChar = uniChar;
3803 #endif
3804 }
3805
3806 SWIGINTERNINLINE PyObject *
3807 SWIG_From_unsigned_SS_int (unsigned int value)
3808 {
3809 return SWIG_From_unsigned_SS_long (value);
3810 }
3811
3812
3813 SWIGINTERN int
3814 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3815 {
3816 unsigned long v;
3817 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3818 if (SWIG_IsOK(res)) {
3819 if ((v > UINT_MAX)) {
3820 return SWIG_OverflowError;
3821 } else {
3822 if (val) *val = static_cast< unsigned int >(v);
3823 }
3824 }
3825 return res;
3826 }
3827
3828 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3829 self->m_size = size;
3830 }
3831 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3832 int count = self->GetNumberOfFiles();
3833 wxString* files = self->GetFiles();
3834 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3835 PyObject* list = PyList_New(count);
3836
3837 if (!list) {
3838 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3839 wxPyEndBlockThreads(blocked);
3840 return NULL;
3841 }
3842
3843 for (int i=0; i<count; i++) {
3844 PyList_SetItem(list, i, wx2PyString(files[i]));
3845 }
3846 wxPyEndBlockThreads(blocked);
3847 return list;
3848 }
3849
3850
3851 SWIGINTERN wxPyApp *new_wxPyApp(){
3852 wxPythonApp = new wxPyApp();
3853 return wxPythonApp;
3854 }
3855 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3856 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3857 return wxPyTestDisplayAvailable();
3858 }
3859
3860 void wxApp_CleanUp() {
3861 __wxPyCleanup();
3862 }
3863
3864
3865 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3866
3867
3868
3869
3870
3871 SWIGINTERNINLINE PyObject *
3872 SWIG_FromCharPtr(const char *cptr)
3873 {
3874 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3875 }
3876
3877
3878 #if 0 // #ifdef __WXMAC__
3879
3880 // A dummy class that raises an exception if used...
3881 class wxEventLoop
3882 {
3883 public:
3884 wxEventLoop() { wxPyRaiseNotImplemented(); }
3885 int Run() { return 0; }
3886 void Exit(int rc = 0) {}
3887 bool Pending() const { return false; }
3888 bool Dispatch() { return false; }
3889 bool IsRunning() const { return false; }
3890 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3891 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3892 };
3893
3894 #else
3895
3896 #include <wx/evtloop.h>
3897
3898 #endif
3899
3900
3901
3902 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3903 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3904 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3905 SWIGINTERN wxFont wxVisualAttributes__get_font(wxVisualAttributes *self){ return self->font; }
3906 SWIGINTERN wxColour wxVisualAttributes__get_colFg(wxVisualAttributes *self){ return self->colFg; }
3907 SWIGINTERN wxColour wxVisualAttributes__get_colBg(wxVisualAttributes *self){ return self->colBg; }
3908 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3909 wxWindowList& list = self->GetChildren();
3910 return wxPy_ConvertList(&list);
3911 }
3912 SWIGINTERN wxWindow *wxWindow_GetTopLevelParent(wxWindow *self){
3913 return wxGetTopLevelParent(self);
3914 }
3915 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3916 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3917 #if wxUSE_HOTKEY
3918 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3919 #else
3920 return false;
3921 #endif
3922 }
3923 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3924
3925
3926
3927 return false;
3928
3929 }
3930 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3931 return wxPyGetWinHandle(self);
3932 }
3933 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3934 self->AssociateHandle((WXWidget)handle);
3935 }
3936 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3937
3938 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3939 return wxWindow::FindWindowById(id, parent);
3940 }
3941
3942 wxWindow* wxFindWindowByName( const wxString& name,
3943 const wxWindow *parent = NULL ) {
3944 return wxWindow::FindWindowByName(name, parent);
3945 }
3946
3947 wxWindow* wxFindWindowByLabel( const wxString& label,
3948 const wxWindow *parent = NULL ) {
3949 return wxWindow::FindWindowByLabel(label, parent);
3950 }
3951
3952
3953 #ifdef __WXMSW__
3954 #include <wx/msw/private.h> // to get wxGetWindowId
3955 #endif
3956
3957
3958 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3959 #ifdef __WXMSW__
3960 WXHWND hWnd = (WXHWND)_hWnd;
3961 long id = wxGetWindowId(hWnd);
3962 wxWindow* win = new wxWindow;
3963 if (parent)
3964 parent->AddChild(win);
3965 win->SetEventHandler(win);
3966 win->SetHWND(hWnd);
3967 win->SetId(id);
3968 win->SubclassWin(hWnd);
3969 win->AdoptAttributesFromHWND();
3970 win->SetupColours();
3971 return win;
3972 #else
3973 wxPyRaiseNotImplemented();
3974 return NULL;
3975 #endif
3976 }
3977
3978
3979 PyObject* GetTopLevelWindows() {
3980 return wxPy_ConvertList(&wxTopLevelWindows);
3981 }
3982
3983
3984 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3985 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3986 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3987
3988 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3989
3990
3991 SWIGINTERNINLINE int
3992 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3993 {
3994 unsigned long v;
3995 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3996 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3997 return res;
3998 }
3999
4000 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
4001 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
4002 wxMenuItemList& list = self->GetMenuItems();
4003 return wxPy_ConvertList(&list);
4004 }
4005 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
4006 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
4007 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
4008 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
4009 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
4010 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
4011 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
4012 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
4013 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
4014 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
4015 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
4016 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
4017 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
4018 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
4019 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
4020 static const wxString wxPyControlNameStr(wxControlNameStr);
4021 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
4022 if (clientData) {
4023 wxPyClientData* data = new wxPyClientData(clientData);
4024 return self->Append(item, data);
4025 } else
4026 return self->Append(item);
4027 }
4028 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
4029 if (clientData) {
4030 wxPyClientData* data = new wxPyClientData(clientData);
4031 return self->Insert(item, pos, data);
4032 } else
4033 return self->Insert(item, pos);
4034 }
4035 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
4036 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
4037 if (data) {
4038 Py_INCREF(data->m_obj);
4039 return data->m_obj;
4040 } else {
4041 Py_INCREF(Py_None);
4042 return Py_None;
4043 }
4044 }
4045 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
4046 wxPyClientData* data = new wxPyClientData(clientData);
4047 self->SetClientObject(n, data);
4048 }
4049
4050
4051 SWIGINTERN wxSizerFlags &wxSizerFlags_Border(wxSizerFlags *self,int direction=wxALL,int borderInPixels=-1){
4052 if (borderInPixels == -1)
4053 return self->Border(direction);
4054 else
4055 return self->Border(direction, borderInPixels);
4056 }
4057 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
4058 wxPyUserData* data = NULL;
4059 if ( userData ) {
4060 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4061 data = new wxPyUserData(userData);
4062 wxPyEndBlockThreads(blocked);
4063 }
4064 return new wxSizerItem(window, proportion, flag, border, data);
4065 }
4066 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
4067 wxPyUserData* data = NULL;
4068 if ( userData ) {
4069 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4070 data = new wxPyUserData(userData);
4071 wxPyEndBlockThreads(blocked);
4072 }
4073 return new wxSizerItem(width, height, proportion, flag, border, data);
4074 }
4075 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
4076 wxPyUserData* data = NULL;
4077 if ( userData ) {
4078 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4079 data = new wxPyUserData(userData);
4080 wxPyEndBlockThreads(blocked);
4081 }
4082 return new wxSizerItem(sizer, proportion, flag, border, data);
4083 }
4084
4085 SWIGINTERNINLINE PyObject *
4086 SWIG_From_float (float value)
4087 {
4088 return SWIG_From_double (value);
4089 }
4090
4091 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4092 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4093 if (data) {
4094 Py_INCREF(data->m_obj);
4095 return data->m_obj;
4096 } else {
4097 Py_INCREF(Py_None);
4098 return Py_None;
4099 }
4100 }
4101 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4102 wxPyUserData* data = NULL;
4103 if ( userData ) {
4104 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4105 data = new wxPyUserData(userData);
4106 wxPyEndBlockThreads(blocked);
4107 }
4108 self->SetUserData(data);
4109 }
4110
4111 // Figure out the type of the sizer item
4112
4113 struct wxPySizerItemInfo {
4114 wxPySizerItemInfo()
4115 : window(NULL), sizer(NULL), gotSize(false),
4116 size(wxDefaultSize), gotPos(false), pos(-1)
4117 {}
4118
4119 wxWindow* window;
4120 wxSizer* sizer;
4121 bool gotSize;
4122 wxSize size;
4123 bool gotPos;
4124 int pos;
4125 };
4126
4127 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4128
4129 wxPySizerItemInfo info;
4130 wxSize size;
4131 wxSize* sizePtr = &size;
4132
4133 // Find out what the type of the item is
4134 // try wxWindow
4135 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4136 PyErr_Clear();
4137 info.window = NULL;
4138
4139 // try wxSizer
4140 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4141 PyErr_Clear();
4142 info.sizer = NULL;
4143
4144 // try wxSize or (w,h)
4145 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4146 info.size = *sizePtr;
4147 info.gotSize = true;
4148 }
4149
4150 // or a single int
4151 if (checkIdx && PyInt_Check(item)) {
4152 info.pos = PyInt_AsLong(item);
4153 info.gotPos = true;
4154 }
4155 }
4156 }
4157
4158 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4159 // no expected type, figure out what kind of error message to generate
4160 if ( !checkSize && !checkIdx )
4161 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4162 else if ( checkSize && !checkIdx )
4163 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4164 else if ( !checkSize && checkIdx)
4165 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4166 else
4167 // can this one happen?
4168 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4169 }
4170
4171 return info;
4172 }
4173
4174 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4175 if (!self->GetClientObject())
4176 self->SetClientObject(new wxPyOORClientData(_self));
4177 }
4178 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4179
4180 wxPyUserData* data = NULL;
4181 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4182 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4183 if ( userData && (info.window || info.sizer || info.gotSize) )
4184 data = new wxPyUserData(userData);
4185 if ( info.sizer )
4186 PyObject_SetAttrString(item,"thisown",Py_False);
4187 wxPyEndBlockThreads(blocked);
4188
4189 // Now call the real Add method if a valid item type was found
4190 if ( info.window )
4191 return self->Add(info.window, proportion, flag, border, data);
4192 else if ( info.sizer )
4193 return self->Add(info.sizer, proportion, flag, border, data);
4194 else if (info.gotSize)
4195 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4196 proportion, flag, border, data);
4197 else
4198 return NULL;
4199 }
4200 SWIGINTERN wxSizerItem *wxSizer_AddF(wxSizer *self,PyObject *item,wxSizerFlags &flags){
4201
4202 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4203 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4204 if ( info.sizer )
4205 PyObject_SetAttrString(item,"thisown",Py_False);
4206 wxPyEndBlockThreads(blocked);
4207
4208 // Now call the real Add method if a valid item type was found
4209 if ( info.window )
4210 return self->Add(info.window, flags);
4211 else if ( info.sizer )
4212 return self->Add(info.sizer, flags);
4213 else if (info.gotSize)
4214 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4215 flags.GetProportion(),
4216 flags.GetFlags(),
4217 flags.GetBorderInPixels());
4218 else
4219 return NULL;
4220 }
4221 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4222
4223 wxPyUserData* data = NULL;
4224 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4225 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4226 if ( userData && (info.window || info.sizer || info.gotSize) )
4227 data = new wxPyUserData(userData);
4228 if ( info.sizer )
4229 PyObject_SetAttrString(item,"thisown",Py_False);
4230 wxPyEndBlockThreads(blocked);
4231
4232 // Now call the real Insert method if a valid item type was found
4233 if ( info.window )
4234 return self->Insert(before, info.window, proportion, flag, border, data);
4235 else if ( info.sizer )
4236 return self->Insert(before, info.sizer, proportion, flag, border, data);
4237 else if (info.gotSize)
4238 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4239 proportion, flag, border, data);
4240 else
4241 return NULL;
4242 }
4243 SWIGINTERN wxSizerItem *wxSizer_InsertF(wxSizer *self,int before,PyObject *item,wxSizerFlags &flags){
4244
4245 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4246 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4247 if ( info.sizer )
4248 PyObject_SetAttrString(item,"thisown",Py_False);
4249 wxPyEndBlockThreads(blocked);
4250
4251 // Now call the real Insert method if a valid item type was found
4252 if ( info.window )
4253 return self->Insert(before, info.window, flags);
4254 else if ( info.sizer )
4255 return self->Insert(before, info.sizer, flags);
4256 else if (info.gotSize)
4257 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4258 flags.GetProportion(),
4259 flags.GetFlags(),
4260 flags.GetBorderInPixels());
4261 else
4262 return NULL;
4263 }
4264 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4265
4266 wxPyUserData* data = NULL;
4267 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4268 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4269 if ( userData && (info.window || info.sizer || info.gotSize) )
4270 data = new wxPyUserData(userData);
4271 if ( info.sizer )
4272 PyObject_SetAttrString(item,"thisown",Py_False);
4273 wxPyEndBlockThreads(blocked);
4274
4275 // Now call the real Prepend method if a valid item type was found
4276 if ( info.window )
4277 return self->Prepend(info.window, proportion, flag, border, data);
4278 else if ( info.sizer )
4279 return self->Prepend(info.sizer, proportion, flag, border, data);
4280 else if (info.gotSize)
4281 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4282 proportion, flag, border, data);
4283 else
4284 return NULL;
4285 }
4286 SWIGINTERN wxSizerItem *wxSizer_PrependF(wxSizer *self,PyObject *item,wxSizerFlags &flags){
4287
4288 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4289 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4290 if ( info.sizer )
4291 PyObject_SetAttrString(item,"thisown",Py_False);
4292 wxPyEndBlockThreads(blocked);
4293
4294 // Now call the real Add method if a valid item type was found
4295 if ( info.window )
4296 return self->Prepend(info.window, flags);
4297 else if ( info.sizer )
4298 return self->Prepend(info.sizer, flags);
4299 else if (info.gotSize)
4300 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4301 flags.GetProportion(),
4302 flags.GetFlags(),
4303 flags.GetBorderInPixels());
4304 else
4305 return NULL;
4306 }
4307 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4308 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4309 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4310 wxPyEndBlockThreads(blocked);
4311 if ( info.window )
4312 return false; //self->Remove(info.window);
4313 else if ( info.sizer )
4314 return self->Remove(info.sizer);
4315 else if ( info.gotPos )
4316 return self->Remove(info.pos);
4317 else
4318 return false;
4319 }
4320 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4321 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4322 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4323 wxPyEndBlockThreads(blocked);
4324 if ( info.window )
4325 return self->Detach(info.window);
4326 else if ( info.sizer )
4327 return self->Detach(info.sizer);
4328 else if ( info.gotPos )
4329 return self->Detach(info.pos);
4330 else
4331 return false;
4332 }
4333 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item,bool recursive=false){
4334 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4335 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4336 wxPyEndBlockThreads(blocked);
4337 if ( info.window )
4338 return self->GetItem(info.window, recursive);
4339 else if ( info.sizer )
4340 return self->GetItem(info.sizer, recursive);
4341 else if ( info.gotPos )
4342 return self->GetItem(info.pos);
4343 else
4344 return NULL;
4345 }
4346 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4347 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4348 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4349 wxPyEndBlockThreads(blocked);
4350 if ( info.window )
4351 self->SetItemMinSize(info.window, size);
4352 else if ( info.sizer )
4353 self->SetItemMinSize(info.sizer, size);
4354 else if ( info.gotPos )
4355 self->SetItemMinSize(info.pos, size);
4356 }
4357 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4358 wxSizerItemList& list = self->GetChildren();
4359 return wxPy_ConvertList(&list);
4360 }
4361 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4362 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4363 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4364 wxPyEndBlockThreads(blocked);
4365 if ( info.window )
4366 return self->Show(info.window, show, recursive);
4367 else if ( info.sizer )
4368 return self->Show(info.sizer, show, recursive);
4369 else if ( info.gotPos )
4370 return self->Show(info.pos, show);
4371 else
4372 return false;
4373 }
4374 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4375 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4376 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4377 wxPyEndBlockThreads(blocked);
4378 if ( info.window )
4379 return self->IsShown(info.window);
4380 else if ( info.sizer )
4381 return self->IsShown(info.sizer);
4382 else if ( info.gotPos )
4383 return self->IsShown(info.pos);
4384 else
4385 return false;
4386 }
4387
4388 // See pyclasses.h
4389 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4390 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4391 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4392
4393
4394
4395
4396 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4397 {
4398 if (source == Py_None) {
4399 **obj = wxGBPosition(-1,-1);
4400 return true;
4401 }
4402 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4403 }
4404
4405 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4406 {
4407 if (source == Py_None) {
4408 **obj = wxGBSpan(-1,-1);
4409 return true;
4410 }
4411 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4412 }
4413
4414
4415 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4416 wxGBPosition temp, *obj = &temp;
4417 if ( other == Py_None ) return false;
4418 if ( ! wxGBPosition_helper(other, &obj) ) {
4419 PyErr_Clear();
4420 return false;
4421 }
4422 return self->operator==(*obj);
4423 }
4424 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4425 wxGBPosition temp, *obj = &temp;
4426 if ( other == Py_None ) return true;
4427 if ( ! wxGBPosition_helper(other, &obj)) {
4428 PyErr_Clear();
4429 return true;
4430 }
4431 return self->operator!=(*obj);
4432 }
4433 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4434 self->SetRow(row);
4435 self->SetCol(col);
4436 }
4437 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4438 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4439 PyObject* tup = PyTuple_New(2);
4440 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4441 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4442 wxPyEndBlockThreads(blocked);
4443 return tup;
4444 }
4445 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4446 wxGBSpan temp, *obj = &temp;
4447 if ( other == Py_None ) return false;
4448 if ( ! wxGBSpan_helper(other, &obj) ) {
4449 PyErr_Clear();
4450 return false;
4451 }
4452 return self->operator==(*obj);
4453 }
4454 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4455 wxGBSpan temp, *obj = &temp;
4456 if ( other == Py_None ) return true;
4457 if ( ! wxGBSpan_helper(other, &obj)) {
4458 PyErr_Clear();
4459 return true;
4460 }
4461 return self->operator!=(*obj);
4462 }
4463 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4464 self->SetRowspan(rowspan);
4465 self->SetColspan(colspan);
4466 }
4467 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4468 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4469 PyObject* tup = PyTuple_New(2);
4470 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4471 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4472 wxPyEndBlockThreads(blocked);
4473 return tup;
4474 }
4475 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4476 wxPyUserData* data = NULL;
4477 if ( userData ) {
4478 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4479 data = new wxPyUserData(userData);
4480 wxPyEndBlockThreads(blocked);
4481 }
4482 return new wxGBSizerItem(window, pos, span, flag, border, data);
4483 }
4484 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4485 wxPyUserData* data = NULL;
4486 if ( userData ) {
4487 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4488 data = new wxPyUserData(userData);
4489 wxPyEndBlockThreads(blocked);
4490 }
4491 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4492 }
4493 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4494 wxPyUserData* data = NULL;
4495 if ( userData ) {
4496 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4497 data = new wxPyUserData(userData);
4498 wxPyEndBlockThreads(blocked);
4499 }
4500 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4501 }
4502 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4503 int row, col;
4504 self->GetEndPos(row, col);
4505 return wxGBPosition(row, col);
4506 }
4507 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4508
4509 wxPyUserData* data = NULL;
4510 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4511 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4512 if ( userData && (info.window || info.sizer || info.gotSize) )
4513 data = new wxPyUserData(userData);
4514 if ( info.sizer )
4515 PyObject_SetAttrString(item,"thisown",Py_False);
4516 wxPyEndBlockThreads(blocked);
4517
4518 // Now call the real Add method if a valid item type was found
4519 if ( info.window )
4520 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4521 else if ( info.sizer )
4522 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4523 else if (info.gotSize)
4524 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4525 pos, span, flag, border, data);
4526 return NULL;
4527 }
4528
4529
4530 #ifdef __cplusplus
4531 extern "C" {
4532 #endif
4533 SWIGINTERN int EmptyString_set(PyObject *) {
4534 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4535 return 1;
4536 }
4537
4538
4539 SWIGINTERN PyObject *EmptyString_get(void) {
4540 PyObject *pyobj = 0;
4541
4542 {
4543 #if wxUSE_UNICODE
4544 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4545 #else
4546 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4547 #endif
4548 }
4549 return pyobj;
4550 }
4551
4552
4553 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4554 PyObject *resultobj = 0;
4555 wxObject *arg1 = (wxObject *) 0 ;
4556 wxString result;
4557 void *argp1 = 0 ;
4558 int res1 = 0 ;
4559 PyObject *swig_obj[1] ;
4560
4561 if (!args) SWIG_fail;
4562 swig_obj[0] = args;
4563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4564 if (!SWIG_IsOK(res1)) {
4565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4566 }
4567 arg1 = reinterpret_cast< wxObject * >(argp1);
4568 {
4569 PyThreadState* __tstate = wxPyBeginAllowThreads();
4570 result = wxObject_GetClassName(arg1);
4571 wxPyEndAllowThreads(__tstate);
4572 if (PyErr_Occurred()) SWIG_fail;
4573 }
4574 {
4575 #if wxUSE_UNICODE
4576 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4577 #else
4578 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4579 #endif
4580 }
4581 return resultobj;
4582 fail:
4583 return NULL;
4584 }
4585
4586
4587 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4588 PyObject *resultobj = 0;
4589 wxObject *arg1 = (wxObject *) 0 ;
4590 void *argp1 = 0 ;
4591 int res1 = 0 ;
4592 PyObject *swig_obj[1] ;
4593
4594 if (!args) SWIG_fail;
4595 swig_obj[0] = args;
4596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4597 if (!SWIG_IsOK(res1)) {
4598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4599 }
4600 arg1 = reinterpret_cast< wxObject * >(argp1);
4601 {
4602 PyThreadState* __tstate = wxPyBeginAllowThreads();
4603 wxObject_Destroy(arg1);
4604 wxPyEndAllowThreads(__tstate);
4605 if (PyErr_Occurred()) SWIG_fail;
4606 }
4607 resultobj = SWIG_Py_Void();
4608 return resultobj;
4609 fail:
4610 return NULL;
4611 }
4612
4613
4614 SWIGINTERN PyObject *_wrap_Object_IsSameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4615 PyObject *resultobj = 0;
4616 wxObject *arg1 = (wxObject *) 0 ;
4617 wxObject *arg2 = 0 ;
4618 bool result;
4619 void *argp1 = 0 ;
4620 int res1 = 0 ;
4621 void *argp2 = 0 ;
4622 int res2 = 0 ;
4623 PyObject * obj0 = 0 ;
4624 PyObject * obj1 = 0 ;
4625 char * kwnames[] = {
4626 (char *) "self",(char *) "p", NULL
4627 };
4628
4629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Object_IsSameAs",kwnames,&obj0,&obj1)) SWIG_fail;
4630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4631 if (!SWIG_IsOK(res1)) {
4632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_IsSameAs" "', expected argument " "1"" of type '" "wxObject const *""'");
4633 }
4634 arg1 = reinterpret_cast< wxObject * >(argp1);
4635 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxObject, 0 | 0);
4636 if (!SWIG_IsOK(res2)) {
4637 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4638 }
4639 if (!argp2) {
4640 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4641 }
4642 arg2 = reinterpret_cast< wxObject * >(argp2);
4643 {
4644 PyThreadState* __tstate = wxPyBeginAllowThreads();
4645 result = (bool)((wxObject const *)arg1)->IsSameAs((wxObject const &)*arg2);
4646 wxPyEndAllowThreads(__tstate);
4647 if (PyErr_Occurred()) SWIG_fail;
4648 }
4649 {
4650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4651 }
4652 return resultobj;
4653 fail:
4654 return NULL;
4655 }
4656
4657
4658 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4659 PyObject *obj;
4660 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4661 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4662 return SWIG_Py_Void();
4663 }
4664
4665 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4666 PyObject *resultobj = 0;
4667 wxSize *arg1 = (wxSize *) 0 ;
4668 int arg2 ;
4669 void *argp1 = 0 ;
4670 int res1 = 0 ;
4671 int val2 ;
4672 int ecode2 = 0 ;
4673 PyObject *swig_obj[2] ;
4674
4675 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4677 if (!SWIG_IsOK(res1)) {
4678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4679 }
4680 arg1 = reinterpret_cast< wxSize * >(argp1);
4681 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4682 if (!SWIG_IsOK(ecode2)) {
4683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4684 }
4685 arg2 = static_cast< int >(val2);
4686 if (arg1) (arg1)->x = arg2;
4687
4688 resultobj = SWIG_Py_Void();
4689 return resultobj;
4690 fail:
4691 return NULL;
4692 }
4693
4694
4695 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4696 PyObject *resultobj = 0;
4697 wxSize *arg1 = (wxSize *) 0 ;
4698 int result;
4699 void *argp1 = 0 ;
4700 int res1 = 0 ;
4701 PyObject *swig_obj[1] ;
4702
4703 if (!args) SWIG_fail;
4704 swig_obj[0] = args;
4705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4706 if (!SWIG_IsOK(res1)) {
4707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4708 }
4709 arg1 = reinterpret_cast< wxSize * >(argp1);
4710 result = (int) ((arg1)->x);
4711 resultobj = SWIG_From_int(static_cast< int >(result));
4712 return resultobj;
4713 fail:
4714 return NULL;
4715 }
4716
4717
4718 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4719 PyObject *resultobj = 0;
4720 wxSize *arg1 = (wxSize *) 0 ;
4721 int arg2 ;
4722 void *argp1 = 0 ;
4723 int res1 = 0 ;
4724 int val2 ;
4725 int ecode2 = 0 ;
4726 PyObject *swig_obj[2] ;
4727
4728 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4730 if (!SWIG_IsOK(res1)) {
4731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4732 }
4733 arg1 = reinterpret_cast< wxSize * >(argp1);
4734 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4735 if (!SWIG_IsOK(ecode2)) {
4736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4737 }
4738 arg2 = static_cast< int >(val2);
4739 if (arg1) (arg1)->y = arg2;
4740
4741 resultobj = SWIG_Py_Void();
4742 return resultobj;
4743 fail:
4744 return NULL;
4745 }
4746
4747
4748 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4749 PyObject *resultobj = 0;
4750 wxSize *arg1 = (wxSize *) 0 ;
4751 int result;
4752 void *argp1 = 0 ;
4753 int res1 = 0 ;
4754 PyObject *swig_obj[1] ;
4755
4756 if (!args) SWIG_fail;
4757 swig_obj[0] = args;
4758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4759 if (!SWIG_IsOK(res1)) {
4760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4761 }
4762 arg1 = reinterpret_cast< wxSize * >(argp1);
4763 result = (int) ((arg1)->y);
4764 resultobj = SWIG_From_int(static_cast< int >(result));
4765 return resultobj;
4766 fail:
4767 return NULL;
4768 }
4769
4770
4771 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4772 PyObject *resultobj = 0;
4773 int arg1 = (int) 0 ;
4774 int arg2 = (int) 0 ;
4775 wxSize *result = 0 ;
4776 int val1 ;
4777 int ecode1 = 0 ;
4778 int val2 ;
4779 int ecode2 = 0 ;
4780 PyObject * obj0 = 0 ;
4781 PyObject * obj1 = 0 ;
4782 char * kwnames[] = {
4783 (char *) "w",(char *) "h", NULL
4784 };
4785
4786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4787 if (obj0) {
4788 ecode1 = SWIG_AsVal_int(obj0, &val1);
4789 if (!SWIG_IsOK(ecode1)) {
4790 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4791 }
4792 arg1 = static_cast< int >(val1);
4793 }
4794 if (obj1) {
4795 ecode2 = SWIG_AsVal_int(obj1, &val2);
4796 if (!SWIG_IsOK(ecode2)) {
4797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4798 }
4799 arg2 = static_cast< int >(val2);
4800 }
4801 {
4802 result = (wxSize *)new wxSize(arg1,arg2);
4803 if (PyErr_Occurred()) SWIG_fail;
4804 }
4805 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4806 return resultobj;
4807 fail:
4808 return NULL;
4809 }
4810
4811
4812 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4813 PyObject *resultobj = 0;
4814 wxSize *arg1 = (wxSize *) 0 ;
4815 void *argp1 = 0 ;
4816 int res1 = 0 ;
4817 PyObject *swig_obj[1] ;
4818
4819 if (!args) SWIG_fail;
4820 swig_obj[0] = args;
4821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4822 if (!SWIG_IsOK(res1)) {
4823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4824 }
4825 arg1 = reinterpret_cast< wxSize * >(argp1);
4826 {
4827 delete arg1;
4828
4829 if (PyErr_Occurred()) SWIG_fail;
4830 }
4831 resultobj = SWIG_Py_Void();
4832 return resultobj;
4833 fail:
4834 return NULL;
4835 }
4836
4837
4838 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4839 PyObject *resultobj = 0;
4840 wxSize *arg1 = (wxSize *) 0 ;
4841 PyObject *arg2 = (PyObject *) 0 ;
4842 bool result;
4843 void *argp1 = 0 ;
4844 int res1 = 0 ;
4845 PyObject * obj0 = 0 ;
4846 PyObject * obj1 = 0 ;
4847 char * kwnames[] = {
4848 (char *) "self",(char *) "other", NULL
4849 };
4850
4851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4853 if (!SWIG_IsOK(res1)) {
4854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4855 }
4856 arg1 = reinterpret_cast< wxSize * >(argp1);
4857 arg2 = obj1;
4858 {
4859 result = (bool)wxSize___eq__(arg1,arg2);
4860 if (PyErr_Occurred()) SWIG_fail;
4861 }
4862 {
4863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4864 }
4865 return resultobj;
4866 fail:
4867 return NULL;
4868 }
4869
4870
4871 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4872 PyObject *resultobj = 0;
4873 wxSize *arg1 = (wxSize *) 0 ;
4874 PyObject *arg2 = (PyObject *) 0 ;
4875 bool result;
4876 void *argp1 = 0 ;
4877 int res1 = 0 ;
4878 PyObject * obj0 = 0 ;
4879 PyObject * obj1 = 0 ;
4880 char * kwnames[] = {
4881 (char *) "self",(char *) "other", NULL
4882 };
4883
4884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4886 if (!SWIG_IsOK(res1)) {
4887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4888 }
4889 arg1 = reinterpret_cast< wxSize * >(argp1);
4890 arg2 = obj1;
4891 {
4892 result = (bool)wxSize___ne__(arg1,arg2);
4893 if (PyErr_Occurred()) SWIG_fail;
4894 }
4895 {
4896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4897 }
4898 return resultobj;
4899 fail:
4900 return NULL;
4901 }
4902
4903
4904 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4905 PyObject *resultobj = 0;
4906 wxSize *arg1 = (wxSize *) 0 ;
4907 wxSize *arg2 = 0 ;
4908 wxSize result;
4909 void *argp1 = 0 ;
4910 int res1 = 0 ;
4911 wxSize temp2 ;
4912 PyObject * obj0 = 0 ;
4913 PyObject * obj1 = 0 ;
4914 char * kwnames[] = {
4915 (char *) "self",(char *) "sz", NULL
4916 };
4917
4918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4920 if (!SWIG_IsOK(res1)) {
4921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4922 }
4923 arg1 = reinterpret_cast< wxSize * >(argp1);
4924 {
4925 arg2 = &temp2;
4926 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4927 }
4928 {
4929 result = (arg1)->operator +((wxSize const &)*arg2);
4930 if (PyErr_Occurred()) SWIG_fail;
4931 }
4932 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4933 return resultobj;
4934 fail:
4935 return NULL;
4936 }
4937
4938
4939 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4940 PyObject *resultobj = 0;
4941 wxSize *arg1 = (wxSize *) 0 ;
4942 wxSize *arg2 = 0 ;
4943 wxSize result;
4944 void *argp1 = 0 ;
4945 int res1 = 0 ;
4946 wxSize temp2 ;
4947 PyObject * obj0 = 0 ;
4948 PyObject * obj1 = 0 ;
4949 char * kwnames[] = {
4950 (char *) "self",(char *) "sz", NULL
4951 };
4952
4953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4955 if (!SWIG_IsOK(res1)) {
4956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4957 }
4958 arg1 = reinterpret_cast< wxSize * >(argp1);
4959 {
4960 arg2 = &temp2;
4961 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4962 }
4963 {
4964 result = (arg1)->operator -((wxSize const &)*arg2);
4965 if (PyErr_Occurred()) SWIG_fail;
4966 }
4967 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4968 return resultobj;
4969 fail:
4970 return NULL;
4971 }
4972
4973
4974 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4975 PyObject *resultobj = 0;
4976 wxSize *arg1 = (wxSize *) 0 ;
4977 wxSize *arg2 = 0 ;
4978 void *argp1 = 0 ;
4979 int res1 = 0 ;
4980 wxSize temp2 ;
4981 PyObject * obj0 = 0 ;
4982 PyObject * obj1 = 0 ;
4983 char * kwnames[] = {
4984 (char *) "self",(char *) "sz", NULL
4985 };
4986
4987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4989 if (!SWIG_IsOK(res1)) {
4990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4991 }
4992 arg1 = reinterpret_cast< wxSize * >(argp1);
4993 {
4994 arg2 = &temp2;
4995 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4996 }
4997 {
4998 (arg1)->IncTo((wxSize const &)*arg2);
4999 if (PyErr_Occurred()) SWIG_fail;
5000 }
5001 resultobj = SWIG_Py_Void();
5002 return resultobj;
5003 fail:
5004 return NULL;
5005 }
5006
5007
5008 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5009 PyObject *resultobj = 0;
5010 wxSize *arg1 = (wxSize *) 0 ;
5011 wxSize *arg2 = 0 ;
5012 void *argp1 = 0 ;
5013 int res1 = 0 ;
5014 wxSize temp2 ;
5015 PyObject * obj0 = 0 ;
5016 PyObject * obj1 = 0 ;
5017 char * kwnames[] = {
5018 (char *) "self",(char *) "sz", NULL
5019 };
5020
5021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
5022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5023 if (!SWIG_IsOK(res1)) {
5024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
5025 }
5026 arg1 = reinterpret_cast< wxSize * >(argp1);
5027 {
5028 arg2 = &temp2;
5029 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5030 }
5031 {
5032 (arg1)->DecTo((wxSize const &)*arg2);
5033 if (PyErr_Occurred()) SWIG_fail;
5034 }
5035 resultobj = SWIG_Py_Void();
5036 return resultobj;
5037 fail:
5038 return NULL;
5039 }
5040
5041
5042 SWIGINTERN PyObject *_wrap_Size_IncBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5043 PyObject *resultobj = 0;
5044 wxSize *arg1 = (wxSize *) 0 ;
5045 int arg2 ;
5046 int arg3 ;
5047 void *argp1 = 0 ;
5048 int res1 = 0 ;
5049 int val2 ;
5050 int ecode2 = 0 ;
5051 int val3 ;
5052 int ecode3 = 0 ;
5053 PyObject * obj0 = 0 ;
5054 PyObject * obj1 = 0 ;
5055 PyObject * obj2 = 0 ;
5056 char * kwnames[] = {
5057 (char *) "self",(char *) "dx",(char *) "dy", NULL
5058 };
5059
5060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_IncBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5062 if (!SWIG_IsOK(res1)) {
5063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncBy" "', expected argument " "1"" of type '" "wxSize *""'");
5064 }
5065 arg1 = reinterpret_cast< wxSize * >(argp1);
5066 ecode2 = SWIG_AsVal_int(obj1, &val2);
5067 if (!SWIG_IsOK(ecode2)) {
5068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_IncBy" "', expected argument " "2"" of type '" "int""'");
5069 }
5070 arg2 = static_cast< int >(val2);
5071 ecode3 = SWIG_AsVal_int(obj2, &val3);
5072 if (!SWIG_IsOK(ecode3)) {
5073 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_IncBy" "', expected argument " "3"" of type '" "int""'");
5074 }
5075 arg3 = static_cast< int >(val3);
5076 {
5077 (arg1)->IncBy(arg2,arg3);
5078 if (PyErr_Occurred()) SWIG_fail;
5079 }
5080 resultobj = SWIG_Py_Void();
5081 return resultobj;
5082 fail:
5083 return NULL;
5084 }
5085
5086
5087 SWIGINTERN PyObject *_wrap_Size_DecBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5088 PyObject *resultobj = 0;
5089 wxSize *arg1 = (wxSize *) 0 ;
5090 int arg2 ;
5091 int arg3 ;
5092 void *argp1 = 0 ;
5093 int res1 = 0 ;
5094 int val2 ;
5095 int ecode2 = 0 ;
5096 int val3 ;
5097 int ecode3 = 0 ;
5098 PyObject * obj0 = 0 ;
5099 PyObject * obj1 = 0 ;
5100 PyObject * obj2 = 0 ;
5101 char * kwnames[] = {
5102 (char *) "self",(char *) "dx",(char *) "dy", NULL
5103 };
5104
5105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_DecBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5107 if (!SWIG_IsOK(res1)) {
5108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecBy" "', expected argument " "1"" of type '" "wxSize *""'");
5109 }
5110 arg1 = reinterpret_cast< wxSize * >(argp1);
5111 ecode2 = SWIG_AsVal_int(obj1, &val2);
5112 if (!SWIG_IsOK(ecode2)) {
5113 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_DecBy" "', expected argument " "2"" of type '" "int""'");
5114 }
5115 arg2 = static_cast< int >(val2);
5116 ecode3 = SWIG_AsVal_int(obj2, &val3);
5117 if (!SWIG_IsOK(ecode3)) {
5118 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_DecBy" "', expected argument " "3"" of type '" "int""'");
5119 }
5120 arg3 = static_cast< int >(val3);
5121 {
5122 (arg1)->DecBy(arg2,arg3);
5123 if (PyErr_Occurred()) SWIG_fail;
5124 }
5125 resultobj = SWIG_Py_Void();
5126 return resultobj;
5127 fail:
5128 return NULL;
5129 }
5130
5131
5132 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5133 PyObject *resultobj = 0;
5134 wxSize *arg1 = (wxSize *) 0 ;
5135 float arg2 ;
5136 float arg3 ;
5137 void *argp1 = 0 ;
5138 int res1 = 0 ;
5139 float val2 ;
5140 int ecode2 = 0 ;
5141 float val3 ;
5142 int ecode3 = 0 ;
5143 PyObject * obj0 = 0 ;
5144 PyObject * obj1 = 0 ;
5145 PyObject * obj2 = 0 ;
5146 char * kwnames[] = {
5147 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
5148 };
5149
5150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5152 if (!SWIG_IsOK(res1)) {
5153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
5154 }
5155 arg1 = reinterpret_cast< wxSize * >(argp1);
5156 ecode2 = SWIG_AsVal_float(obj1, &val2);
5157 if (!SWIG_IsOK(ecode2)) {
5158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
5159 }
5160 arg2 = static_cast< float >(val2);
5161 ecode3 = SWIG_AsVal_float(obj2, &val3);
5162 if (!SWIG_IsOK(ecode3)) {
5163 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
5164 }
5165 arg3 = static_cast< float >(val3);
5166 {
5167 (arg1)->Scale(arg2,arg3);
5168 if (PyErr_Occurred()) SWIG_fail;
5169 }
5170 resultobj = SWIG_Py_Void();
5171 return resultobj;
5172 fail:
5173 return NULL;
5174 }
5175
5176
5177 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5178 PyObject *resultobj = 0;
5179 wxSize *arg1 = (wxSize *) 0 ;
5180 int arg2 ;
5181 int arg3 ;
5182 void *argp1 = 0 ;
5183 int res1 = 0 ;
5184 int val2 ;
5185 int ecode2 = 0 ;
5186 int val3 ;
5187 int ecode3 = 0 ;
5188 PyObject * obj0 = 0 ;
5189 PyObject * obj1 = 0 ;
5190 PyObject * obj2 = 0 ;
5191 char * kwnames[] = {
5192 (char *) "self",(char *) "w",(char *) "h", NULL
5193 };
5194
5195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5197 if (!SWIG_IsOK(res1)) {
5198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
5199 }
5200 arg1 = reinterpret_cast< wxSize * >(argp1);
5201 ecode2 = SWIG_AsVal_int(obj1, &val2);
5202 if (!SWIG_IsOK(ecode2)) {
5203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
5204 }
5205 arg2 = static_cast< int >(val2);
5206 ecode3 = SWIG_AsVal_int(obj2, &val3);
5207 if (!SWIG_IsOK(ecode3)) {
5208 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
5209 }
5210 arg3 = static_cast< int >(val3);
5211 {
5212 (arg1)->Set(arg2,arg3);
5213 if (PyErr_Occurred()) SWIG_fail;
5214 }
5215 resultobj = SWIG_Py_Void();
5216 return resultobj;
5217 fail:
5218 return NULL;
5219 }
5220
5221
5222 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5223 PyObject *resultobj = 0;
5224 wxSize *arg1 = (wxSize *) 0 ;
5225 int arg2 ;
5226 void *argp1 = 0 ;
5227 int res1 = 0 ;
5228 int val2 ;
5229 int ecode2 = 0 ;
5230 PyObject * obj0 = 0 ;
5231 PyObject * obj1 = 0 ;
5232 char * kwnames[] = {
5233 (char *) "self",(char *) "w", NULL
5234 };
5235
5236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
5237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5238 if (!SWIG_IsOK(res1)) {
5239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
5240 }
5241 arg1 = reinterpret_cast< wxSize * >(argp1);
5242 ecode2 = SWIG_AsVal_int(obj1, &val2);
5243 if (!SWIG_IsOK(ecode2)) {
5244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
5245 }
5246 arg2 = static_cast< int >(val2);
5247 {
5248 (arg1)->SetWidth(arg2);
5249 if (PyErr_Occurred()) SWIG_fail;
5250 }
5251 resultobj = SWIG_Py_Void();
5252 return resultobj;
5253 fail:
5254 return NULL;
5255 }
5256
5257
5258 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5259 PyObject *resultobj = 0;
5260 wxSize *arg1 = (wxSize *) 0 ;
5261 int arg2 ;
5262 void *argp1 = 0 ;
5263 int res1 = 0 ;
5264 int val2 ;
5265 int ecode2 = 0 ;
5266 PyObject * obj0 = 0 ;
5267 PyObject * obj1 = 0 ;
5268 char * kwnames[] = {
5269 (char *) "self",(char *) "h", NULL
5270 };
5271
5272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5274 if (!SWIG_IsOK(res1)) {
5275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5276 }
5277 arg1 = reinterpret_cast< wxSize * >(argp1);
5278 ecode2 = SWIG_AsVal_int(obj1, &val2);
5279 if (!SWIG_IsOK(ecode2)) {
5280 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5281 }
5282 arg2 = static_cast< int >(val2);
5283 {
5284 (arg1)->SetHeight(arg2);
5285 if (PyErr_Occurred()) SWIG_fail;
5286 }
5287 resultobj = SWIG_Py_Void();
5288 return resultobj;
5289 fail:
5290 return NULL;
5291 }
5292
5293
5294 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5295 PyObject *resultobj = 0;
5296 wxSize *arg1 = (wxSize *) 0 ;
5297 int result;
5298 void *argp1 = 0 ;
5299 int res1 = 0 ;
5300 PyObject *swig_obj[1] ;
5301
5302 if (!args) SWIG_fail;
5303 swig_obj[0] = args;
5304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5305 if (!SWIG_IsOK(res1)) {
5306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5307 }
5308 arg1 = reinterpret_cast< wxSize * >(argp1);
5309 {
5310 result = (int)((wxSize const *)arg1)->GetWidth();
5311 if (PyErr_Occurred()) SWIG_fail;
5312 }
5313 resultobj = SWIG_From_int(static_cast< int >(result));
5314 return resultobj;
5315 fail:
5316 return NULL;
5317 }
5318
5319
5320 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5321 PyObject *resultobj = 0;
5322 wxSize *arg1 = (wxSize *) 0 ;
5323 int result;
5324 void *argp1 = 0 ;
5325 int res1 = 0 ;
5326 PyObject *swig_obj[1] ;
5327
5328 if (!args) SWIG_fail;
5329 swig_obj[0] = args;
5330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5331 if (!SWIG_IsOK(res1)) {
5332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5333 }
5334 arg1 = reinterpret_cast< wxSize * >(argp1);
5335 {
5336 result = (int)((wxSize const *)arg1)->GetHeight();
5337 if (PyErr_Occurred()) SWIG_fail;
5338 }
5339 resultobj = SWIG_From_int(static_cast< int >(result));
5340 return resultobj;
5341 fail:
5342 return NULL;
5343 }
5344
5345
5346 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5347 PyObject *resultobj = 0;
5348 wxSize *arg1 = (wxSize *) 0 ;
5349 bool result;
5350 void *argp1 = 0 ;
5351 int res1 = 0 ;
5352 PyObject *swig_obj[1] ;
5353
5354 if (!args) SWIG_fail;
5355 swig_obj[0] = args;
5356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5357 if (!SWIG_IsOK(res1)) {
5358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5359 }
5360 arg1 = reinterpret_cast< wxSize * >(argp1);
5361 {
5362 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5363 if (PyErr_Occurred()) SWIG_fail;
5364 }
5365 {
5366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5367 }
5368 return resultobj;
5369 fail:
5370 return NULL;
5371 }
5372
5373
5374 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5375 PyObject *resultobj = 0;
5376 wxSize *arg1 = (wxSize *) 0 ;
5377 wxSize *arg2 = 0 ;
5378 void *argp1 = 0 ;
5379 int res1 = 0 ;
5380 wxSize temp2 ;
5381 PyObject * obj0 = 0 ;
5382 PyObject * obj1 = 0 ;
5383 char * kwnames[] = {
5384 (char *) "self",(char *) "size", NULL
5385 };
5386
5387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5389 if (!SWIG_IsOK(res1)) {
5390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5391 }
5392 arg1 = reinterpret_cast< wxSize * >(argp1);
5393 {
5394 arg2 = &temp2;
5395 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5396 }
5397 {
5398 (arg1)->SetDefaults((wxSize const &)*arg2);
5399 if (PyErr_Occurred()) SWIG_fail;
5400 }
5401 resultobj = SWIG_Py_Void();
5402 return resultobj;
5403 fail:
5404 return NULL;
5405 }
5406
5407
5408 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5409 PyObject *resultobj = 0;
5410 wxSize *arg1 = (wxSize *) 0 ;
5411 PyObject *result = 0 ;
5412 void *argp1 = 0 ;
5413 int res1 = 0 ;
5414 PyObject *swig_obj[1] ;
5415
5416 if (!args) SWIG_fail;
5417 swig_obj[0] = args;
5418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5419 if (!SWIG_IsOK(res1)) {
5420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5421 }
5422 arg1 = reinterpret_cast< wxSize * >(argp1);
5423 {
5424 result = (PyObject *)wxSize_Get(arg1);
5425 if (PyErr_Occurred()) SWIG_fail;
5426 }
5427 resultobj = result;
5428 return resultobj;
5429 fail:
5430 return NULL;
5431 }
5432
5433
5434 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5435 PyObject *obj;
5436 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5437 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5438 return SWIG_Py_Void();
5439 }
5440
5441 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5442 return SWIG_Python_InitShadowInstance(args);
5443 }
5444
5445 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5446 PyObject *resultobj = 0;
5447 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5448 double arg2 ;
5449 void *argp1 = 0 ;
5450 int res1 = 0 ;
5451 double val2 ;
5452 int ecode2 = 0 ;
5453 PyObject *swig_obj[2] ;
5454
5455 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5457 if (!SWIG_IsOK(res1)) {
5458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5459 }
5460 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5461 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5462 if (!SWIG_IsOK(ecode2)) {
5463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5464 }
5465 arg2 = static_cast< double >(val2);
5466 if (arg1) (arg1)->x = arg2;
5467
5468 resultobj = SWIG_Py_Void();
5469 return resultobj;
5470 fail:
5471 return NULL;
5472 }
5473
5474
5475 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5476 PyObject *resultobj = 0;
5477 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5478 double result;
5479 void *argp1 = 0 ;
5480 int res1 = 0 ;
5481 PyObject *swig_obj[1] ;
5482
5483 if (!args) SWIG_fail;
5484 swig_obj[0] = args;
5485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5486 if (!SWIG_IsOK(res1)) {
5487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5488 }
5489 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5490 result = (double) ((arg1)->x);
5491 resultobj = SWIG_From_double(static_cast< double >(result));
5492 return resultobj;
5493 fail:
5494 return NULL;
5495 }
5496
5497
5498 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5499 PyObject *resultobj = 0;
5500 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5501 double arg2 ;
5502 void *argp1 = 0 ;
5503 int res1 = 0 ;
5504 double val2 ;
5505 int ecode2 = 0 ;
5506 PyObject *swig_obj[2] ;
5507
5508 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5510 if (!SWIG_IsOK(res1)) {
5511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5512 }
5513 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5514 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5515 if (!SWIG_IsOK(ecode2)) {
5516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5517 }
5518 arg2 = static_cast< double >(val2);
5519 if (arg1) (arg1)->y = arg2;
5520
5521 resultobj = SWIG_Py_Void();
5522 return resultobj;
5523 fail:
5524 return NULL;
5525 }
5526
5527
5528 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5529 PyObject *resultobj = 0;
5530 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5531 double result;
5532 void *argp1 = 0 ;
5533 int res1 = 0 ;
5534 PyObject *swig_obj[1] ;
5535
5536 if (!args) SWIG_fail;
5537 swig_obj[0] = args;
5538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5539 if (!SWIG_IsOK(res1)) {
5540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5541 }
5542 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5543 result = (double) ((arg1)->y);
5544 resultobj = SWIG_From_double(static_cast< double >(result));
5545 return resultobj;
5546 fail:
5547 return NULL;
5548 }
5549
5550
5551 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5552 PyObject *resultobj = 0;
5553 double arg1 = (double) 0.0 ;
5554 double arg2 = (double) 0.0 ;
5555 wxRealPoint *result = 0 ;
5556 double val1 ;
5557 int ecode1 = 0 ;
5558 double val2 ;
5559 int ecode2 = 0 ;
5560 PyObject * obj0 = 0 ;
5561 PyObject * obj1 = 0 ;
5562 char * kwnames[] = {
5563 (char *) "x",(char *) "y", NULL
5564 };
5565
5566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5567 if (obj0) {
5568 ecode1 = SWIG_AsVal_double(obj0, &val1);
5569 if (!SWIG_IsOK(ecode1)) {
5570 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5571 }
5572 arg1 = static_cast< double >(val1);
5573 }
5574 if (obj1) {
5575 ecode2 = SWIG_AsVal_double(obj1, &val2);
5576 if (!SWIG_IsOK(ecode2)) {
5577 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5578 }
5579 arg2 = static_cast< double >(val2);
5580 }
5581 {
5582 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5583 if (PyErr_Occurred()) SWIG_fail;
5584 }
5585 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5586 return resultobj;
5587 fail:
5588 return NULL;
5589 }
5590
5591
5592 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5593 PyObject *resultobj = 0;
5594 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5595 void *argp1 = 0 ;
5596 int res1 = 0 ;
5597 PyObject *swig_obj[1] ;
5598
5599 if (!args) SWIG_fail;
5600 swig_obj[0] = args;
5601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5602 if (!SWIG_IsOK(res1)) {
5603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5604 }
5605 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5606 {
5607 delete arg1;
5608
5609 if (PyErr_Occurred()) SWIG_fail;
5610 }
5611 resultobj = SWIG_Py_Void();
5612 return resultobj;
5613 fail:
5614 return NULL;
5615 }
5616
5617
5618 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5619 PyObject *resultobj = 0;
5620 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5621 PyObject *arg2 = (PyObject *) 0 ;
5622 bool result;
5623 void *argp1 = 0 ;
5624 int res1 = 0 ;
5625 PyObject * obj0 = 0 ;
5626 PyObject * obj1 = 0 ;
5627 char * kwnames[] = {
5628 (char *) "self",(char *) "other", NULL
5629 };
5630
5631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5633 if (!SWIG_IsOK(res1)) {
5634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5635 }
5636 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5637 arg2 = obj1;
5638 {
5639 result = (bool)wxRealPoint___eq__(arg1,arg2);
5640 if (PyErr_Occurred()) SWIG_fail;
5641 }
5642 {
5643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5644 }
5645 return resultobj;
5646 fail:
5647 return NULL;
5648 }
5649
5650
5651 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5652 PyObject *resultobj = 0;
5653 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5654 PyObject *arg2 = (PyObject *) 0 ;
5655 bool result;
5656 void *argp1 = 0 ;
5657 int res1 = 0 ;
5658 PyObject * obj0 = 0 ;
5659 PyObject * obj1 = 0 ;
5660 char * kwnames[] = {
5661 (char *) "self",(char *) "other", NULL
5662 };
5663
5664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5666 if (!SWIG_IsOK(res1)) {
5667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5668 }
5669 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5670 arg2 = obj1;
5671 {
5672 result = (bool)wxRealPoint___ne__(arg1,arg2);
5673 if (PyErr_Occurred()) SWIG_fail;
5674 }
5675 {
5676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5677 }
5678 return resultobj;
5679 fail:
5680 return NULL;
5681 }
5682
5683
5684 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5685 PyObject *resultobj = 0;
5686 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5687 wxRealPoint *arg2 = 0 ;
5688 wxRealPoint result;
5689 void *argp1 = 0 ;
5690 int res1 = 0 ;
5691 wxRealPoint temp2 ;
5692 PyObject * obj0 = 0 ;
5693 PyObject * obj1 = 0 ;
5694 char * kwnames[] = {
5695 (char *) "self",(char *) "pt", NULL
5696 };
5697
5698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5700 if (!SWIG_IsOK(res1)) {
5701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5702 }
5703 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5704 {
5705 arg2 = &temp2;
5706 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5707 }
5708 {
5709 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5710 if (PyErr_Occurred()) SWIG_fail;
5711 }
5712 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5713 return resultobj;
5714 fail:
5715 return NULL;
5716 }
5717
5718
5719 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5720 PyObject *resultobj = 0;
5721 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5722 wxRealPoint *arg2 = 0 ;
5723 wxRealPoint result;
5724 void *argp1 = 0 ;
5725 int res1 = 0 ;
5726 wxRealPoint temp2 ;
5727 PyObject * obj0 = 0 ;
5728 PyObject * obj1 = 0 ;
5729 char * kwnames[] = {
5730 (char *) "self",(char *) "pt", NULL
5731 };
5732
5733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5735 if (!SWIG_IsOK(res1)) {
5736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5737 }
5738 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5739 {
5740 arg2 = &temp2;
5741 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5742 }
5743 {
5744 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5745 if (PyErr_Occurred()) SWIG_fail;
5746 }
5747 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5748 return resultobj;
5749 fail:
5750 return NULL;
5751 }
5752
5753
5754 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5755 PyObject *resultobj = 0;
5756 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5757 double arg2 ;
5758 double arg3 ;
5759 void *argp1 = 0 ;
5760 int res1 = 0 ;
5761 double val2 ;
5762 int ecode2 = 0 ;
5763 double val3 ;
5764 int ecode3 = 0 ;
5765 PyObject * obj0 = 0 ;
5766 PyObject * obj1 = 0 ;
5767 PyObject * obj2 = 0 ;
5768 char * kwnames[] = {
5769 (char *) "self",(char *) "x",(char *) "y", NULL
5770 };
5771
5772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5774 if (!SWIG_IsOK(res1)) {
5775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5776 }
5777 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5778 ecode2 = SWIG_AsVal_double(obj1, &val2);
5779 if (!SWIG_IsOK(ecode2)) {
5780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5781 }
5782 arg2 = static_cast< double >(val2);
5783 ecode3 = SWIG_AsVal_double(obj2, &val3);
5784 if (!SWIG_IsOK(ecode3)) {
5785 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5786 }
5787 arg3 = static_cast< double >(val3);
5788 {
5789 wxRealPoint_Set(arg1,arg2,arg3);
5790 if (PyErr_Occurred()) SWIG_fail;
5791 }
5792 resultobj = SWIG_Py_Void();
5793 return resultobj;
5794 fail:
5795 return NULL;
5796 }
5797
5798
5799 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5800 PyObject *resultobj = 0;
5801 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5802 PyObject *result = 0 ;
5803 void *argp1 = 0 ;
5804 int res1 = 0 ;
5805 PyObject *swig_obj[1] ;
5806
5807 if (!args) SWIG_fail;
5808 swig_obj[0] = args;
5809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5810 if (!SWIG_IsOK(res1)) {
5811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5812 }
5813 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5814 {
5815 result = (PyObject *)wxRealPoint_Get(arg1);
5816 if (PyErr_Occurred()) SWIG_fail;
5817 }
5818 resultobj = result;
5819 return resultobj;
5820 fail:
5821 return NULL;
5822 }
5823
5824
5825 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5826 PyObject *obj;
5827 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5828 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5829 return SWIG_Py_Void();
5830 }
5831
5832 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5833 return SWIG_Python_InitShadowInstance(args);
5834 }
5835
5836 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5837 PyObject *resultobj = 0;
5838 wxPoint *arg1 = (wxPoint *) 0 ;
5839 int arg2 ;
5840 void *argp1 = 0 ;
5841 int res1 = 0 ;
5842 int val2 ;
5843 int ecode2 = 0 ;
5844 PyObject *swig_obj[2] ;
5845
5846 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5848 if (!SWIG_IsOK(res1)) {
5849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5850 }
5851 arg1 = reinterpret_cast< wxPoint * >(argp1);
5852 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5853 if (!SWIG_IsOK(ecode2)) {
5854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5855 }
5856 arg2 = static_cast< int >(val2);
5857 if (arg1) (arg1)->x = arg2;
5858
5859 resultobj = SWIG_Py_Void();
5860 return resultobj;
5861 fail:
5862 return NULL;
5863 }
5864
5865
5866 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5867 PyObject *resultobj = 0;
5868 wxPoint *arg1 = (wxPoint *) 0 ;
5869 int result;
5870 void *argp1 = 0 ;
5871 int res1 = 0 ;
5872 PyObject *swig_obj[1] ;
5873
5874 if (!args) SWIG_fail;
5875 swig_obj[0] = args;
5876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5877 if (!SWIG_IsOK(res1)) {
5878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5879 }
5880 arg1 = reinterpret_cast< wxPoint * >(argp1);
5881 result = (int) ((arg1)->x);
5882 resultobj = SWIG_From_int(static_cast< int >(result));
5883 return resultobj;
5884 fail:
5885 return NULL;
5886 }
5887
5888
5889 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5890 PyObject *resultobj = 0;
5891 wxPoint *arg1 = (wxPoint *) 0 ;
5892 int arg2 ;
5893 void *argp1 = 0 ;
5894 int res1 = 0 ;
5895 int val2 ;
5896 int ecode2 = 0 ;
5897 PyObject *swig_obj[2] ;
5898
5899 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5901 if (!SWIG_IsOK(res1)) {
5902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5903 }
5904 arg1 = reinterpret_cast< wxPoint * >(argp1);
5905 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5906 if (!SWIG_IsOK(ecode2)) {
5907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5908 }
5909 arg2 = static_cast< int >(val2);
5910 if (arg1) (arg1)->y = arg2;
5911
5912 resultobj = SWIG_Py_Void();
5913 return resultobj;
5914 fail:
5915 return NULL;
5916 }
5917
5918
5919 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5920 PyObject *resultobj = 0;
5921 wxPoint *arg1 = (wxPoint *) 0 ;
5922 int result;
5923 void *argp1 = 0 ;
5924 int res1 = 0 ;
5925 PyObject *swig_obj[1] ;
5926
5927 if (!args) SWIG_fail;
5928 swig_obj[0] = args;
5929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5930 if (!SWIG_IsOK(res1)) {
5931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5932 }
5933 arg1 = reinterpret_cast< wxPoint * >(argp1);
5934 result = (int) ((arg1)->y);
5935 resultobj = SWIG_From_int(static_cast< int >(result));
5936 return resultobj;
5937 fail:
5938 return NULL;
5939 }
5940
5941
5942 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5943 PyObject *resultobj = 0;
5944 int arg1 = (int) 0 ;
5945 int arg2 = (int) 0 ;
5946 wxPoint *result = 0 ;
5947 int val1 ;
5948 int ecode1 = 0 ;
5949 int val2 ;
5950 int ecode2 = 0 ;
5951 PyObject * obj0 = 0 ;
5952 PyObject * obj1 = 0 ;
5953 char * kwnames[] = {
5954 (char *) "x",(char *) "y", NULL
5955 };
5956
5957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5958 if (obj0) {
5959 ecode1 = SWIG_AsVal_int(obj0, &val1);
5960 if (!SWIG_IsOK(ecode1)) {
5961 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5962 }
5963 arg1 = static_cast< int >(val1);
5964 }
5965 if (obj1) {
5966 ecode2 = SWIG_AsVal_int(obj1, &val2);
5967 if (!SWIG_IsOK(ecode2)) {
5968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5969 }
5970 arg2 = static_cast< int >(val2);
5971 }
5972 {
5973 result = (wxPoint *)new wxPoint(arg1,arg2);
5974 if (PyErr_Occurred()) SWIG_fail;
5975 }
5976 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5977 return resultobj;
5978 fail:
5979 return NULL;
5980 }
5981
5982
5983 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5984 PyObject *resultobj = 0;
5985 wxPoint *arg1 = (wxPoint *) 0 ;
5986 void *argp1 = 0 ;
5987 int res1 = 0 ;
5988 PyObject *swig_obj[1] ;
5989
5990 if (!args) SWIG_fail;
5991 swig_obj[0] = args;
5992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5993 if (!SWIG_IsOK(res1)) {
5994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5995 }
5996 arg1 = reinterpret_cast< wxPoint * >(argp1);
5997 {
5998 delete arg1;
5999
6000 if (PyErr_Occurred()) SWIG_fail;
6001 }
6002 resultobj = SWIG_Py_Void();
6003 return resultobj;
6004 fail:
6005 return NULL;
6006 }
6007
6008
6009 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6010 PyObject *resultobj = 0;
6011 wxPoint *arg1 = (wxPoint *) 0 ;
6012 PyObject *arg2 = (PyObject *) 0 ;
6013 bool result;
6014 void *argp1 = 0 ;
6015 int res1 = 0 ;
6016 PyObject * obj0 = 0 ;
6017 PyObject * obj1 = 0 ;
6018 char * kwnames[] = {
6019 (char *) "self",(char *) "other", NULL
6020 };
6021
6022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
6023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6024 if (!SWIG_IsOK(res1)) {
6025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
6026 }
6027 arg1 = reinterpret_cast< wxPoint * >(argp1);
6028 arg2 = obj1;
6029 {
6030 result = (bool)wxPoint___eq__(arg1,arg2);
6031 if (PyErr_Occurred()) SWIG_fail;
6032 }
6033 {
6034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6035 }
6036 return resultobj;
6037 fail:
6038 return NULL;
6039 }
6040
6041
6042 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6043 PyObject *resultobj = 0;
6044 wxPoint *arg1 = (wxPoint *) 0 ;
6045 PyObject *arg2 = (PyObject *) 0 ;
6046 bool result;
6047 void *argp1 = 0 ;
6048 int res1 = 0 ;
6049 PyObject * obj0 = 0 ;
6050 PyObject * obj1 = 0 ;
6051 char * kwnames[] = {
6052 (char *) "self",(char *) "other", NULL
6053 };
6054
6055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
6056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6057 if (!SWIG_IsOK(res1)) {
6058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
6059 }
6060 arg1 = reinterpret_cast< wxPoint * >(argp1);
6061 arg2 = obj1;
6062 {
6063 result = (bool)wxPoint___ne__(arg1,arg2);
6064 if (PyErr_Occurred()) SWIG_fail;
6065 }
6066 {
6067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6068 }
6069 return resultobj;
6070 fail:
6071 return NULL;
6072 }
6073
6074
6075 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6076 PyObject *resultobj = 0;
6077 wxPoint *arg1 = (wxPoint *) 0 ;
6078 wxPoint *arg2 = 0 ;
6079 wxPoint result;
6080 void *argp1 = 0 ;
6081 int res1 = 0 ;
6082 wxPoint temp2 ;
6083 PyObject * obj0 = 0 ;
6084 PyObject * obj1 = 0 ;
6085 char * kwnames[] = {
6086 (char *) "self",(char *) "pt", NULL
6087 };
6088
6089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
6090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6091 if (!SWIG_IsOK(res1)) {
6092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
6093 }
6094 arg1 = reinterpret_cast< wxPoint * >(argp1);
6095 {
6096 arg2 = &temp2;
6097 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6098 }
6099 {
6100 result = (arg1)->operator +((wxPoint const &)*arg2);
6101 if (PyErr_Occurred()) SWIG_fail;
6102 }
6103 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6104 return resultobj;
6105 fail:
6106 return NULL;
6107 }
6108
6109
6110 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6111 PyObject *resultobj = 0;
6112 wxPoint *arg1 = (wxPoint *) 0 ;
6113 wxPoint *arg2 = 0 ;
6114 wxPoint result;
6115 void *argp1 = 0 ;
6116 int res1 = 0 ;
6117 wxPoint temp2 ;
6118 PyObject * obj0 = 0 ;
6119 PyObject * obj1 = 0 ;
6120 char * kwnames[] = {
6121 (char *) "self",(char *) "pt", NULL
6122 };
6123
6124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
6125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6126 if (!SWIG_IsOK(res1)) {
6127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6128 }
6129 arg1 = reinterpret_cast< wxPoint * >(argp1);
6130 {
6131 arg2 = &temp2;
6132 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6133 }
6134 {
6135 result = (arg1)->operator -((wxPoint const &)*arg2);
6136 if (PyErr_Occurred()) SWIG_fail;
6137 }
6138 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6139 return resultobj;
6140 fail:
6141 return NULL;
6142 }
6143
6144
6145 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6146 PyObject *resultobj = 0;
6147 wxPoint *arg1 = (wxPoint *) 0 ;
6148 wxPoint *arg2 = 0 ;
6149 wxPoint *result = 0 ;
6150 void *argp1 = 0 ;
6151 int res1 = 0 ;
6152 wxPoint temp2 ;
6153 PyObject * obj0 = 0 ;
6154 PyObject * obj1 = 0 ;
6155 char * kwnames[] = {
6156 (char *) "self",(char *) "pt", NULL
6157 };
6158
6159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
6160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6161 if (!SWIG_IsOK(res1)) {
6162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
6163 }
6164 arg1 = reinterpret_cast< wxPoint * >(argp1);
6165 {
6166 arg2 = &temp2;
6167 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6168 }
6169 {
6170 {
6171 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
6172 result = (wxPoint *) &_result_ref;
6173 }
6174 if (PyErr_Occurred()) SWIG_fail;
6175 }
6176 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6177 return resultobj;
6178 fail:
6179 return NULL;
6180 }
6181
6182
6183 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6184 PyObject *resultobj = 0;
6185 wxPoint *arg1 = (wxPoint *) 0 ;
6186 wxPoint *arg2 = 0 ;
6187 wxPoint *result = 0 ;
6188 void *argp1 = 0 ;
6189 int res1 = 0 ;
6190 wxPoint temp2 ;
6191 PyObject * obj0 = 0 ;
6192 PyObject * obj1 = 0 ;
6193 char * kwnames[] = {
6194 (char *) "self",(char *) "pt", NULL
6195 };
6196
6197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
6198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6199 if (!SWIG_IsOK(res1)) {
6200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6201 }
6202 arg1 = reinterpret_cast< wxPoint * >(argp1);
6203 {
6204 arg2 = &temp2;
6205 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6206 }
6207 {
6208 {
6209 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
6210 result = (wxPoint *) &_result_ref;
6211 }
6212 if (PyErr_Occurred()) SWIG_fail;
6213 }
6214 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6215 return resultobj;
6216 fail:
6217 return NULL;
6218 }
6219
6220
6221 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6222 PyObject *resultobj = 0;
6223 wxPoint *arg1 = (wxPoint *) 0 ;
6224 long arg2 ;
6225 long arg3 ;
6226 void *argp1 = 0 ;
6227 int res1 = 0 ;
6228 long val2 ;
6229 int ecode2 = 0 ;
6230 long val3 ;
6231 int ecode3 = 0 ;
6232 PyObject * obj0 = 0 ;
6233 PyObject * obj1 = 0 ;
6234 PyObject * obj2 = 0 ;
6235 char * kwnames[] = {
6236 (char *) "self",(char *) "x",(char *) "y", NULL
6237 };
6238
6239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6241 if (!SWIG_IsOK(res1)) {
6242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6243 }
6244 arg1 = reinterpret_cast< wxPoint * >(argp1);
6245 ecode2 = SWIG_AsVal_long(obj1, &val2);
6246 if (!SWIG_IsOK(ecode2)) {
6247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6248 }
6249 arg2 = static_cast< long >(val2);
6250 ecode3 = SWIG_AsVal_long(obj2, &val3);
6251 if (!SWIG_IsOK(ecode3)) {
6252 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6253 }
6254 arg3 = static_cast< long >(val3);
6255 {
6256 wxPoint_Set(arg1,arg2,arg3);
6257 if (PyErr_Occurred()) SWIG_fail;
6258 }
6259 resultobj = SWIG_Py_Void();
6260 return resultobj;
6261 fail:
6262 return NULL;
6263 }
6264
6265
6266 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6267 PyObject *resultobj = 0;
6268 wxPoint *arg1 = (wxPoint *) 0 ;
6269 PyObject *result = 0 ;
6270 void *argp1 = 0 ;
6271 int res1 = 0 ;
6272 PyObject *swig_obj[1] ;
6273
6274 if (!args) SWIG_fail;
6275 swig_obj[0] = args;
6276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6277 if (!SWIG_IsOK(res1)) {
6278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6279 }
6280 arg1 = reinterpret_cast< wxPoint * >(argp1);
6281 {
6282 result = (PyObject *)wxPoint_Get(arg1);
6283 if (PyErr_Occurred()) SWIG_fail;
6284 }
6285 resultobj = result;
6286 return resultobj;
6287 fail:
6288 return NULL;
6289 }
6290
6291
6292 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6293 PyObject *obj;
6294 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6295 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6296 return SWIG_Py_Void();
6297 }
6298
6299 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6300 return SWIG_Python_InitShadowInstance(args);
6301 }
6302
6303 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6304 PyObject *resultobj = 0;
6305 int arg1 = (int) 0 ;
6306 int arg2 = (int) 0 ;
6307 int arg3 = (int) 0 ;
6308 int arg4 = (int) 0 ;
6309 wxRect *result = 0 ;
6310 int val1 ;
6311 int ecode1 = 0 ;
6312 int val2 ;
6313 int ecode2 = 0 ;
6314 int val3 ;
6315 int ecode3 = 0 ;
6316 int val4 ;
6317 int ecode4 = 0 ;
6318 PyObject * obj0 = 0 ;
6319 PyObject * obj1 = 0 ;
6320 PyObject * obj2 = 0 ;
6321 PyObject * obj3 = 0 ;
6322 char * kwnames[] = {
6323 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6324 };
6325
6326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6327 if (obj0) {
6328 ecode1 = SWIG_AsVal_int(obj0, &val1);
6329 if (!SWIG_IsOK(ecode1)) {
6330 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6331 }
6332 arg1 = static_cast< int >(val1);
6333 }
6334 if (obj1) {
6335 ecode2 = SWIG_AsVal_int(obj1, &val2);
6336 if (!SWIG_IsOK(ecode2)) {
6337 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6338 }
6339 arg2 = static_cast< int >(val2);
6340 }
6341 if (obj2) {
6342 ecode3 = SWIG_AsVal_int(obj2, &val3);
6343 if (!SWIG_IsOK(ecode3)) {
6344 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6345 }
6346 arg3 = static_cast< int >(val3);
6347 }
6348 if (obj3) {
6349 ecode4 = SWIG_AsVal_int(obj3, &val4);
6350 if (!SWIG_IsOK(ecode4)) {
6351 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6352 }
6353 arg4 = static_cast< int >(val4);
6354 }
6355 {
6356 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6357 if (PyErr_Occurred()) SWIG_fail;
6358 }
6359 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6360 return resultobj;
6361 fail:
6362 return NULL;
6363 }
6364
6365
6366 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6367 PyObject *resultobj = 0;
6368 wxPoint *arg1 = 0 ;
6369 wxPoint *arg2 = 0 ;
6370 wxRect *result = 0 ;
6371 wxPoint temp1 ;
6372 wxPoint temp2 ;
6373 PyObject * obj0 = 0 ;
6374 PyObject * obj1 = 0 ;
6375 char * kwnames[] = {
6376 (char *) "topLeft",(char *) "bottomRight", NULL
6377 };
6378
6379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6380 {
6381 arg1 = &temp1;
6382 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6383 }
6384 {
6385 arg2 = &temp2;
6386 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6387 }
6388 {
6389 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6390 if (PyErr_Occurred()) SWIG_fail;
6391 }
6392 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6393 return resultobj;
6394 fail:
6395 return NULL;
6396 }
6397
6398
6399 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6400 PyObject *resultobj = 0;
6401 wxPoint *arg1 = 0 ;
6402 wxSize *arg2 = 0 ;
6403 wxRect *result = 0 ;
6404 wxPoint temp1 ;
6405 wxSize temp2 ;
6406 PyObject * obj0 = 0 ;
6407 PyObject * obj1 = 0 ;
6408 char * kwnames[] = {
6409 (char *) "pos",(char *) "size", NULL
6410 };
6411
6412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6413 {
6414 arg1 = &temp1;
6415 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6416 }
6417 {
6418 arg2 = &temp2;
6419 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6420 }
6421 {
6422 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6423 if (PyErr_Occurred()) SWIG_fail;
6424 }
6425 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6426 return resultobj;
6427 fail:
6428 return NULL;
6429 }
6430
6431
6432 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6433 PyObject *resultobj = 0;
6434 wxSize *arg1 = 0 ;
6435 wxRect *result = 0 ;
6436 wxSize temp1 ;
6437 PyObject * obj0 = 0 ;
6438 char * kwnames[] = {
6439 (char *) "size", NULL
6440 };
6441
6442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6443 {
6444 arg1 = &temp1;
6445 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6446 }
6447 {
6448 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6449 if (PyErr_Occurred()) SWIG_fail;
6450 }
6451 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6452 return resultobj;
6453 fail:
6454 return NULL;
6455 }
6456
6457
6458 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6459 PyObject *resultobj = 0;
6460 wxRect *arg1 = (wxRect *) 0 ;
6461 void *argp1 = 0 ;
6462 int res1 = 0 ;
6463 PyObject *swig_obj[1] ;
6464
6465 if (!args) SWIG_fail;
6466 swig_obj[0] = args;
6467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6468 if (!SWIG_IsOK(res1)) {
6469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6470 }
6471 arg1 = reinterpret_cast< wxRect * >(argp1);
6472 {
6473 delete arg1;
6474
6475 if (PyErr_Occurred()) SWIG_fail;
6476 }
6477 resultobj = SWIG_Py_Void();
6478 return resultobj;
6479 fail:
6480 return NULL;
6481 }
6482
6483
6484 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6485 PyObject *resultobj = 0;
6486 wxRect *arg1 = (wxRect *) 0 ;
6487 int result;
6488 void *argp1 = 0 ;
6489 int res1 = 0 ;
6490 PyObject *swig_obj[1] ;
6491
6492 if (!args) SWIG_fail;
6493 swig_obj[0] = args;
6494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6495 if (!SWIG_IsOK(res1)) {
6496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6497 }
6498 arg1 = reinterpret_cast< wxRect * >(argp1);
6499 {
6500 result = (int)((wxRect const *)arg1)->GetX();
6501 if (PyErr_Occurred()) SWIG_fail;
6502 }
6503 resultobj = SWIG_From_int(static_cast< int >(result));
6504 return resultobj;
6505 fail:
6506 return NULL;
6507 }
6508
6509
6510 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6511 PyObject *resultobj = 0;
6512 wxRect *arg1 = (wxRect *) 0 ;
6513 int arg2 ;
6514 void *argp1 = 0 ;
6515 int res1 = 0 ;
6516 int val2 ;
6517 int ecode2 = 0 ;
6518 PyObject * obj0 = 0 ;
6519 PyObject * obj1 = 0 ;
6520 char * kwnames[] = {
6521 (char *) "self",(char *) "x", NULL
6522 };
6523
6524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6526 if (!SWIG_IsOK(res1)) {
6527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6528 }
6529 arg1 = reinterpret_cast< wxRect * >(argp1);
6530 ecode2 = SWIG_AsVal_int(obj1, &val2);
6531 if (!SWIG_IsOK(ecode2)) {
6532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6533 }
6534 arg2 = static_cast< int >(val2);
6535 {
6536 (arg1)->SetX(arg2);
6537 if (PyErr_Occurred()) SWIG_fail;
6538 }
6539 resultobj = SWIG_Py_Void();
6540 return resultobj;
6541 fail:
6542 return NULL;
6543 }
6544
6545
6546 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6547 PyObject *resultobj = 0;
6548 wxRect *arg1 = (wxRect *) 0 ;
6549 int result;
6550 void *argp1 = 0 ;
6551 int res1 = 0 ;
6552 PyObject *swig_obj[1] ;
6553
6554 if (!args) SWIG_fail;
6555 swig_obj[0] = args;
6556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6557 if (!SWIG_IsOK(res1)) {
6558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6559 }
6560 arg1 = reinterpret_cast< wxRect * >(argp1);
6561 {
6562 result = (int)(arg1)->GetY();
6563 if (PyErr_Occurred()) SWIG_fail;
6564 }
6565 resultobj = SWIG_From_int(static_cast< int >(result));
6566 return resultobj;
6567 fail:
6568 return NULL;
6569 }
6570
6571
6572 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6573 PyObject *resultobj = 0;
6574 wxRect *arg1 = (wxRect *) 0 ;
6575 int arg2 ;
6576 void *argp1 = 0 ;
6577 int res1 = 0 ;
6578 int val2 ;
6579 int ecode2 = 0 ;
6580 PyObject * obj0 = 0 ;
6581 PyObject * obj1 = 0 ;
6582 char * kwnames[] = {
6583 (char *) "self",(char *) "y", NULL
6584 };
6585
6586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6588 if (!SWIG_IsOK(res1)) {
6589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6590 }
6591 arg1 = reinterpret_cast< wxRect * >(argp1);
6592 ecode2 = SWIG_AsVal_int(obj1, &val2);
6593 if (!SWIG_IsOK(ecode2)) {
6594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6595 }
6596 arg2 = static_cast< int >(val2);
6597 {
6598 (arg1)->SetY(arg2);
6599 if (PyErr_Occurred()) SWIG_fail;
6600 }
6601 resultobj = SWIG_Py_Void();
6602 return resultobj;
6603 fail:
6604 return NULL;
6605 }
6606
6607
6608 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6609 PyObject *resultobj = 0;
6610 wxRect *arg1 = (wxRect *) 0 ;
6611 int result;
6612 void *argp1 = 0 ;
6613 int res1 = 0 ;
6614 PyObject *swig_obj[1] ;
6615
6616 if (!args) SWIG_fail;
6617 swig_obj[0] = args;
6618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6619 if (!SWIG_IsOK(res1)) {
6620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6621 }
6622 arg1 = reinterpret_cast< wxRect * >(argp1);
6623 {
6624 result = (int)((wxRect const *)arg1)->GetWidth();
6625 if (PyErr_Occurred()) SWIG_fail;
6626 }
6627 resultobj = SWIG_From_int(static_cast< int >(result));
6628 return resultobj;
6629 fail:
6630 return NULL;
6631 }
6632
6633
6634 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6635 PyObject *resultobj = 0;
6636 wxRect *arg1 = (wxRect *) 0 ;
6637 int arg2 ;
6638 void *argp1 = 0 ;
6639 int res1 = 0 ;
6640 int val2 ;
6641 int ecode2 = 0 ;
6642 PyObject * obj0 = 0 ;
6643 PyObject * obj1 = 0 ;
6644 char * kwnames[] = {
6645 (char *) "self",(char *) "w", NULL
6646 };
6647
6648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6650 if (!SWIG_IsOK(res1)) {
6651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6652 }
6653 arg1 = reinterpret_cast< wxRect * >(argp1);
6654 ecode2 = SWIG_AsVal_int(obj1, &val2);
6655 if (!SWIG_IsOK(ecode2)) {
6656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6657 }
6658 arg2 = static_cast< int >(val2);
6659 {
6660 (arg1)->SetWidth(arg2);
6661 if (PyErr_Occurred()) SWIG_fail;
6662 }
6663 resultobj = SWIG_Py_Void();
6664 return resultobj;
6665 fail:
6666 return NULL;
6667 }
6668
6669
6670 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6671 PyObject *resultobj = 0;
6672 wxRect *arg1 = (wxRect *) 0 ;
6673 int result;
6674 void *argp1 = 0 ;
6675 int res1 = 0 ;
6676 PyObject *swig_obj[1] ;
6677
6678 if (!args) SWIG_fail;
6679 swig_obj[0] = args;
6680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6681 if (!SWIG_IsOK(res1)) {
6682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6683 }
6684 arg1 = reinterpret_cast< wxRect * >(argp1);
6685 {
6686 result = (int)((wxRect const *)arg1)->GetHeight();
6687 if (PyErr_Occurred()) SWIG_fail;
6688 }
6689 resultobj = SWIG_From_int(static_cast< int >(result));
6690 return resultobj;
6691 fail:
6692 return NULL;
6693 }
6694
6695
6696 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6697 PyObject *resultobj = 0;
6698 wxRect *arg1 = (wxRect *) 0 ;
6699 int arg2 ;
6700 void *argp1 = 0 ;
6701 int res1 = 0 ;
6702 int val2 ;
6703 int ecode2 = 0 ;
6704 PyObject * obj0 = 0 ;
6705 PyObject * obj1 = 0 ;
6706 char * kwnames[] = {
6707 (char *) "self",(char *) "h", NULL
6708 };
6709
6710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6712 if (!SWIG_IsOK(res1)) {
6713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6714 }
6715 arg1 = reinterpret_cast< wxRect * >(argp1);
6716 ecode2 = SWIG_AsVal_int(obj1, &val2);
6717 if (!SWIG_IsOK(ecode2)) {
6718 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6719 }
6720 arg2 = static_cast< int >(val2);
6721 {
6722 (arg1)->SetHeight(arg2);
6723 if (PyErr_Occurred()) SWIG_fail;
6724 }
6725 resultobj = SWIG_Py_Void();
6726 return resultobj;
6727 fail:
6728 return NULL;
6729 }
6730
6731
6732 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6733 PyObject *resultobj = 0;
6734 wxRect *arg1 = (wxRect *) 0 ;
6735 wxPoint result;
6736 void *argp1 = 0 ;
6737 int res1 = 0 ;
6738 PyObject *swig_obj[1] ;
6739
6740 if (!args) SWIG_fail;
6741 swig_obj[0] = args;
6742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6743 if (!SWIG_IsOK(res1)) {
6744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6745 }
6746 arg1 = reinterpret_cast< wxRect * >(argp1);
6747 {
6748 result = ((wxRect const *)arg1)->GetPosition();
6749 if (PyErr_Occurred()) SWIG_fail;
6750 }
6751 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6752 return resultobj;
6753 fail:
6754 return NULL;
6755 }
6756
6757
6758 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6759 PyObject *resultobj = 0;
6760 wxRect *arg1 = (wxRect *) 0 ;
6761 wxPoint *arg2 = 0 ;
6762 void *argp1 = 0 ;
6763 int res1 = 0 ;
6764 wxPoint temp2 ;
6765 PyObject * obj0 = 0 ;
6766 PyObject * obj1 = 0 ;
6767 char * kwnames[] = {
6768 (char *) "self",(char *) "p", NULL
6769 };
6770
6771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6773 if (!SWIG_IsOK(res1)) {
6774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6775 }
6776 arg1 = reinterpret_cast< wxRect * >(argp1);
6777 {
6778 arg2 = &temp2;
6779 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6780 }
6781 {
6782 (arg1)->SetPosition((wxPoint const &)*arg2);
6783 if (PyErr_Occurred()) SWIG_fail;
6784 }
6785 resultobj = SWIG_Py_Void();
6786 return resultobj;
6787 fail:
6788 return NULL;
6789 }
6790
6791
6792 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6793 PyObject *resultobj = 0;
6794 wxRect *arg1 = (wxRect *) 0 ;
6795 wxSize result;
6796 void *argp1 = 0 ;
6797 int res1 = 0 ;
6798 PyObject *swig_obj[1] ;
6799
6800 if (!args) SWIG_fail;
6801 swig_obj[0] = args;
6802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6803 if (!SWIG_IsOK(res1)) {
6804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6805 }
6806 arg1 = reinterpret_cast< wxRect * >(argp1);
6807 {
6808 result = ((wxRect const *)arg1)->GetSize();
6809 if (PyErr_Occurred()) SWIG_fail;
6810 }
6811 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6812 return resultobj;
6813 fail:
6814 return NULL;
6815 }
6816
6817
6818 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6819 PyObject *resultobj = 0;
6820 wxRect *arg1 = (wxRect *) 0 ;
6821 wxSize *arg2 = 0 ;
6822 void *argp1 = 0 ;
6823 int res1 = 0 ;
6824 wxSize temp2 ;
6825 PyObject * obj0 = 0 ;
6826 PyObject * obj1 = 0 ;
6827 char * kwnames[] = {
6828 (char *) "self",(char *) "s", NULL
6829 };
6830
6831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6833 if (!SWIG_IsOK(res1)) {
6834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6835 }
6836 arg1 = reinterpret_cast< wxRect * >(argp1);
6837 {
6838 arg2 = &temp2;
6839 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6840 }
6841 {
6842 (arg1)->SetSize((wxSize const &)*arg2);
6843 if (PyErr_Occurred()) SWIG_fail;
6844 }
6845 resultobj = SWIG_Py_Void();
6846 return resultobj;
6847 fail:
6848 return NULL;
6849 }
6850
6851
6852 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6853 PyObject *resultobj = 0;
6854 wxRect *arg1 = (wxRect *) 0 ;
6855 bool result;
6856 void *argp1 = 0 ;
6857 int res1 = 0 ;
6858 PyObject *swig_obj[1] ;
6859
6860 if (!args) SWIG_fail;
6861 swig_obj[0] = args;
6862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6863 if (!SWIG_IsOK(res1)) {
6864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6865 }
6866 arg1 = reinterpret_cast< wxRect * >(argp1);
6867 {
6868 result = (bool)((wxRect const *)arg1)->IsEmpty();
6869 if (PyErr_Occurred()) SWIG_fail;
6870 }
6871 {
6872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6873 }
6874 return resultobj;
6875 fail:
6876 return NULL;
6877 }
6878
6879
6880 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6881 PyObject *resultobj = 0;
6882 wxRect *arg1 = (wxRect *) 0 ;
6883 wxPoint result;
6884 void *argp1 = 0 ;
6885 int res1 = 0 ;
6886 PyObject *swig_obj[1] ;
6887
6888 if (!args) SWIG_fail;
6889 swig_obj[0] = args;
6890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6891 if (!SWIG_IsOK(res1)) {
6892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6893 }
6894 arg1 = reinterpret_cast< wxRect * >(argp1);
6895 {
6896 result = ((wxRect const *)arg1)->GetTopLeft();
6897 if (PyErr_Occurred()) SWIG_fail;
6898 }
6899 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6900 return resultobj;
6901 fail:
6902 return NULL;
6903 }
6904
6905
6906 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6907 PyObject *resultobj = 0;
6908 wxRect *arg1 = (wxRect *) 0 ;
6909 wxPoint *arg2 = 0 ;
6910 void *argp1 = 0 ;
6911 int res1 = 0 ;
6912 wxPoint temp2 ;
6913 PyObject * obj0 = 0 ;
6914 PyObject * obj1 = 0 ;
6915 char * kwnames[] = {
6916 (char *) "self",(char *) "p", NULL
6917 };
6918
6919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6921 if (!SWIG_IsOK(res1)) {
6922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6923 }
6924 arg1 = reinterpret_cast< wxRect * >(argp1);
6925 {
6926 arg2 = &temp2;
6927 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6928 }
6929 {
6930 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6931 if (PyErr_Occurred()) SWIG_fail;
6932 }
6933 resultobj = SWIG_Py_Void();
6934 return resultobj;
6935 fail:
6936 return NULL;
6937 }
6938
6939
6940 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6941 PyObject *resultobj = 0;
6942 wxRect *arg1 = (wxRect *) 0 ;
6943 wxPoint result;
6944 void *argp1 = 0 ;
6945 int res1 = 0 ;
6946 PyObject *swig_obj[1] ;
6947
6948 if (!args) SWIG_fail;
6949 swig_obj[0] = args;
6950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6951 if (!SWIG_IsOK(res1)) {
6952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6953 }
6954 arg1 = reinterpret_cast< wxRect * >(argp1);
6955 {
6956 result = ((wxRect const *)arg1)->GetBottomRight();
6957 if (PyErr_Occurred()) SWIG_fail;
6958 }
6959 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6960 return resultobj;
6961 fail:
6962 return NULL;
6963 }
6964
6965
6966 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6967 PyObject *resultobj = 0;
6968 wxRect *arg1 = (wxRect *) 0 ;
6969 wxPoint *arg2 = 0 ;
6970 void *argp1 = 0 ;
6971 int res1 = 0 ;
6972 wxPoint temp2 ;
6973 PyObject * obj0 = 0 ;
6974 PyObject * obj1 = 0 ;
6975 char * kwnames[] = {
6976 (char *) "self",(char *) "p", NULL
6977 };
6978
6979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6981 if (!SWIG_IsOK(res1)) {
6982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6983 }
6984 arg1 = reinterpret_cast< wxRect * >(argp1);
6985 {
6986 arg2 = &temp2;
6987 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6988 }
6989 {
6990 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6991 if (PyErr_Occurred()) SWIG_fail;
6992 }
6993 resultobj = SWIG_Py_Void();
6994 return resultobj;
6995 fail:
6996 return NULL;
6997 }
6998
6999
7000 SWIGINTERN PyObject *_wrap_Rect_GetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7001 PyObject *resultobj = 0;
7002 wxRect *arg1 = (wxRect *) 0 ;
7003 wxPoint result;
7004 void *argp1 = 0 ;
7005 int res1 = 0 ;
7006 PyObject *swig_obj[1] ;
7007
7008 if (!args) SWIG_fail;
7009 swig_obj[0] = args;
7010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7011 if (!SWIG_IsOK(res1)) {
7012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7013 }
7014 arg1 = reinterpret_cast< wxRect * >(argp1);
7015 {
7016 result = ((wxRect const *)arg1)->GetTopRight();
7017 if (PyErr_Occurred()) SWIG_fail;
7018 }
7019 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7020 return resultobj;
7021 fail:
7022 return NULL;
7023 }
7024
7025
7026 SWIGINTERN PyObject *_wrap_Rect_SetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7027 PyObject *resultobj = 0;
7028 wxRect *arg1 = (wxRect *) 0 ;
7029 wxPoint *arg2 = 0 ;
7030 void *argp1 = 0 ;
7031 int res1 = 0 ;
7032 wxPoint temp2 ;
7033 PyObject * obj0 = 0 ;
7034 PyObject * obj1 = 0 ;
7035 char * kwnames[] = {
7036 (char *) "self",(char *) "p", NULL
7037 };
7038
7039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopRight",kwnames,&obj0,&obj1)) SWIG_fail;
7040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7041 if (!SWIG_IsOK(res1)) {
7042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopRight" "', expected argument " "1"" of type '" "wxRect *""'");
7043 }
7044 arg1 = reinterpret_cast< wxRect * >(argp1);
7045 {
7046 arg2 = &temp2;
7047 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7048 }
7049 {
7050 (arg1)->SetTopRight((wxPoint const &)*arg2);
7051 if (PyErr_Occurred()) SWIG_fail;
7052 }
7053 resultobj = SWIG_Py_Void();
7054 return resultobj;
7055 fail:
7056 return NULL;
7057 }
7058
7059
7060 SWIGINTERN PyObject *_wrap_Rect_GetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7061 PyObject *resultobj = 0;
7062 wxRect *arg1 = (wxRect *) 0 ;
7063 wxPoint result;
7064 void *argp1 = 0 ;
7065 int res1 = 0 ;
7066 PyObject *swig_obj[1] ;
7067
7068 if (!args) SWIG_fail;
7069 swig_obj[0] = args;
7070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7071 if (!SWIG_IsOK(res1)) {
7072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7073 }
7074 arg1 = reinterpret_cast< wxRect * >(argp1);
7075 {
7076 result = ((wxRect const *)arg1)->GetBottomLeft();
7077 if (PyErr_Occurred()) SWIG_fail;
7078 }
7079 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7080 return resultobj;
7081 fail:
7082 return NULL;
7083 }
7084
7085
7086 SWIGINTERN PyObject *_wrap_Rect_SetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7087 PyObject *resultobj = 0;
7088 wxRect *arg1 = (wxRect *) 0 ;
7089 wxPoint *arg2 = 0 ;
7090 void *argp1 = 0 ;
7091 int res1 = 0 ;
7092 wxPoint temp2 ;
7093 PyObject * obj0 = 0 ;
7094 PyObject * obj1 = 0 ;
7095 char * kwnames[] = {
7096 (char *) "self",(char *) "p", NULL
7097 };
7098
7099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7101 if (!SWIG_IsOK(res1)) {
7102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7103 }
7104 arg1 = reinterpret_cast< wxRect * >(argp1);
7105 {
7106 arg2 = &temp2;
7107 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7108 }
7109 {
7110 (arg1)->SetBottomLeft((wxPoint const &)*arg2);
7111 if (PyErr_Occurred()) SWIG_fail;
7112 }
7113 resultobj = SWIG_Py_Void();
7114 return resultobj;
7115 fail:
7116 return NULL;
7117 }
7118
7119
7120 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7121 PyObject *resultobj = 0;
7122 wxRect *arg1 = (wxRect *) 0 ;
7123 int result;
7124 void *argp1 = 0 ;
7125 int res1 = 0 ;
7126 PyObject *swig_obj[1] ;
7127
7128 if (!args) SWIG_fail;
7129 swig_obj[0] = args;
7130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7131 if (!SWIG_IsOK(res1)) {
7132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7133 }
7134 arg1 = reinterpret_cast< wxRect * >(argp1);
7135 {
7136 result = (int)((wxRect const *)arg1)->GetLeft();
7137 if (PyErr_Occurred()) SWIG_fail;
7138 }
7139 resultobj = SWIG_From_int(static_cast< int >(result));
7140 return resultobj;
7141 fail:
7142 return NULL;
7143 }
7144
7145
7146 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7147 PyObject *resultobj = 0;
7148 wxRect *arg1 = (wxRect *) 0 ;
7149 int result;
7150 void *argp1 = 0 ;
7151 int res1 = 0 ;
7152 PyObject *swig_obj[1] ;
7153
7154 if (!args) SWIG_fail;
7155 swig_obj[0] = args;
7156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7157 if (!SWIG_IsOK(res1)) {
7158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
7159 }
7160 arg1 = reinterpret_cast< wxRect * >(argp1);
7161 {
7162 result = (int)((wxRect const *)arg1)->GetTop();
7163 if (PyErr_Occurred()) SWIG_fail;
7164 }
7165 resultobj = SWIG_From_int(static_cast< int >(result));
7166 return resultobj;
7167 fail:
7168 return NULL;
7169 }
7170
7171
7172 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7173 PyObject *resultobj = 0;
7174 wxRect *arg1 = (wxRect *) 0 ;
7175 int result;
7176 void *argp1 = 0 ;
7177 int res1 = 0 ;
7178 PyObject *swig_obj[1] ;
7179
7180 if (!args) SWIG_fail;
7181 swig_obj[0] = args;
7182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7183 if (!SWIG_IsOK(res1)) {
7184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
7185 }
7186 arg1 = reinterpret_cast< wxRect * >(argp1);
7187 {
7188 result = (int)((wxRect const *)arg1)->GetBottom();
7189 if (PyErr_Occurred()) SWIG_fail;
7190 }
7191 resultobj = SWIG_From_int(static_cast< int >(result));
7192 return resultobj;
7193 fail:
7194 return NULL;
7195 }
7196
7197
7198 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7199 PyObject *resultobj = 0;
7200 wxRect *arg1 = (wxRect *) 0 ;
7201 int result;
7202 void *argp1 = 0 ;
7203 int res1 = 0 ;
7204 PyObject *swig_obj[1] ;
7205
7206 if (!args) SWIG_fail;
7207 swig_obj[0] = args;
7208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7209 if (!SWIG_IsOK(res1)) {
7210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7211 }
7212 arg1 = reinterpret_cast< wxRect * >(argp1);
7213 {
7214 result = (int)((wxRect const *)arg1)->GetRight();
7215 if (PyErr_Occurred()) SWIG_fail;
7216 }
7217 resultobj = SWIG_From_int(static_cast< int >(result));
7218 return resultobj;
7219 fail:
7220 return NULL;
7221 }
7222
7223
7224 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7225 PyObject *resultobj = 0;
7226 wxRect *arg1 = (wxRect *) 0 ;
7227 int arg2 ;
7228 void *argp1 = 0 ;
7229 int res1 = 0 ;
7230 int val2 ;
7231 int ecode2 = 0 ;
7232 PyObject * obj0 = 0 ;
7233 PyObject * obj1 = 0 ;
7234 char * kwnames[] = {
7235 (char *) "self",(char *) "left", NULL
7236 };
7237
7238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7240 if (!SWIG_IsOK(res1)) {
7241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7242 }
7243 arg1 = reinterpret_cast< wxRect * >(argp1);
7244 ecode2 = SWIG_AsVal_int(obj1, &val2);
7245 if (!SWIG_IsOK(ecode2)) {
7246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
7247 }
7248 arg2 = static_cast< int >(val2);
7249 {
7250 (arg1)->SetLeft(arg2);
7251 if (PyErr_Occurred()) SWIG_fail;
7252 }
7253 resultobj = SWIG_Py_Void();
7254 return resultobj;
7255 fail:
7256 return NULL;
7257 }
7258
7259
7260 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7261 PyObject *resultobj = 0;
7262 wxRect *arg1 = (wxRect *) 0 ;
7263 int arg2 ;
7264 void *argp1 = 0 ;
7265 int res1 = 0 ;
7266 int val2 ;
7267 int ecode2 = 0 ;
7268 PyObject * obj0 = 0 ;
7269 PyObject * obj1 = 0 ;
7270 char * kwnames[] = {
7271 (char *) "self",(char *) "right", NULL
7272 };
7273
7274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
7275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7276 if (!SWIG_IsOK(res1)) {
7277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
7278 }
7279 arg1 = reinterpret_cast< wxRect * >(argp1);
7280 ecode2 = SWIG_AsVal_int(obj1, &val2);
7281 if (!SWIG_IsOK(ecode2)) {
7282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7283 }
7284 arg2 = static_cast< int >(val2);
7285 {
7286 (arg1)->SetRight(arg2);
7287 if (PyErr_Occurred()) SWIG_fail;
7288 }
7289 resultobj = SWIG_Py_Void();
7290 return resultobj;
7291 fail:
7292 return NULL;
7293 }
7294
7295
7296 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7297 PyObject *resultobj = 0;
7298 wxRect *arg1 = (wxRect *) 0 ;
7299 int arg2 ;
7300 void *argp1 = 0 ;
7301 int res1 = 0 ;
7302 int val2 ;
7303 int ecode2 = 0 ;
7304 PyObject * obj0 = 0 ;
7305 PyObject * obj1 = 0 ;
7306 char * kwnames[] = {
7307 (char *) "self",(char *) "top", NULL
7308 };
7309
7310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7312 if (!SWIG_IsOK(res1)) {
7313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7314 }
7315 arg1 = reinterpret_cast< wxRect * >(argp1);
7316 ecode2 = SWIG_AsVal_int(obj1, &val2);
7317 if (!SWIG_IsOK(ecode2)) {
7318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7319 }
7320 arg2 = static_cast< int >(val2);
7321 {
7322 (arg1)->SetTop(arg2);
7323 if (PyErr_Occurred()) SWIG_fail;
7324 }
7325 resultobj = SWIG_Py_Void();
7326 return resultobj;
7327 fail:
7328 return NULL;
7329 }
7330
7331
7332 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7333 PyObject *resultobj = 0;
7334 wxRect *arg1 = (wxRect *) 0 ;
7335 int arg2 ;
7336 void *argp1 = 0 ;
7337 int res1 = 0 ;
7338 int val2 ;
7339 int ecode2 = 0 ;
7340 PyObject * obj0 = 0 ;
7341 PyObject * obj1 = 0 ;
7342 char * kwnames[] = {
7343 (char *) "self",(char *) "bottom", NULL
7344 };
7345
7346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7348 if (!SWIG_IsOK(res1)) {
7349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7350 }
7351 arg1 = reinterpret_cast< wxRect * >(argp1);
7352 ecode2 = SWIG_AsVal_int(obj1, &val2);
7353 if (!SWIG_IsOK(ecode2)) {
7354 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7355 }
7356 arg2 = static_cast< int >(val2);
7357 {
7358 (arg1)->SetBottom(arg2);
7359 if (PyErr_Occurred()) SWIG_fail;
7360 }
7361 resultobj = SWIG_Py_Void();
7362 return resultobj;
7363 fail:
7364 return NULL;
7365 }
7366
7367
7368 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7369 PyObject *resultobj = 0;
7370 wxRect *arg1 = (wxRect *) 0 ;
7371 int arg2 ;
7372 int arg3 ;
7373 wxRect result;
7374 void *argp1 = 0 ;
7375 int res1 = 0 ;
7376 int val2 ;
7377 int ecode2 = 0 ;
7378 int val3 ;
7379 int ecode3 = 0 ;
7380 PyObject * obj0 = 0 ;
7381 PyObject * obj1 = 0 ;
7382 PyObject * obj2 = 0 ;
7383 char * kwnames[] = {
7384 (char *) "self",(char *) "dx",(char *) "dy", NULL
7385 };
7386
7387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7389 if (!SWIG_IsOK(res1)) {
7390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7391 }
7392 arg1 = reinterpret_cast< wxRect * >(argp1);
7393 ecode2 = SWIG_AsVal_int(obj1, &val2);
7394 if (!SWIG_IsOK(ecode2)) {
7395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7396 }
7397 arg2 = static_cast< int >(val2);
7398 ecode3 = SWIG_AsVal_int(obj2, &val3);
7399 if (!SWIG_IsOK(ecode3)) {
7400 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7401 }
7402 arg3 = static_cast< int >(val3);
7403 {
7404 result = (arg1)->Inflate(arg2,arg3);
7405 if (PyErr_Occurred()) SWIG_fail;
7406 }
7407 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7408 return resultobj;
7409 fail:
7410 return NULL;
7411 }
7412
7413
7414 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7415 PyObject *resultobj = 0;
7416 wxRect *arg1 = (wxRect *) 0 ;
7417 int arg2 ;
7418 int arg3 ;
7419 wxRect *result = 0 ;
7420 void *argp1 = 0 ;
7421 int res1 = 0 ;
7422 int val2 ;
7423 int ecode2 = 0 ;
7424 int val3 ;
7425 int ecode3 = 0 ;
7426 PyObject * obj0 = 0 ;
7427 PyObject * obj1 = 0 ;
7428 PyObject * obj2 = 0 ;
7429 char * kwnames[] = {
7430 (char *) "self",(char *) "dx",(char *) "dy", NULL
7431 };
7432
7433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7435 if (!SWIG_IsOK(res1)) {
7436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7437 }
7438 arg1 = reinterpret_cast< wxRect * >(argp1);
7439 ecode2 = SWIG_AsVal_int(obj1, &val2);
7440 if (!SWIG_IsOK(ecode2)) {
7441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7442 }
7443 arg2 = static_cast< int >(val2);
7444 ecode3 = SWIG_AsVal_int(obj2, &val3);
7445 if (!SWIG_IsOK(ecode3)) {
7446 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7447 }
7448 arg3 = static_cast< int >(val3);
7449 {
7450 {
7451 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7452 result = (wxRect *) &_result_ref;
7453 }
7454 if (PyErr_Occurred()) SWIG_fail;
7455 }
7456 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7457 return resultobj;
7458 fail:
7459 return NULL;
7460 }
7461
7462
7463 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7464 PyObject *resultobj = 0;
7465 wxRect *arg1 = (wxRect *) 0 ;
7466 int arg2 ;
7467 int arg3 ;
7468 void *argp1 = 0 ;
7469 int res1 = 0 ;
7470 int val2 ;
7471 int ecode2 = 0 ;
7472 int val3 ;
7473 int ecode3 = 0 ;
7474 PyObject * obj0 = 0 ;
7475 PyObject * obj1 = 0 ;
7476 PyObject * obj2 = 0 ;
7477 char * kwnames[] = {
7478 (char *) "self",(char *) "dx",(char *) "dy", NULL
7479 };
7480
7481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7483 if (!SWIG_IsOK(res1)) {
7484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7485 }
7486 arg1 = reinterpret_cast< wxRect * >(argp1);
7487 ecode2 = SWIG_AsVal_int(obj1, &val2);
7488 if (!SWIG_IsOK(ecode2)) {
7489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7490 }
7491 arg2 = static_cast< int >(val2);
7492 ecode3 = SWIG_AsVal_int(obj2, &val3);
7493 if (!SWIG_IsOK(ecode3)) {
7494 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7495 }
7496 arg3 = static_cast< int >(val3);
7497 {
7498 (arg1)->Offset(arg2,arg3);
7499 if (PyErr_Occurred()) SWIG_fail;
7500 }
7501 resultobj = SWIG_Py_Void();
7502 return resultobj;
7503 fail:
7504 return NULL;
7505 }
7506
7507
7508 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7509 PyObject *resultobj = 0;
7510 wxRect *arg1 = (wxRect *) 0 ;
7511 wxPoint *arg2 = 0 ;
7512 void *argp1 = 0 ;
7513 int res1 = 0 ;
7514 wxPoint temp2 ;
7515 PyObject * obj0 = 0 ;
7516 PyObject * obj1 = 0 ;
7517 char * kwnames[] = {
7518 (char *) "self",(char *) "pt", NULL
7519 };
7520
7521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7523 if (!SWIG_IsOK(res1)) {
7524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7525 }
7526 arg1 = reinterpret_cast< wxRect * >(argp1);
7527 {
7528 arg2 = &temp2;
7529 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7530 }
7531 {
7532 (arg1)->Offset((wxPoint const &)*arg2);
7533 if (PyErr_Occurred()) SWIG_fail;
7534 }
7535 resultobj = SWIG_Py_Void();
7536 return resultobj;
7537 fail:
7538 return NULL;
7539 }
7540
7541
7542 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7543 PyObject *resultobj = 0;
7544 wxRect *arg1 = (wxRect *) 0 ;
7545 wxRect *arg2 = 0 ;
7546 wxRect result;
7547 void *argp1 = 0 ;
7548 int res1 = 0 ;
7549 wxRect temp2 ;
7550 PyObject * obj0 = 0 ;
7551 PyObject * obj1 = 0 ;
7552 char * kwnames[] = {
7553 (char *) "self",(char *) "rect", NULL
7554 };
7555
7556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7558 if (!SWIG_IsOK(res1)) {
7559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7560 }
7561 arg1 = reinterpret_cast< wxRect * >(argp1);
7562 {
7563 arg2 = &temp2;
7564 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7565 }
7566 {
7567 result = (arg1)->Intersect((wxRect const &)*arg2);
7568 if (PyErr_Occurred()) SWIG_fail;
7569 }
7570 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7571 return resultobj;
7572 fail:
7573 return NULL;
7574 }
7575
7576
7577 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7578 PyObject *resultobj = 0;
7579 wxRect *arg1 = (wxRect *) 0 ;
7580 wxRect *arg2 = 0 ;
7581 wxRect result;
7582 void *argp1 = 0 ;
7583 int res1 = 0 ;
7584 wxRect temp2 ;
7585 PyObject * obj0 = 0 ;
7586 PyObject * obj1 = 0 ;
7587 char * kwnames[] = {
7588 (char *) "self",(char *) "rect", NULL
7589 };
7590
7591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7593 if (!SWIG_IsOK(res1)) {
7594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7595 }
7596 arg1 = reinterpret_cast< wxRect * >(argp1);
7597 {
7598 arg2 = &temp2;
7599 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7600 }
7601 {
7602 result = (arg1)->Union((wxRect const &)*arg2);
7603 if (PyErr_Occurred()) SWIG_fail;
7604 }
7605 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7606 return resultobj;
7607 fail:
7608 return NULL;
7609 }
7610
7611
7612 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7613 PyObject *resultobj = 0;
7614 wxRect *arg1 = (wxRect *) 0 ;
7615 wxRect *arg2 = 0 ;
7616 wxRect result;
7617 void *argp1 = 0 ;
7618 int res1 = 0 ;
7619 wxRect temp2 ;
7620 PyObject * obj0 = 0 ;
7621 PyObject * obj1 = 0 ;
7622 char * kwnames[] = {
7623 (char *) "self",(char *) "rect", NULL
7624 };
7625
7626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7628 if (!SWIG_IsOK(res1)) {
7629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7630 }
7631 arg1 = reinterpret_cast< wxRect * >(argp1);
7632 {
7633 arg2 = &temp2;
7634 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7635 }
7636 {
7637 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7638 if (PyErr_Occurred()) SWIG_fail;
7639 }
7640 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7641 return resultobj;
7642 fail:
7643 return NULL;
7644 }
7645
7646
7647 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7648 PyObject *resultobj = 0;
7649 wxRect *arg1 = (wxRect *) 0 ;
7650 wxRect *arg2 = 0 ;
7651 wxRect *result = 0 ;
7652 void *argp1 = 0 ;
7653 int res1 = 0 ;
7654 wxRect temp2 ;
7655 PyObject * obj0 = 0 ;
7656 PyObject * obj1 = 0 ;
7657 char * kwnames[] = {
7658 (char *) "self",(char *) "rect", NULL
7659 };
7660
7661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7663 if (!SWIG_IsOK(res1)) {
7664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7665 }
7666 arg1 = reinterpret_cast< wxRect * >(argp1);
7667 {
7668 arg2 = &temp2;
7669 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7670 }
7671 {
7672 {
7673 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7674 result = (wxRect *) &_result_ref;
7675 }
7676 if (PyErr_Occurred()) SWIG_fail;
7677 }
7678 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7679 return resultobj;
7680 fail:
7681 return NULL;
7682 }
7683
7684
7685 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7686 PyObject *resultobj = 0;
7687 wxRect *arg1 = (wxRect *) 0 ;
7688 PyObject *arg2 = (PyObject *) 0 ;
7689 bool result;
7690 void *argp1 = 0 ;
7691 int res1 = 0 ;
7692 PyObject * obj0 = 0 ;
7693 PyObject * obj1 = 0 ;
7694 char * kwnames[] = {
7695 (char *) "self",(char *) "other", NULL
7696 };
7697
7698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7700 if (!SWIG_IsOK(res1)) {
7701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7702 }
7703 arg1 = reinterpret_cast< wxRect * >(argp1);
7704 arg2 = obj1;
7705 {
7706 result = (bool)wxRect___eq__(arg1,arg2);
7707 if (PyErr_Occurred()) SWIG_fail;
7708 }
7709 {
7710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7711 }
7712 return resultobj;
7713 fail:
7714 return NULL;
7715 }
7716
7717
7718 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7719 PyObject *resultobj = 0;
7720 wxRect *arg1 = (wxRect *) 0 ;
7721 PyObject *arg2 = (PyObject *) 0 ;
7722 bool result;
7723 void *argp1 = 0 ;
7724 int res1 = 0 ;
7725 PyObject * obj0 = 0 ;
7726 PyObject * obj1 = 0 ;
7727 char * kwnames[] = {
7728 (char *) "self",(char *) "other", NULL
7729 };
7730
7731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7733 if (!SWIG_IsOK(res1)) {
7734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7735 }
7736 arg1 = reinterpret_cast< wxRect * >(argp1);
7737 arg2 = obj1;
7738 {
7739 result = (bool)wxRect___ne__(arg1,arg2);
7740 if (PyErr_Occurred()) SWIG_fail;
7741 }
7742 {
7743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7744 }
7745 return resultobj;
7746 fail:
7747 return NULL;
7748 }
7749
7750
7751 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7752 PyObject *resultobj = 0;
7753 wxRect *arg1 = (wxRect *) 0 ;
7754 int arg2 ;
7755 int arg3 ;
7756 bool result;
7757 void *argp1 = 0 ;
7758 int res1 = 0 ;
7759 int val2 ;
7760 int ecode2 = 0 ;
7761 int val3 ;
7762 int ecode3 = 0 ;
7763 PyObject * obj0 = 0 ;
7764 PyObject * obj1 = 0 ;
7765 PyObject * obj2 = 0 ;
7766 char * kwnames[] = {
7767 (char *) "self",(char *) "x",(char *) "y", NULL
7768 };
7769
7770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7772 if (!SWIG_IsOK(res1)) {
7773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7774 }
7775 arg1 = reinterpret_cast< wxRect * >(argp1);
7776 ecode2 = SWIG_AsVal_int(obj1, &val2);
7777 if (!SWIG_IsOK(ecode2)) {
7778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7779 }
7780 arg2 = static_cast< int >(val2);
7781 ecode3 = SWIG_AsVal_int(obj2, &val3);
7782 if (!SWIG_IsOK(ecode3)) {
7783 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7784 }
7785 arg3 = static_cast< int >(val3);
7786 {
7787 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7788 if (PyErr_Occurred()) SWIG_fail;
7789 }
7790 {
7791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7792 }
7793 return resultobj;
7794 fail:
7795 return NULL;
7796 }
7797
7798
7799 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7800 PyObject *resultobj = 0;
7801 wxRect *arg1 = (wxRect *) 0 ;
7802 wxPoint *arg2 = 0 ;
7803 bool result;
7804 void *argp1 = 0 ;
7805 int res1 = 0 ;
7806 wxPoint temp2 ;
7807 PyObject * obj0 = 0 ;
7808 PyObject * obj1 = 0 ;
7809 char * kwnames[] = {
7810 (char *) "self",(char *) "pt", NULL
7811 };
7812
7813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7815 if (!SWIG_IsOK(res1)) {
7816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7817 }
7818 arg1 = reinterpret_cast< wxRect * >(argp1);
7819 {
7820 arg2 = &temp2;
7821 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7822 }
7823 {
7824 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7825 if (PyErr_Occurred()) SWIG_fail;
7826 }
7827 {
7828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7829 }
7830 return resultobj;
7831 fail:
7832 return NULL;
7833 }
7834
7835
7836 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7837 PyObject *resultobj = 0;
7838 wxRect *arg1 = (wxRect *) 0 ;
7839 wxRect *arg2 = 0 ;
7840 bool result;
7841 void *argp1 = 0 ;
7842 int res1 = 0 ;
7843 wxRect temp2 ;
7844 PyObject * obj0 = 0 ;
7845 PyObject * obj1 = 0 ;
7846 char * kwnames[] = {
7847 (char *) "self",(char *) "rect", NULL
7848 };
7849
7850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7852 if (!SWIG_IsOK(res1)) {
7853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7854 }
7855 arg1 = reinterpret_cast< wxRect * >(argp1);
7856 {
7857 arg2 = &temp2;
7858 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7859 }
7860 {
7861 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7862 if (PyErr_Occurred()) SWIG_fail;
7863 }
7864 {
7865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7866 }
7867 return resultobj;
7868 fail:
7869 return NULL;
7870 }
7871
7872
7873 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7874 PyObject *resultobj = 0;
7875 wxRect *arg1 = (wxRect *) 0 ;
7876 wxRect *arg2 = 0 ;
7877 bool result;
7878 void *argp1 = 0 ;
7879 int res1 = 0 ;
7880 wxRect temp2 ;
7881 PyObject * obj0 = 0 ;
7882 PyObject * obj1 = 0 ;
7883 char * kwnames[] = {
7884 (char *) "self",(char *) "rect", NULL
7885 };
7886
7887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7889 if (!SWIG_IsOK(res1)) {
7890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7891 }
7892 arg1 = reinterpret_cast< wxRect * >(argp1);
7893 {
7894 arg2 = &temp2;
7895 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7896 }
7897 {
7898 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7899 if (PyErr_Occurred()) SWIG_fail;
7900 }
7901 {
7902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7903 }
7904 return resultobj;
7905 fail:
7906 return NULL;
7907 }
7908
7909
7910 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7911 PyObject *resultobj = 0;
7912 wxRect *arg1 = (wxRect *) 0 ;
7913 wxRect *arg2 = 0 ;
7914 int arg3 = (int) wxBOTH ;
7915 wxRect result;
7916 void *argp1 = 0 ;
7917 int res1 = 0 ;
7918 wxRect temp2 ;
7919 int val3 ;
7920 int ecode3 = 0 ;
7921 PyObject * obj0 = 0 ;
7922 PyObject * obj1 = 0 ;
7923 PyObject * obj2 = 0 ;
7924 char * kwnames[] = {
7925 (char *) "self",(char *) "r",(char *) "dir", NULL
7926 };
7927
7928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7930 if (!SWIG_IsOK(res1)) {
7931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7932 }
7933 arg1 = reinterpret_cast< wxRect * >(argp1);
7934 {
7935 arg2 = &temp2;
7936 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7937 }
7938 if (obj2) {
7939 ecode3 = SWIG_AsVal_int(obj2, &val3);
7940 if (!SWIG_IsOK(ecode3)) {
7941 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7942 }
7943 arg3 = static_cast< int >(val3);
7944 }
7945 {
7946 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7947 if (PyErr_Occurred()) SWIG_fail;
7948 }
7949 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7950 return resultobj;
7951 fail:
7952 return NULL;
7953 }
7954
7955
7956 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7957 PyObject *resultobj = 0;
7958 wxRect *arg1 = (wxRect *) 0 ;
7959 int arg2 ;
7960 void *argp1 = 0 ;
7961 int res1 = 0 ;
7962 int val2 ;
7963 int ecode2 = 0 ;
7964 PyObject *swig_obj[2] ;
7965
7966 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7968 if (!SWIG_IsOK(res1)) {
7969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7970 }
7971 arg1 = reinterpret_cast< wxRect * >(argp1);
7972 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7973 if (!SWIG_IsOK(ecode2)) {
7974 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7975 }
7976 arg2 = static_cast< int >(val2);
7977 if (arg1) (arg1)->x = arg2;
7978
7979 resultobj = SWIG_Py_Void();
7980 return resultobj;
7981 fail:
7982 return NULL;
7983 }
7984
7985
7986 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7987 PyObject *resultobj = 0;
7988 wxRect *arg1 = (wxRect *) 0 ;
7989 int result;
7990 void *argp1 = 0 ;
7991 int res1 = 0 ;
7992 PyObject *swig_obj[1] ;
7993
7994 if (!args) SWIG_fail;
7995 swig_obj[0] = args;
7996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7997 if (!SWIG_IsOK(res1)) {
7998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7999 }
8000 arg1 = reinterpret_cast< wxRect * >(argp1);
8001 result = (int) ((arg1)->x);
8002 resultobj = SWIG_From_int(static_cast< int >(result));
8003 return resultobj;
8004 fail:
8005 return NULL;
8006 }
8007
8008
8009 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8010 PyObject *resultobj = 0;
8011 wxRect *arg1 = (wxRect *) 0 ;
8012 int arg2 ;
8013 void *argp1 = 0 ;
8014 int res1 = 0 ;
8015 int val2 ;
8016 int ecode2 = 0 ;
8017 PyObject *swig_obj[2] ;
8018
8019 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
8020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8021 if (!SWIG_IsOK(res1)) {
8022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
8023 }
8024 arg1 = reinterpret_cast< wxRect * >(argp1);
8025 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8026 if (!SWIG_IsOK(ecode2)) {
8027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
8028 }
8029 arg2 = static_cast< int >(val2);
8030 if (arg1) (arg1)->y = arg2;
8031
8032 resultobj = SWIG_Py_Void();
8033 return resultobj;
8034 fail:
8035 return NULL;
8036 }
8037
8038
8039 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8040 PyObject *resultobj = 0;
8041 wxRect *arg1 = (wxRect *) 0 ;
8042 int result;
8043 void *argp1 = 0 ;
8044 int res1 = 0 ;
8045 PyObject *swig_obj[1] ;
8046
8047 if (!args) SWIG_fail;
8048 swig_obj[0] = args;
8049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8050 if (!SWIG_IsOK(res1)) {
8051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
8052 }
8053 arg1 = reinterpret_cast< wxRect * >(argp1);
8054 result = (int) ((arg1)->y);
8055 resultobj = SWIG_From_int(static_cast< int >(result));
8056 return resultobj;
8057 fail:
8058 return NULL;
8059 }
8060
8061
8062 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8063 PyObject *resultobj = 0;
8064 wxRect *arg1 = (wxRect *) 0 ;
8065 int arg2 ;
8066 void *argp1 = 0 ;
8067 int res1 = 0 ;
8068 int val2 ;
8069 int ecode2 = 0 ;
8070 PyObject *swig_obj[2] ;
8071
8072 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
8073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8074 if (!SWIG_IsOK(res1)) {
8075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
8076 }
8077 arg1 = reinterpret_cast< wxRect * >(argp1);
8078 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8079 if (!SWIG_IsOK(ecode2)) {
8080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
8081 }
8082 arg2 = static_cast< int >(val2);
8083 if (arg1) (arg1)->width = arg2;
8084
8085 resultobj = SWIG_Py_Void();
8086 return resultobj;
8087 fail:
8088 return NULL;
8089 }
8090
8091
8092 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8093 PyObject *resultobj = 0;
8094 wxRect *arg1 = (wxRect *) 0 ;
8095 int result;
8096 void *argp1 = 0 ;
8097 int res1 = 0 ;
8098 PyObject *swig_obj[1] ;
8099
8100 if (!args) SWIG_fail;
8101 swig_obj[0] = args;
8102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8103 if (!SWIG_IsOK(res1)) {
8104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
8105 }
8106 arg1 = reinterpret_cast< wxRect * >(argp1);
8107 result = (int) ((arg1)->width);
8108 resultobj = SWIG_From_int(static_cast< int >(result));
8109 return resultobj;
8110 fail:
8111 return NULL;
8112 }
8113
8114
8115 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8116 PyObject *resultobj = 0;
8117 wxRect *arg1 = (wxRect *) 0 ;
8118 int arg2 ;
8119 void *argp1 = 0 ;
8120 int res1 = 0 ;
8121 int val2 ;
8122 int ecode2 = 0 ;
8123 PyObject *swig_obj[2] ;
8124
8125 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
8126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8127 if (!SWIG_IsOK(res1)) {
8128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
8129 }
8130 arg1 = reinterpret_cast< wxRect * >(argp1);
8131 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8132 if (!SWIG_IsOK(ecode2)) {
8133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
8134 }
8135 arg2 = static_cast< int >(val2);
8136 if (arg1) (arg1)->height = arg2;
8137
8138 resultobj = SWIG_Py_Void();
8139 return resultobj;
8140 fail:
8141 return NULL;
8142 }
8143
8144
8145 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8146 PyObject *resultobj = 0;
8147 wxRect *arg1 = (wxRect *) 0 ;
8148 int result;
8149 void *argp1 = 0 ;
8150 int res1 = 0 ;
8151 PyObject *swig_obj[1] ;
8152
8153 if (!args) SWIG_fail;
8154 swig_obj[0] = args;
8155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8156 if (!SWIG_IsOK(res1)) {
8157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
8158 }
8159 arg1 = reinterpret_cast< wxRect * >(argp1);
8160 result = (int) ((arg1)->height);
8161 resultobj = SWIG_From_int(static_cast< int >(result));
8162 return resultobj;
8163 fail:
8164 return NULL;
8165 }
8166
8167
8168 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8169 PyObject *resultobj = 0;
8170 wxRect *arg1 = (wxRect *) 0 ;
8171 int arg2 = (int) 0 ;
8172 int arg3 = (int) 0 ;
8173 int arg4 = (int) 0 ;
8174 int arg5 = (int) 0 ;
8175 void *argp1 = 0 ;
8176 int res1 = 0 ;
8177 int val2 ;
8178 int ecode2 = 0 ;
8179 int val3 ;
8180 int ecode3 = 0 ;
8181 int val4 ;
8182 int ecode4 = 0 ;
8183 int val5 ;
8184 int ecode5 = 0 ;
8185 PyObject * obj0 = 0 ;
8186 PyObject * obj1 = 0 ;
8187 PyObject * obj2 = 0 ;
8188 PyObject * obj3 = 0 ;
8189 PyObject * obj4 = 0 ;
8190 char * kwnames[] = {
8191 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8192 };
8193
8194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8196 if (!SWIG_IsOK(res1)) {
8197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
8198 }
8199 arg1 = reinterpret_cast< wxRect * >(argp1);
8200 if (obj1) {
8201 ecode2 = SWIG_AsVal_int(obj1, &val2);
8202 if (!SWIG_IsOK(ecode2)) {
8203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
8204 }
8205 arg2 = static_cast< int >(val2);
8206 }
8207 if (obj2) {
8208 ecode3 = SWIG_AsVal_int(obj2, &val3);
8209 if (!SWIG_IsOK(ecode3)) {
8210 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
8211 }
8212 arg3 = static_cast< int >(val3);
8213 }
8214 if (obj3) {
8215 ecode4 = SWIG_AsVal_int(obj3, &val4);
8216 if (!SWIG_IsOK(ecode4)) {
8217 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
8218 }
8219 arg4 = static_cast< int >(val4);
8220 }
8221 if (obj4) {
8222 ecode5 = SWIG_AsVal_int(obj4, &val5);
8223 if (!SWIG_IsOK(ecode5)) {
8224 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
8225 }
8226 arg5 = static_cast< int >(val5);
8227 }
8228 {
8229 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
8230 if (PyErr_Occurred()) SWIG_fail;
8231 }
8232 resultobj = SWIG_Py_Void();
8233 return resultobj;
8234 fail:
8235 return NULL;
8236 }
8237
8238
8239 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8240 PyObject *resultobj = 0;
8241 wxRect *arg1 = (wxRect *) 0 ;
8242 PyObject *result = 0 ;
8243 void *argp1 = 0 ;
8244 int res1 = 0 ;
8245 PyObject *swig_obj[1] ;
8246
8247 if (!args) SWIG_fail;
8248 swig_obj[0] = args;
8249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8250 if (!SWIG_IsOK(res1)) {
8251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8252 }
8253 arg1 = reinterpret_cast< wxRect * >(argp1);
8254 {
8255 result = (PyObject *)wxRect_Get(arg1);
8256 if (PyErr_Occurred()) SWIG_fail;
8257 }
8258 resultobj = result;
8259 return resultobj;
8260 fail:
8261 return NULL;
8262 }
8263
8264
8265 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8266 PyObject *obj;
8267 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8268 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8269 return SWIG_Py_Void();
8270 }
8271
8272 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8273 return SWIG_Python_InitShadowInstance(args);
8274 }
8275
8276 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8277 PyObject *resultobj = 0;
8278 wxRect *arg1 = (wxRect *) 0 ;
8279 wxRect *arg2 = (wxRect *) 0 ;
8280 PyObject *result = 0 ;
8281 void *argp1 = 0 ;
8282 int res1 = 0 ;
8283 void *argp2 = 0 ;
8284 int res2 = 0 ;
8285 PyObject * obj0 = 0 ;
8286 PyObject * obj1 = 0 ;
8287 char * kwnames[] = {
8288 (char *) "r1",(char *) "r2", NULL
8289 };
8290
8291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8293 if (!SWIG_IsOK(res1)) {
8294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8295 }
8296 arg1 = reinterpret_cast< wxRect * >(argp1);
8297 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8298 if (!SWIG_IsOK(res2)) {
8299 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8300 }
8301 arg2 = reinterpret_cast< wxRect * >(argp2);
8302 {
8303 if (!wxPyCheckForApp()) SWIG_fail;
8304 PyThreadState* __tstate = wxPyBeginAllowThreads();
8305 result = (PyObject *)wxIntersectRect(arg1,arg2);
8306 wxPyEndAllowThreads(__tstate);
8307 if (PyErr_Occurred()) SWIG_fail;
8308 }
8309 resultobj = result;
8310 return resultobj;
8311 fail:
8312 return NULL;
8313 }
8314
8315
8316 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8317 PyObject *resultobj = 0;
8318 double arg1 = (double) 0.0 ;
8319 double arg2 = (double) 0.0 ;
8320 wxPoint2D *result = 0 ;
8321 double val1 ;
8322 int ecode1 = 0 ;
8323 double val2 ;
8324 int ecode2 = 0 ;
8325 PyObject * obj0 = 0 ;
8326 PyObject * obj1 = 0 ;
8327 char * kwnames[] = {
8328 (char *) "x",(char *) "y", NULL
8329 };
8330
8331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8332 if (obj0) {
8333 ecode1 = SWIG_AsVal_double(obj0, &val1);
8334 if (!SWIG_IsOK(ecode1)) {
8335 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8336 }
8337 arg1 = static_cast< double >(val1);
8338 }
8339 if (obj1) {
8340 ecode2 = SWIG_AsVal_double(obj1, &val2);
8341 if (!SWIG_IsOK(ecode2)) {
8342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8343 }
8344 arg2 = static_cast< double >(val2);
8345 }
8346 {
8347 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8348 if (PyErr_Occurred()) SWIG_fail;
8349 }
8350 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8351 return resultobj;
8352 fail:
8353 return NULL;
8354 }
8355
8356
8357 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8358 PyObject *resultobj = 0;
8359 wxPoint2D *arg1 = 0 ;
8360 wxPoint2D *result = 0 ;
8361 wxPoint2D temp1 ;
8362 PyObject * obj0 = 0 ;
8363 char * kwnames[] = {
8364 (char *) "pt", NULL
8365 };
8366
8367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8368 {
8369 arg1 = &temp1;
8370 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8371 }
8372 {
8373 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8374 if (PyErr_Occurred()) SWIG_fail;
8375 }
8376 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8377 return resultobj;
8378 fail:
8379 return NULL;
8380 }
8381
8382
8383 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8384 PyObject *resultobj = 0;
8385 wxPoint *arg1 = 0 ;
8386 wxPoint2D *result = 0 ;
8387 wxPoint temp1 ;
8388 PyObject * obj0 = 0 ;
8389 char * kwnames[] = {
8390 (char *) "pt", NULL
8391 };
8392
8393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8394 {
8395 arg1 = &temp1;
8396 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8397 }
8398 {
8399 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8400 if (PyErr_Occurred()) SWIG_fail;
8401 }
8402 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8403 return resultobj;
8404 fail:
8405 return NULL;
8406 }
8407
8408
8409 SWIGINTERN PyObject *_wrap_delete_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8410 PyObject *resultobj = 0;
8411 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8412 void *argp1 = 0 ;
8413 int res1 = 0 ;
8414 PyObject *swig_obj[1] ;
8415
8416 if (!args) SWIG_fail;
8417 swig_obj[0] = args;
8418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8419 if (!SWIG_IsOK(res1)) {
8420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point2D" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8421 }
8422 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8423 {
8424 delete arg1;
8425
8426 if (PyErr_Occurred()) SWIG_fail;
8427 }
8428 resultobj = SWIG_Py_Void();
8429 return resultobj;
8430 fail:
8431 return NULL;
8432 }
8433
8434
8435 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8436 PyObject *resultobj = 0;
8437 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8438 int *arg2 = (int *) 0 ;
8439 int *arg3 = (int *) 0 ;
8440 void *argp1 = 0 ;
8441 int res1 = 0 ;
8442 int temp2 ;
8443 int res2 = SWIG_TMPOBJ ;
8444 int temp3 ;
8445 int res3 = SWIG_TMPOBJ ;
8446 PyObject *swig_obj[1] ;
8447
8448 arg2 = &temp2;
8449 arg3 = &temp3;
8450 if (!args) SWIG_fail;
8451 swig_obj[0] = args;
8452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8453 if (!SWIG_IsOK(res1)) {
8454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8455 }
8456 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8457 {
8458 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8459 if (PyErr_Occurred()) SWIG_fail;
8460 }
8461 resultobj = SWIG_Py_Void();
8462 if (SWIG_IsTmpObj(res2)) {
8463 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8464 } else {
8465 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8466 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8467 }
8468 if (SWIG_IsTmpObj(res3)) {
8469 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8470 } else {
8471 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8472 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8473 }
8474 return resultobj;
8475 fail:
8476 return NULL;
8477 }
8478
8479
8480 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8481 PyObject *resultobj = 0;
8482 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8483 int *arg2 = (int *) 0 ;
8484 int *arg3 = (int *) 0 ;
8485 void *argp1 = 0 ;
8486 int res1 = 0 ;
8487 int temp2 ;
8488 int res2 = SWIG_TMPOBJ ;
8489 int temp3 ;
8490 int res3 = SWIG_TMPOBJ ;
8491 PyObject *swig_obj[1] ;
8492
8493 arg2 = &temp2;
8494 arg3 = &temp3;
8495 if (!args) SWIG_fail;
8496 swig_obj[0] = args;
8497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8498 if (!SWIG_IsOK(res1)) {
8499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8500 }
8501 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8502 {
8503 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8504 if (PyErr_Occurred()) SWIG_fail;
8505 }
8506 resultobj = SWIG_Py_Void();
8507 if (SWIG_IsTmpObj(res2)) {
8508 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8509 } else {
8510 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8511 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8512 }
8513 if (SWIG_IsTmpObj(res3)) {
8514 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8515 } else {
8516 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8517 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8518 }
8519 return resultobj;
8520 fail:
8521 return NULL;
8522 }
8523
8524
8525 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8526 PyObject *resultobj = 0;
8527 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8528 double result;
8529 void *argp1 = 0 ;
8530 int res1 = 0 ;
8531 PyObject *swig_obj[1] ;
8532
8533 if (!args) SWIG_fail;
8534 swig_obj[0] = args;
8535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8536 if (!SWIG_IsOK(res1)) {
8537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8538 }
8539 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8540 {
8541 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8542 if (PyErr_Occurred()) SWIG_fail;
8543 }
8544 resultobj = SWIG_From_double(static_cast< double >(result));
8545 return resultobj;
8546 fail:
8547 return NULL;
8548 }
8549
8550
8551 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8552 PyObject *resultobj = 0;
8553 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8554 double result;
8555 void *argp1 = 0 ;
8556 int res1 = 0 ;
8557 PyObject *swig_obj[1] ;
8558
8559 if (!args) SWIG_fail;
8560 swig_obj[0] = args;
8561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8562 if (!SWIG_IsOK(res1)) {
8563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8564 }
8565 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8566 {
8567 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8568 if (PyErr_Occurred()) SWIG_fail;
8569 }
8570 resultobj = SWIG_From_double(static_cast< double >(result));
8571 return resultobj;
8572 fail:
8573 return NULL;
8574 }
8575
8576
8577 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8578 PyObject *resultobj = 0;
8579 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8580 double arg2 ;
8581 void *argp1 = 0 ;
8582 int res1 = 0 ;
8583 double val2 ;
8584 int ecode2 = 0 ;
8585 PyObject * obj0 = 0 ;
8586 PyObject * obj1 = 0 ;
8587 char * kwnames[] = {
8588 (char *) "self",(char *) "length", NULL
8589 };
8590
8591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8593 if (!SWIG_IsOK(res1)) {
8594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8595 }
8596 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8597 ecode2 = SWIG_AsVal_double(obj1, &val2);
8598 if (!SWIG_IsOK(ecode2)) {
8599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8600 }
8601 arg2 = static_cast< double >(val2);
8602 {
8603 (arg1)->SetVectorLength(arg2);
8604 if (PyErr_Occurred()) SWIG_fail;
8605 }
8606 resultobj = SWIG_Py_Void();
8607 return resultobj;
8608 fail:
8609 return NULL;
8610 }
8611
8612
8613 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8614 PyObject *resultobj = 0;
8615 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8616 double arg2 ;
8617 void *argp1 = 0 ;
8618 int res1 = 0 ;
8619 double val2 ;
8620 int ecode2 = 0 ;
8621 PyObject * obj0 = 0 ;
8622 PyObject * obj1 = 0 ;
8623 char * kwnames[] = {
8624 (char *) "self",(char *) "degrees", NULL
8625 };
8626
8627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8629 if (!SWIG_IsOK(res1)) {
8630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8631 }
8632 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8633 ecode2 = SWIG_AsVal_double(obj1, &val2);
8634 if (!SWIG_IsOK(ecode2)) {
8635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8636 }
8637 arg2 = static_cast< double >(val2);
8638 {
8639 (arg1)->SetVectorAngle(arg2);
8640 if (PyErr_Occurred()) SWIG_fail;
8641 }
8642 resultobj = SWIG_Py_Void();
8643 return resultobj;
8644 fail:
8645 return NULL;
8646 }
8647
8648
8649 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8650 PyObject *resultobj = 0;
8651 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8652 wxPoint2D *arg2 = 0 ;
8653 double result;
8654 void *argp1 = 0 ;
8655 int res1 = 0 ;
8656 wxPoint2D temp2 ;
8657 PyObject * obj0 = 0 ;
8658 PyObject * obj1 = 0 ;
8659 char * kwnames[] = {
8660 (char *) "self",(char *) "pt", NULL
8661 };
8662
8663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8665 if (!SWIG_IsOK(res1)) {
8666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8667 }
8668 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8669 {
8670 arg2 = &temp2;
8671 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8672 }
8673 {
8674 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8675 if (PyErr_Occurred()) SWIG_fail;
8676 }
8677 resultobj = SWIG_From_double(static_cast< double >(result));
8678 return resultobj;
8679 fail:
8680 return NULL;
8681 }
8682
8683
8684 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8685 PyObject *resultobj = 0;
8686 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8687 wxPoint2D *arg2 = 0 ;
8688 double result;
8689 void *argp1 = 0 ;
8690 int res1 = 0 ;
8691 wxPoint2D temp2 ;
8692 PyObject * obj0 = 0 ;
8693 PyObject * obj1 = 0 ;
8694 char * kwnames[] = {
8695 (char *) "self",(char *) "pt", NULL
8696 };
8697
8698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8700 if (!SWIG_IsOK(res1)) {
8701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8702 }
8703 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8704 {
8705 arg2 = &temp2;
8706 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8707 }
8708 {
8709 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8710 if (PyErr_Occurred()) SWIG_fail;
8711 }
8712 resultobj = SWIG_From_double(static_cast< double >(result));
8713 return resultobj;
8714 fail:
8715 return NULL;
8716 }
8717
8718
8719 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8720 PyObject *resultobj = 0;
8721 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8722 wxPoint2D *arg2 = 0 ;
8723 double result;
8724 void *argp1 = 0 ;
8725 int res1 = 0 ;
8726 wxPoint2D temp2 ;
8727 PyObject * obj0 = 0 ;
8728 PyObject * obj1 = 0 ;
8729 char * kwnames[] = {
8730 (char *) "self",(char *) "vec", NULL
8731 };
8732
8733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8735 if (!SWIG_IsOK(res1)) {
8736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8737 }
8738 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8739 {
8740 arg2 = &temp2;
8741 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8742 }
8743 {
8744 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8745 if (PyErr_Occurred()) SWIG_fail;
8746 }
8747 resultobj = SWIG_From_double(static_cast< double >(result));
8748 return resultobj;
8749 fail:
8750 return NULL;
8751 }
8752
8753
8754 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8755 PyObject *resultobj = 0;
8756 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8757 wxPoint2D *arg2 = 0 ;
8758 double result;
8759 void *argp1 = 0 ;
8760 int res1 = 0 ;
8761 wxPoint2D temp2 ;
8762 PyObject * obj0 = 0 ;
8763 PyObject * obj1 = 0 ;
8764 char * kwnames[] = {
8765 (char *) "self",(char *) "vec", NULL
8766 };
8767
8768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8770 if (!SWIG_IsOK(res1)) {
8771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8772 }
8773 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8774 {
8775 arg2 = &temp2;
8776 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8777 }
8778 {
8779 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8780 if (PyErr_Occurred()) SWIG_fail;
8781 }
8782 resultobj = SWIG_From_double(static_cast< double >(result));
8783 return resultobj;
8784 fail:
8785 return NULL;
8786 }
8787
8788
8789 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8790 PyObject *resultobj = 0;
8791 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8792 wxPoint2D result;
8793 void *argp1 = 0 ;
8794 int res1 = 0 ;
8795 PyObject *swig_obj[1] ;
8796
8797 if (!args) SWIG_fail;
8798 swig_obj[0] = args;
8799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8800 if (!SWIG_IsOK(res1)) {
8801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8802 }
8803 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8804 {
8805 result = (arg1)->operator -();
8806 if (PyErr_Occurred()) SWIG_fail;
8807 }
8808 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8809 return resultobj;
8810 fail:
8811 return NULL;
8812 }
8813
8814
8815 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8816 PyObject *resultobj = 0;
8817 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8818 wxPoint2D *arg2 = 0 ;
8819 wxPoint2D *result = 0 ;
8820 void *argp1 = 0 ;
8821 int res1 = 0 ;
8822 wxPoint2D temp2 ;
8823 PyObject * obj0 = 0 ;
8824 PyObject * obj1 = 0 ;
8825 char * kwnames[] = {
8826 (char *) "self",(char *) "pt", NULL
8827 };
8828
8829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8831 if (!SWIG_IsOK(res1)) {
8832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8833 }
8834 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8835 {
8836 arg2 = &temp2;
8837 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8838 }
8839 {
8840 {
8841 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8842 result = (wxPoint2D *) &_result_ref;
8843 }
8844 if (PyErr_Occurred()) SWIG_fail;
8845 }
8846 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8847 return resultobj;
8848 fail:
8849 return NULL;
8850 }
8851
8852
8853 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8854 PyObject *resultobj = 0;
8855 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8856 wxPoint2D *arg2 = 0 ;
8857 wxPoint2D *result = 0 ;
8858 void *argp1 = 0 ;
8859 int res1 = 0 ;
8860 wxPoint2D temp2 ;
8861 PyObject * obj0 = 0 ;
8862 PyObject * obj1 = 0 ;
8863 char * kwnames[] = {
8864 (char *) "self",(char *) "pt", NULL
8865 };
8866
8867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8869 if (!SWIG_IsOK(res1)) {
8870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8871 }
8872 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8873 {
8874 arg2 = &temp2;
8875 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8876 }
8877 {
8878 {
8879 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8880 result = (wxPoint2D *) &_result_ref;
8881 }
8882 if (PyErr_Occurred()) SWIG_fail;
8883 }
8884 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8885 return resultobj;
8886 fail:
8887 return NULL;
8888 }
8889
8890
8891 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8892 PyObject *resultobj = 0;
8893 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8894 wxPoint2D *arg2 = 0 ;
8895 wxPoint2D *result = 0 ;
8896 void *argp1 = 0 ;
8897 int res1 = 0 ;
8898 wxPoint2D temp2 ;
8899 PyObject * obj0 = 0 ;
8900 PyObject * obj1 = 0 ;
8901 char * kwnames[] = {
8902 (char *) "self",(char *) "pt", NULL
8903 };
8904
8905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8907 if (!SWIG_IsOK(res1)) {
8908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8909 }
8910 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8911 {
8912 arg2 = &temp2;
8913 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8914 }
8915 {
8916 {
8917 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8918 result = (wxPoint2D *) &_result_ref;
8919 }
8920 if (PyErr_Occurred()) SWIG_fail;
8921 }
8922 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8923 return resultobj;
8924 fail:
8925 return NULL;
8926 }
8927
8928
8929 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8930 PyObject *resultobj = 0;
8931 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8932 wxPoint2D *arg2 = 0 ;
8933 wxPoint2D *result = 0 ;
8934 void *argp1 = 0 ;
8935 int res1 = 0 ;
8936 wxPoint2D temp2 ;
8937 PyObject * obj0 = 0 ;
8938 PyObject * obj1 = 0 ;
8939 char * kwnames[] = {
8940 (char *) "self",(char *) "pt", NULL
8941 };
8942
8943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8945 if (!SWIG_IsOK(res1)) {
8946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8947 }
8948 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8949 {
8950 arg2 = &temp2;
8951 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8952 }
8953 {
8954 {
8955 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8956 result = (wxPoint2D *) &_result_ref;
8957 }
8958 if (PyErr_Occurred()) SWIG_fail;
8959 }
8960 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8961 return resultobj;
8962 fail:
8963 return NULL;
8964 }
8965
8966
8967 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8968 PyObject *resultobj = 0;
8969 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8970 PyObject *arg2 = (PyObject *) 0 ;
8971 bool result;
8972 void *argp1 = 0 ;
8973 int res1 = 0 ;
8974 PyObject * obj0 = 0 ;
8975 PyObject * obj1 = 0 ;
8976 char * kwnames[] = {
8977 (char *) "self",(char *) "other", NULL
8978 };
8979
8980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8982 if (!SWIG_IsOK(res1)) {
8983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8984 }
8985 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8986 arg2 = obj1;
8987 {
8988 result = (bool)wxPoint2D___eq__(arg1,arg2);
8989 if (PyErr_Occurred()) SWIG_fail;
8990 }
8991 {
8992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8993 }
8994 return resultobj;
8995 fail:
8996 return NULL;
8997 }
8998
8999
9000 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9001 PyObject *resultobj = 0;
9002 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9003 PyObject *arg2 = (PyObject *) 0 ;
9004 bool result;
9005 void *argp1 = 0 ;
9006 int res1 = 0 ;
9007 PyObject * obj0 = 0 ;
9008 PyObject * obj1 = 0 ;
9009 char * kwnames[] = {
9010 (char *) "self",(char *) "other", NULL
9011 };
9012
9013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
9014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9015 if (!SWIG_IsOK(res1)) {
9016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9017 }
9018 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9019 arg2 = obj1;
9020 {
9021 result = (bool)wxPoint2D___ne__(arg1,arg2);
9022 if (PyErr_Occurred()) SWIG_fail;
9023 }
9024 {
9025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9026 }
9027 return resultobj;
9028 fail:
9029 return NULL;
9030 }
9031
9032
9033 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9034 PyObject *resultobj = 0;
9035 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9036 double arg2 ;
9037 void *argp1 = 0 ;
9038 int res1 = 0 ;
9039 double val2 ;
9040 int ecode2 = 0 ;
9041 PyObject *swig_obj[2] ;
9042
9043 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
9044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9045 if (!SWIG_IsOK(res1)) {
9046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9047 }
9048 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9049 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9050 if (!SWIG_IsOK(ecode2)) {
9051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
9052 }
9053 arg2 = static_cast< double >(val2);
9054 if (arg1) (arg1)->m_x = arg2;
9055
9056 resultobj = SWIG_Py_Void();
9057 return resultobj;
9058 fail:
9059 return NULL;
9060 }
9061
9062
9063 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9064 PyObject *resultobj = 0;
9065 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9066 double result;
9067 void *argp1 = 0 ;
9068 int res1 = 0 ;
9069 PyObject *swig_obj[1] ;
9070
9071 if (!args) SWIG_fail;
9072 swig_obj[0] = args;
9073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9074 if (!SWIG_IsOK(res1)) {
9075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9076 }
9077 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9078 result = (double) ((arg1)->m_x);
9079 resultobj = SWIG_From_double(static_cast< double >(result));
9080 return resultobj;
9081 fail:
9082 return NULL;
9083 }
9084
9085
9086 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9087 PyObject *resultobj = 0;
9088 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9089 double arg2 ;
9090 void *argp1 = 0 ;
9091 int res1 = 0 ;
9092 double val2 ;
9093 int ecode2 = 0 ;
9094 PyObject *swig_obj[2] ;
9095
9096 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
9097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9098 if (!SWIG_IsOK(res1)) {
9099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9100 }
9101 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9102 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9103 if (!SWIG_IsOK(ecode2)) {
9104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
9105 }
9106 arg2 = static_cast< double >(val2);
9107 if (arg1) (arg1)->m_y = arg2;
9108
9109 resultobj = SWIG_Py_Void();
9110 return resultobj;
9111 fail:
9112 return NULL;
9113 }
9114
9115
9116 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9117 PyObject *resultobj = 0;
9118 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9119 double result;
9120 void *argp1 = 0 ;
9121 int res1 = 0 ;
9122 PyObject *swig_obj[1] ;
9123
9124 if (!args) SWIG_fail;
9125 swig_obj[0] = args;
9126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9127 if (!SWIG_IsOK(res1)) {
9128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9129 }
9130 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9131 result = (double) ((arg1)->m_y);
9132 resultobj = SWIG_From_double(static_cast< double >(result));
9133 return resultobj;
9134 fail:
9135 return NULL;
9136 }
9137
9138
9139 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9140 PyObject *resultobj = 0;
9141 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9142 double arg2 = (double) 0 ;
9143 double arg3 = (double) 0 ;
9144 void *argp1 = 0 ;
9145 int res1 = 0 ;
9146 double val2 ;
9147 int ecode2 = 0 ;
9148 double val3 ;
9149 int ecode3 = 0 ;
9150 PyObject * obj0 = 0 ;
9151 PyObject * obj1 = 0 ;
9152 PyObject * obj2 = 0 ;
9153 char * kwnames[] = {
9154 (char *) "self",(char *) "x",(char *) "y", NULL
9155 };
9156
9157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9159 if (!SWIG_IsOK(res1)) {
9160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9161 }
9162 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9163 if (obj1) {
9164 ecode2 = SWIG_AsVal_double(obj1, &val2);
9165 if (!SWIG_IsOK(ecode2)) {
9166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
9167 }
9168 arg2 = static_cast< double >(val2);
9169 }
9170 if (obj2) {
9171 ecode3 = SWIG_AsVal_double(obj2, &val3);
9172 if (!SWIG_IsOK(ecode3)) {
9173 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
9174 }
9175 arg3 = static_cast< double >(val3);
9176 }
9177 {
9178 wxPoint2D_Set(arg1,arg2,arg3);
9179 if (PyErr_Occurred()) SWIG_fail;
9180 }
9181 resultobj = SWIG_Py_Void();
9182 return resultobj;
9183 fail:
9184 return NULL;
9185 }
9186
9187
9188 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9189 PyObject *resultobj = 0;
9190 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9191 PyObject *result = 0 ;
9192 void *argp1 = 0 ;
9193 int res1 = 0 ;
9194 PyObject *swig_obj[1] ;
9195
9196 if (!args) SWIG_fail;
9197 swig_obj[0] = args;
9198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9199 if (!SWIG_IsOK(res1)) {
9200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9201 }
9202 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9203 {
9204 result = (PyObject *)wxPoint2D_Get(arg1);
9205 if (PyErr_Occurred()) SWIG_fail;
9206 }
9207 resultobj = result;
9208 return resultobj;
9209 fail:
9210 return NULL;
9211 }
9212
9213
9214 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9215 PyObject *obj;
9216 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9217 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
9218 return SWIG_Py_Void();
9219 }
9220
9221 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9222 return SWIG_Python_InitShadowInstance(args);
9223 }
9224
9225 SWIGINTERN PyObject *_wrap_new_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9226 PyObject *resultobj = 0;
9227 wxDouble arg1 = (wxDouble) 0.0 ;
9228 wxDouble arg2 = (wxDouble) 0.0 ;
9229 wxDouble arg3 = (wxDouble) 0.0 ;
9230 wxDouble arg4 = (wxDouble) 0.0 ;
9231 wxRect2D *result = 0 ;
9232 void *argp1 ;
9233 int res1 = 0 ;
9234 void *argp2 ;
9235 int res2 = 0 ;
9236 void *argp3 ;
9237 int res3 = 0 ;
9238 void *argp4 ;
9239 int res4 = 0 ;
9240 PyObject * obj0 = 0 ;
9241 PyObject * obj1 = 0 ;
9242 PyObject * obj2 = 0 ;
9243 PyObject * obj3 = 0 ;
9244 char * kwnames[] = {
9245 (char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
9246 };
9247
9248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect2D",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9249 if (obj0) {
9250 {
9251 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDouble, 0 | 0);
9252 if (!SWIG_IsOK(res1)) {
9253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9254 }
9255 if (!argp1) {
9256 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9257 } else {
9258 wxDouble * temp = reinterpret_cast< wxDouble * >(argp1);
9259 arg1 = *temp;
9260 if (SWIG_IsNewObj(res1)) delete temp;
9261 }
9262 }
9263 }
9264 if (obj1) {
9265 {
9266 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9267 if (!SWIG_IsOK(res2)) {
9268 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9269 }
9270 if (!argp2) {
9271 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9272 } else {
9273 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9274 arg2 = *temp;
9275 if (SWIG_IsNewObj(res2)) delete temp;
9276 }
9277 }
9278 }
9279 if (obj2) {
9280 {
9281 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
9282 if (!SWIG_IsOK(res3)) {
9283 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9284 }
9285 if (!argp3) {
9286 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9287 } else {
9288 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
9289 arg3 = *temp;
9290 if (SWIG_IsNewObj(res3)) delete temp;
9291 }
9292 }
9293 }
9294 if (obj3) {
9295 {
9296 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
9297 if (!SWIG_IsOK(res4)) {
9298 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9299 }
9300 if (!argp4) {
9301 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9302 } else {
9303 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
9304 arg4 = *temp;
9305 if (SWIG_IsNewObj(res4)) delete temp;
9306 }
9307 }
9308 }
9309 {
9310 result = (wxRect2D *)new wxRect2D(arg1,arg2,arg3,arg4);
9311 if (PyErr_Occurred()) SWIG_fail;
9312 }
9313 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect2D, SWIG_POINTER_NEW | 0 );
9314 return resultobj;
9315 fail:
9316 return NULL;
9317 }
9318
9319
9320 SWIGINTERN PyObject *_wrap_delete_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9321 PyObject *resultobj = 0;
9322 wxRect2D *arg1 = (wxRect2D *) 0 ;
9323 void *argp1 = 0 ;
9324 int res1 = 0 ;
9325 PyObject *swig_obj[1] ;
9326
9327 if (!args) SWIG_fail;
9328 swig_obj[0] = args;
9329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, SWIG_POINTER_DISOWN | 0 );
9330 if (!SWIG_IsOK(res1)) {
9331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect2D" "', expected argument " "1"" of type '" "wxRect2D *""'");
9332 }
9333 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9334 {
9335 delete arg1;
9336
9337 if (PyErr_Occurred()) SWIG_fail;
9338 }
9339 resultobj = SWIG_Py_Void();
9340 return resultobj;
9341 fail:
9342 return NULL;
9343 }
9344
9345
9346 SWIGINTERN PyObject *_wrap_Rect2D_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9347 PyObject *resultobj = 0;
9348 wxRect2D *arg1 = (wxRect2D *) 0 ;
9349 wxPoint2D result;
9350 void *argp1 = 0 ;
9351 int res1 = 0 ;
9352 PyObject *swig_obj[1] ;
9353
9354 if (!args) SWIG_fail;
9355 swig_obj[0] = args;
9356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9357 if (!SWIG_IsOK(res1)) {
9358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetPosition" "', expected argument " "1"" of type '" "wxRect2D *""'");
9359 }
9360 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9361 {
9362 result = (arg1)->GetPosition();
9363 if (PyErr_Occurred()) SWIG_fail;
9364 }
9365 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9366 return resultobj;
9367 fail:
9368 return NULL;
9369 }
9370
9371
9372 SWIGINTERN PyObject *_wrap_Rect2D_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9373 PyObject *resultobj = 0;
9374 wxRect2D *arg1 = (wxRect2D *) 0 ;
9375 wxSize result;
9376 void *argp1 = 0 ;
9377 int res1 = 0 ;
9378 PyObject *swig_obj[1] ;
9379
9380 if (!args) SWIG_fail;
9381 swig_obj[0] = args;
9382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9383 if (!SWIG_IsOK(res1)) {
9384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetSize" "', expected argument " "1"" of type '" "wxRect2D *""'");
9385 }
9386 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9387 {
9388 result = (arg1)->GetSize();
9389 if (PyErr_Occurred()) SWIG_fail;
9390 }
9391 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
9392 return resultobj;
9393 fail:
9394 return NULL;
9395 }
9396
9397
9398 SWIGINTERN PyObject *_wrap_Rect2D_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9399 PyObject *resultobj = 0;
9400 wxRect2D *arg1 = (wxRect2D *) 0 ;
9401 wxDouble result;
9402 void *argp1 = 0 ;
9403 int res1 = 0 ;
9404 PyObject *swig_obj[1] ;
9405
9406 if (!args) SWIG_fail;
9407 swig_obj[0] = args;
9408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9409 if (!SWIG_IsOK(res1)) {
9410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeft" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9411 }
9412 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9413 {
9414 result = ((wxRect2D const *)arg1)->GetLeft();
9415 if (PyErr_Occurred()) SWIG_fail;
9416 }
9417 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9418 return resultobj;
9419 fail:
9420 return NULL;
9421 }
9422
9423
9424 SWIGINTERN PyObject *_wrap_Rect2D_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9425 PyObject *resultobj = 0;
9426 wxRect2D *arg1 = (wxRect2D *) 0 ;
9427 wxDouble arg2 ;
9428 void *argp1 = 0 ;
9429 int res1 = 0 ;
9430 void *argp2 ;
9431 int res2 = 0 ;
9432 PyObject * obj0 = 0 ;
9433 PyObject * obj1 = 0 ;
9434 char * kwnames[] = {
9435 (char *) "self",(char *) "n", NULL
9436 };
9437
9438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
9439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9440 if (!SWIG_IsOK(res1)) {
9441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeft" "', expected argument " "1"" of type '" "wxRect2D *""'");
9442 }
9443 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9444 {
9445 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9446 if (!SWIG_IsOK(res2)) {
9447 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9448 }
9449 if (!argp2) {
9450 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9451 } else {
9452 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9453 arg2 = *temp;
9454 if (SWIG_IsNewObj(res2)) delete temp;
9455 }
9456 }
9457 {
9458 (arg1)->SetLeft(arg2);
9459 if (PyErr_Occurred()) SWIG_fail;
9460 }
9461 resultobj = SWIG_Py_Void();
9462 return resultobj;
9463 fail:
9464 return NULL;
9465 }
9466
9467
9468 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9469 PyObject *resultobj = 0;
9470 wxRect2D *arg1 = (wxRect2D *) 0 ;
9471 wxDouble arg2 ;
9472 void *argp1 = 0 ;
9473 int res1 = 0 ;
9474 void *argp2 ;
9475 int res2 = 0 ;
9476 PyObject * obj0 = 0 ;
9477 PyObject * obj1 = 0 ;
9478 char * kwnames[] = {
9479 (char *) "self",(char *) "n", NULL
9480 };
9481
9482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTo",kwnames,&obj0,&obj1)) SWIG_fail;
9483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9484 if (!SWIG_IsOK(res1)) {
9485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9486 }
9487 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9488 {
9489 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9490 if (!SWIG_IsOK(res2)) {
9491 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9492 }
9493 if (!argp2) {
9494 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9495 } else {
9496 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9497 arg2 = *temp;
9498 if (SWIG_IsNewObj(res2)) delete temp;
9499 }
9500 }
9501 {
9502 (arg1)->MoveLeftTo(arg2);
9503 if (PyErr_Occurred()) SWIG_fail;
9504 }
9505 resultobj = SWIG_Py_Void();
9506 return resultobj;
9507 fail:
9508 return NULL;
9509 }
9510
9511
9512 SWIGINTERN PyObject *_wrap_Rect2D_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9513 PyObject *resultobj = 0;
9514 wxRect2D *arg1 = (wxRect2D *) 0 ;
9515 wxDouble result;
9516 void *argp1 = 0 ;
9517 int res1 = 0 ;
9518 PyObject *swig_obj[1] ;
9519
9520 if (!args) SWIG_fail;
9521 swig_obj[0] = args;
9522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9523 if (!SWIG_IsOK(res1)) {
9524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9525 }
9526 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9527 {
9528 result = ((wxRect2D const *)arg1)->GetTop();
9529 if (PyErr_Occurred()) SWIG_fail;
9530 }
9531 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9532 return resultobj;
9533 fail:
9534 return NULL;
9535 }
9536
9537
9538 SWIGINTERN PyObject *_wrap_Rect2D_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9539 PyObject *resultobj = 0;
9540 wxRect2D *arg1 = (wxRect2D *) 0 ;
9541 wxDouble arg2 ;
9542 void *argp1 = 0 ;
9543 int res1 = 0 ;
9544 void *argp2 ;
9545 int res2 = 0 ;
9546 PyObject * obj0 = 0 ;
9547 PyObject * obj1 = 0 ;
9548 char * kwnames[] = {
9549 (char *) "self",(char *) "n", NULL
9550 };
9551
9552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
9553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9554 if (!SWIG_IsOK(res1)) {
9555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9556 }
9557 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9558 {
9559 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9560 if (!SWIG_IsOK(res2)) {
9561 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9562 }
9563 if (!argp2) {
9564 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9565 } else {
9566 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9567 arg2 = *temp;
9568 if (SWIG_IsNewObj(res2)) delete temp;
9569 }
9570 }
9571 {
9572 (arg1)->SetTop(arg2);
9573 if (PyErr_Occurred()) SWIG_fail;
9574 }
9575 resultobj = SWIG_Py_Void();
9576 return resultobj;
9577 fail:
9578 return NULL;
9579 }
9580
9581
9582 SWIGINTERN PyObject *_wrap_Rect2D_MoveTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9583 PyObject *resultobj = 0;
9584 wxRect2D *arg1 = (wxRect2D *) 0 ;
9585 wxDouble arg2 ;
9586 void *argp1 = 0 ;
9587 int res1 = 0 ;
9588 void *argp2 ;
9589 int res2 = 0 ;
9590 PyObject * obj0 = 0 ;
9591 PyObject * obj1 = 0 ;
9592 char * kwnames[] = {
9593 (char *) "self",(char *) "n", NULL
9594 };
9595
9596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9598 if (!SWIG_IsOK(res1)) {
9599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9600 }
9601 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9602 {
9603 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9604 if (!SWIG_IsOK(res2)) {
9605 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9606 }
9607 if (!argp2) {
9608 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9609 } else {
9610 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9611 arg2 = *temp;
9612 if (SWIG_IsNewObj(res2)) delete temp;
9613 }
9614 }
9615 {
9616 (arg1)->MoveTopTo(arg2);
9617 if (PyErr_Occurred()) SWIG_fail;
9618 }
9619 resultobj = SWIG_Py_Void();
9620 return resultobj;
9621 fail:
9622 return NULL;
9623 }
9624
9625
9626 SWIGINTERN PyObject *_wrap_Rect2D_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9627 PyObject *resultobj = 0;
9628 wxRect2D *arg1 = (wxRect2D *) 0 ;
9629 wxDouble result;
9630 void *argp1 = 0 ;
9631 int res1 = 0 ;
9632 PyObject *swig_obj[1] ;
9633
9634 if (!args) SWIG_fail;
9635 swig_obj[0] = args;
9636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9637 if (!SWIG_IsOK(res1)) {
9638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9639 }
9640 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9641 {
9642 result = ((wxRect2D const *)arg1)->GetBottom();
9643 if (PyErr_Occurred()) SWIG_fail;
9644 }
9645 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9646 return resultobj;
9647 fail:
9648 return NULL;
9649 }
9650
9651
9652 SWIGINTERN PyObject *_wrap_Rect2D_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9653 PyObject *resultobj = 0;
9654 wxRect2D *arg1 = (wxRect2D *) 0 ;
9655 wxDouble arg2 ;
9656 void *argp1 = 0 ;
9657 int res1 = 0 ;
9658 void *argp2 ;
9659 int res2 = 0 ;
9660 PyObject * obj0 = 0 ;
9661 PyObject * obj1 = 0 ;
9662 char * kwnames[] = {
9663 (char *) "self",(char *) "n", NULL
9664 };
9665
9666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9668 if (!SWIG_IsOK(res1)) {
9669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9670 }
9671 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9672 {
9673 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9674 if (!SWIG_IsOK(res2)) {
9675 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9676 }
9677 if (!argp2) {
9678 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9679 } else {
9680 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9681 arg2 = *temp;
9682 if (SWIG_IsNewObj(res2)) delete temp;
9683 }
9684 }
9685 {
9686 (arg1)->SetBottom(arg2);
9687 if (PyErr_Occurred()) SWIG_fail;
9688 }
9689 resultobj = SWIG_Py_Void();
9690 return resultobj;
9691 fail:
9692 return NULL;
9693 }
9694
9695
9696 SWIGINTERN PyObject *_wrap_Rect2D_MoveBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9697 PyObject *resultobj = 0;
9698 wxRect2D *arg1 = (wxRect2D *) 0 ;
9699 wxDouble arg2 ;
9700 void *argp1 = 0 ;
9701 int res1 = 0 ;
9702 void *argp2 ;
9703 int res2 = 0 ;
9704 PyObject * obj0 = 0 ;
9705 PyObject * obj1 = 0 ;
9706 char * kwnames[] = {
9707 (char *) "self",(char *) "n", NULL
9708 };
9709
9710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9712 if (!SWIG_IsOK(res1)) {
9713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9714 }
9715 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9716 {
9717 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9718 if (!SWIG_IsOK(res2)) {
9719 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9720 }
9721 if (!argp2) {
9722 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9723 } else {
9724 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9725 arg2 = *temp;
9726 if (SWIG_IsNewObj(res2)) delete temp;
9727 }
9728 }
9729 {
9730 (arg1)->MoveBottomTo(arg2);
9731 if (PyErr_Occurred()) SWIG_fail;
9732 }
9733 resultobj = SWIG_Py_Void();
9734 return resultobj;
9735 fail:
9736 return NULL;
9737 }
9738
9739
9740 SWIGINTERN PyObject *_wrap_Rect2D_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9741 PyObject *resultobj = 0;
9742 wxRect2D *arg1 = (wxRect2D *) 0 ;
9743 wxDouble result;
9744 void *argp1 = 0 ;
9745 int res1 = 0 ;
9746 PyObject *swig_obj[1] ;
9747
9748 if (!args) SWIG_fail;
9749 swig_obj[0] = args;
9750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9751 if (!SWIG_IsOK(res1)) {
9752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRight" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9753 }
9754 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9755 {
9756 result = ((wxRect2D const *)arg1)->GetRight();
9757 if (PyErr_Occurred()) SWIG_fail;
9758 }
9759 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9760 return resultobj;
9761 fail:
9762 return NULL;
9763 }
9764
9765
9766 SWIGINTERN PyObject *_wrap_Rect2D_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9767 PyObject *resultobj = 0;
9768 wxRect2D *arg1 = (wxRect2D *) 0 ;
9769 wxDouble arg2 ;
9770 void *argp1 = 0 ;
9771 int res1 = 0 ;
9772 void *argp2 ;
9773 int res2 = 0 ;
9774 PyObject * obj0 = 0 ;
9775 PyObject * obj1 = 0 ;
9776 char * kwnames[] = {
9777 (char *) "self",(char *) "n", NULL
9778 };
9779
9780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
9781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9782 if (!SWIG_IsOK(res1)) {
9783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRight" "', expected argument " "1"" of type '" "wxRect2D *""'");
9784 }
9785 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9786 {
9787 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9788 if (!SWIG_IsOK(res2)) {
9789 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9790 }
9791 if (!argp2) {
9792 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9793 } else {
9794 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9795 arg2 = *temp;
9796 if (SWIG_IsNewObj(res2)) delete temp;
9797 }
9798 }
9799 {
9800 (arg1)->SetRight(arg2);
9801 if (PyErr_Occurred()) SWIG_fail;
9802 }
9803 resultobj = SWIG_Py_Void();
9804 return resultobj;
9805 fail:
9806 return NULL;
9807 }
9808
9809
9810 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9811 PyObject *resultobj = 0;
9812 wxRect2D *arg1 = (wxRect2D *) 0 ;
9813 wxDouble arg2 ;
9814 void *argp1 = 0 ;
9815 int res1 = 0 ;
9816 void *argp2 ;
9817 int res2 = 0 ;
9818 PyObject * obj0 = 0 ;
9819 PyObject * obj1 = 0 ;
9820 char * kwnames[] = {
9821 (char *) "self",(char *) "n", NULL
9822 };
9823
9824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTo",kwnames,&obj0,&obj1)) SWIG_fail;
9825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9826 if (!SWIG_IsOK(res1)) {
9827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9828 }
9829 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9830 {
9831 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9832 if (!SWIG_IsOK(res2)) {
9833 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9834 }
9835 if (!argp2) {
9836 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9837 } else {
9838 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9839 arg2 = *temp;
9840 if (SWIG_IsNewObj(res2)) delete temp;
9841 }
9842 }
9843 {
9844 (arg1)->MoveRightTo(arg2);
9845 if (PyErr_Occurred()) SWIG_fail;
9846 }
9847 resultobj = SWIG_Py_Void();
9848 return resultobj;
9849 fail:
9850 return NULL;
9851 }
9852
9853
9854 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9855 PyObject *resultobj = 0;
9856 wxRect2D *arg1 = (wxRect2D *) 0 ;
9857 wxPoint2D result;
9858 void *argp1 = 0 ;
9859 int res1 = 0 ;
9860 PyObject *swig_obj[1] ;
9861
9862 if (!args) SWIG_fail;
9863 swig_obj[0] = args;
9864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9865 if (!SWIG_IsOK(res1)) {
9866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9867 }
9868 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9869 {
9870 result = ((wxRect2D const *)arg1)->GetLeftTop();
9871 if (PyErr_Occurred()) SWIG_fail;
9872 }
9873 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9874 return resultobj;
9875 fail:
9876 return NULL;
9877 }
9878
9879
9880 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9881 PyObject *resultobj = 0;
9882 wxRect2D *arg1 = (wxRect2D *) 0 ;
9883 wxPoint2D *arg2 = 0 ;
9884 void *argp1 = 0 ;
9885 int res1 = 0 ;
9886 wxPoint2D temp2 ;
9887 PyObject * obj0 = 0 ;
9888 PyObject * obj1 = 0 ;
9889 char * kwnames[] = {
9890 (char *) "self",(char *) "pt", NULL
9891 };
9892
9893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftTop",kwnames,&obj0,&obj1)) SWIG_fail;
9894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9895 if (!SWIG_IsOK(res1)) {
9896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9897 }
9898 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9899 {
9900 arg2 = &temp2;
9901 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9902 }
9903 {
9904 (arg1)->SetLeftTop((wxPoint2D const &)*arg2);
9905 if (PyErr_Occurred()) SWIG_fail;
9906 }
9907 resultobj = SWIG_Py_Void();
9908 return resultobj;
9909 fail:
9910 return NULL;
9911 }
9912
9913
9914 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9915 PyObject *resultobj = 0;
9916 wxRect2D *arg1 = (wxRect2D *) 0 ;
9917 wxPoint2D *arg2 = 0 ;
9918 void *argp1 = 0 ;
9919 int res1 = 0 ;
9920 wxPoint2D temp2 ;
9921 PyObject * obj0 = 0 ;
9922 PyObject * obj1 = 0 ;
9923 char * kwnames[] = {
9924 (char *) "self",(char *) "pt", NULL
9925 };
9926
9927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9929 if (!SWIG_IsOK(res1)) {
9930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9931 }
9932 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9933 {
9934 arg2 = &temp2;
9935 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9936 }
9937 {
9938 (arg1)->MoveLeftTopTo((wxPoint2D const &)*arg2);
9939 if (PyErr_Occurred()) SWIG_fail;
9940 }
9941 resultobj = SWIG_Py_Void();
9942 return resultobj;
9943 fail:
9944 return NULL;
9945 }
9946
9947
9948 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9949 PyObject *resultobj = 0;
9950 wxRect2D *arg1 = (wxRect2D *) 0 ;
9951 wxPoint2D result;
9952 void *argp1 = 0 ;
9953 int res1 = 0 ;
9954 PyObject *swig_obj[1] ;
9955
9956 if (!args) SWIG_fail;
9957 swig_obj[0] = args;
9958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9959 if (!SWIG_IsOK(res1)) {
9960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9961 }
9962 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9963 {
9964 result = ((wxRect2D const *)arg1)->GetLeftBottom();
9965 if (PyErr_Occurred()) SWIG_fail;
9966 }
9967 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9968 return resultobj;
9969 fail:
9970 return NULL;
9971 }
9972
9973
9974 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9975 PyObject *resultobj = 0;
9976 wxRect2D *arg1 = (wxRect2D *) 0 ;
9977 wxPoint2D *arg2 = 0 ;
9978 void *argp1 = 0 ;
9979 int res1 = 0 ;
9980 wxPoint2D temp2 ;
9981 PyObject * obj0 = 0 ;
9982 PyObject * obj1 = 0 ;
9983 char * kwnames[] = {
9984 (char *) "self",(char *) "pt", NULL
9985 };
9986
9987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9989 if (!SWIG_IsOK(res1)) {
9990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9991 }
9992 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9993 {
9994 arg2 = &temp2;
9995 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9996 }
9997 {
9998 (arg1)->SetLeftBottom((wxPoint2D const &)*arg2);
9999 if (PyErr_Occurred()) SWIG_fail;
10000 }
10001 resultobj = SWIG_Py_Void();
10002 return resultobj;
10003 fail:
10004 return NULL;
10005 }
10006
10007
10008 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10009 PyObject *resultobj = 0;
10010 wxRect2D *arg1 = (wxRect2D *) 0 ;
10011 wxPoint2D *arg2 = 0 ;
10012 void *argp1 = 0 ;
10013 int res1 = 0 ;
10014 wxPoint2D temp2 ;
10015 PyObject * obj0 = 0 ;
10016 PyObject * obj1 = 0 ;
10017 char * kwnames[] = {
10018 (char *) "self",(char *) "pt", NULL
10019 };
10020
10021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
10022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10023 if (!SWIG_IsOK(res1)) {
10024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10025 }
10026 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10027 {
10028 arg2 = &temp2;
10029 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10030 }
10031 {
10032 (arg1)->MoveLeftBottomTo((wxPoint2D const &)*arg2);
10033 if (PyErr_Occurred()) SWIG_fail;
10034 }
10035 resultobj = SWIG_Py_Void();
10036 return resultobj;
10037 fail:
10038 return NULL;
10039 }
10040
10041
10042 SWIGINTERN PyObject *_wrap_Rect2D_GetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10043 PyObject *resultobj = 0;
10044 wxRect2D *arg1 = (wxRect2D *) 0 ;
10045 wxPoint2D result;
10046 void *argp1 = 0 ;
10047 int res1 = 0 ;
10048 PyObject *swig_obj[1] ;
10049
10050 if (!args) SWIG_fail;
10051 swig_obj[0] = args;
10052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10053 if (!SWIG_IsOK(res1)) {
10054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10055 }
10056 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10057 {
10058 result = ((wxRect2D const *)arg1)->GetRightTop();
10059 if (PyErr_Occurred()) SWIG_fail;
10060 }
10061 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10062 return resultobj;
10063 fail:
10064 return NULL;
10065 }
10066
10067
10068 SWIGINTERN PyObject *_wrap_Rect2D_SetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10069 PyObject *resultobj = 0;
10070 wxRect2D *arg1 = (wxRect2D *) 0 ;
10071 wxPoint2D *arg2 = 0 ;
10072 void *argp1 = 0 ;
10073 int res1 = 0 ;
10074 wxPoint2D temp2 ;
10075 PyObject * obj0 = 0 ;
10076 PyObject * obj1 = 0 ;
10077 char * kwnames[] = {
10078 (char *) "self",(char *) "pt", NULL
10079 };
10080
10081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightTop",kwnames,&obj0,&obj1)) SWIG_fail;
10082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10083 if (!SWIG_IsOK(res1)) {
10084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
10085 }
10086 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10087 {
10088 arg2 = &temp2;
10089 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10090 }
10091 {
10092 (arg1)->SetRightTop((wxPoint2D const &)*arg2);
10093 if (PyErr_Occurred()) SWIG_fail;
10094 }
10095 resultobj = SWIG_Py_Void();
10096 return resultobj;
10097 fail:
10098 return NULL;
10099 }
10100
10101
10102 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10103 PyObject *resultobj = 0;
10104 wxRect2D *arg1 = (wxRect2D *) 0 ;
10105 wxPoint2D *arg2 = 0 ;
10106 void *argp1 = 0 ;
10107 int res1 = 0 ;
10108 wxPoint2D temp2 ;
10109 PyObject * obj0 = 0 ;
10110 PyObject * obj1 = 0 ;
10111 char * kwnames[] = {
10112 (char *) "self",(char *) "pt", NULL
10113 };
10114
10115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
10116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10117 if (!SWIG_IsOK(res1)) {
10118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10119 }
10120 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10121 {
10122 arg2 = &temp2;
10123 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10124 }
10125 {
10126 (arg1)->MoveRightTopTo((wxPoint2D const &)*arg2);
10127 if (PyErr_Occurred()) SWIG_fail;
10128 }
10129 resultobj = SWIG_Py_Void();
10130 return resultobj;
10131 fail:
10132 return NULL;
10133 }
10134
10135
10136 SWIGINTERN PyObject *_wrap_Rect2D_GetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10137 PyObject *resultobj = 0;
10138 wxRect2D *arg1 = (wxRect2D *) 0 ;
10139 wxPoint2D result;
10140 void *argp1 = 0 ;
10141 int res1 = 0 ;
10142 PyObject *swig_obj[1] ;
10143
10144 if (!args) SWIG_fail;
10145 swig_obj[0] = args;
10146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10147 if (!SWIG_IsOK(res1)) {
10148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10149 }
10150 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10151 {
10152 result = ((wxRect2D const *)arg1)->GetRightBottom();
10153 if (PyErr_Occurred()) SWIG_fail;
10154 }
10155 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10156 return resultobj;
10157 fail:
10158 return NULL;
10159 }
10160
10161
10162 SWIGINTERN PyObject *_wrap_Rect2D_SetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10163 PyObject *resultobj = 0;
10164 wxRect2D *arg1 = (wxRect2D *) 0 ;
10165 wxPoint2D *arg2 = 0 ;
10166 void *argp1 = 0 ;
10167 int res1 = 0 ;
10168 wxPoint2D temp2 ;
10169 PyObject * obj0 = 0 ;
10170 PyObject * obj1 = 0 ;
10171 char * kwnames[] = {
10172 (char *) "self",(char *) "pt", NULL
10173 };
10174
10175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightBottom",kwnames,&obj0,&obj1)) SWIG_fail;
10176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10177 if (!SWIG_IsOK(res1)) {
10178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
10179 }
10180 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10181 {
10182 arg2 = &temp2;
10183 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10184 }
10185 {
10186 (arg1)->SetRightBottom((wxPoint2D const &)*arg2);
10187 if (PyErr_Occurred()) SWIG_fail;
10188 }
10189 resultobj = SWIG_Py_Void();
10190 return resultobj;
10191 fail:
10192 return NULL;
10193 }
10194
10195
10196 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10197 PyObject *resultobj = 0;
10198 wxRect2D *arg1 = (wxRect2D *) 0 ;
10199 wxPoint2D *arg2 = 0 ;
10200 void *argp1 = 0 ;
10201 int res1 = 0 ;
10202 wxPoint2D temp2 ;
10203 PyObject * obj0 = 0 ;
10204 PyObject * obj1 = 0 ;
10205 char * kwnames[] = {
10206 (char *) "self",(char *) "pt", NULL
10207 };
10208
10209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
10210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10211 if (!SWIG_IsOK(res1)) {
10212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10213 }
10214 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10215 {
10216 arg2 = &temp2;
10217 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10218 }
10219 {
10220 (arg1)->MoveRightBottomTo((wxPoint2D const &)*arg2);
10221 if (PyErr_Occurred()) SWIG_fail;
10222 }
10223 resultobj = SWIG_Py_Void();
10224 return resultobj;
10225 fail:
10226 return NULL;
10227 }
10228
10229
10230 SWIGINTERN PyObject *_wrap_Rect2D_GetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10231 PyObject *resultobj = 0;
10232 wxRect2D *arg1 = (wxRect2D *) 0 ;
10233 wxPoint2D result;
10234 void *argp1 = 0 ;
10235 int res1 = 0 ;
10236 PyObject *swig_obj[1] ;
10237
10238 if (!args) SWIG_fail;
10239 swig_obj[0] = args;
10240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10241 if (!SWIG_IsOK(res1)) {
10242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetCentre" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10243 }
10244 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10245 {
10246 result = ((wxRect2D const *)arg1)->GetCentre();
10247 if (PyErr_Occurred()) SWIG_fail;
10248 }
10249 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10250 return resultobj;
10251 fail:
10252 return NULL;
10253 }
10254
10255
10256 SWIGINTERN PyObject *_wrap_Rect2D_SetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10257 PyObject *resultobj = 0;
10258 wxRect2D *arg1 = (wxRect2D *) 0 ;
10259 wxPoint2D *arg2 = 0 ;
10260 void *argp1 = 0 ;
10261 int res1 = 0 ;
10262 wxPoint2D temp2 ;
10263 PyObject * obj0 = 0 ;
10264 PyObject * obj1 = 0 ;
10265 char * kwnames[] = {
10266 (char *) "self",(char *) "pt", NULL
10267 };
10268
10269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetCentre",kwnames,&obj0,&obj1)) SWIG_fail;
10270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10271 if (!SWIG_IsOK(res1)) {
10272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetCentre" "', expected argument " "1"" of type '" "wxRect2D *""'");
10273 }
10274 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10275 {
10276 arg2 = &temp2;
10277 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10278 }
10279 {
10280 (arg1)->SetCentre((wxPoint2D const &)*arg2);
10281 if (PyErr_Occurred()) SWIG_fail;
10282 }
10283 resultobj = SWIG_Py_Void();
10284 return resultobj;
10285 fail:
10286 return NULL;
10287 }
10288
10289
10290 SWIGINTERN PyObject *_wrap_Rect2D_MoveCentreTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10291 PyObject *resultobj = 0;
10292 wxRect2D *arg1 = (wxRect2D *) 0 ;
10293 wxPoint2D *arg2 = 0 ;
10294 void *argp1 = 0 ;
10295 int res1 = 0 ;
10296 wxPoint2D temp2 ;
10297 PyObject * obj0 = 0 ;
10298 PyObject * obj1 = 0 ;
10299 char * kwnames[] = {
10300 (char *) "self",(char *) "pt", NULL
10301 };
10302
10303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveCentreTo",kwnames,&obj0,&obj1)) SWIG_fail;
10304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10305 if (!SWIG_IsOK(res1)) {
10306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveCentreTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10307 }
10308 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10309 {
10310 arg2 = &temp2;
10311 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10312 }
10313 {
10314 (arg1)->MoveCentreTo((wxPoint2D const &)*arg2);
10315 if (PyErr_Occurred()) SWIG_fail;
10316 }
10317 resultobj = SWIG_Py_Void();
10318 return resultobj;
10319 fail:
10320 return NULL;
10321 }
10322
10323
10324 SWIGINTERN PyObject *_wrap_Rect2D_GetOutcode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10325 PyObject *resultobj = 0;
10326 wxRect2D *arg1 = (wxRect2D *) 0 ;
10327 wxPoint2D *arg2 = 0 ;
10328 wxOutCode result;
10329 void *argp1 = 0 ;
10330 int res1 = 0 ;
10331 wxPoint2D temp2 ;
10332 PyObject * obj0 = 0 ;
10333 PyObject * obj1 = 0 ;
10334 char * kwnames[] = {
10335 (char *) "self",(char *) "pt", NULL
10336 };
10337
10338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_GetOutcode",kwnames,&obj0,&obj1)) SWIG_fail;
10339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10340 if (!SWIG_IsOK(res1)) {
10341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetOutcode" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10342 }
10343 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10344 {
10345 arg2 = &temp2;
10346 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10347 }
10348 {
10349 result = (wxOutCode)((wxRect2D const *)arg1)->GetOutcode((wxPoint2D const &)*arg2);
10350 if (PyErr_Occurred()) SWIG_fail;
10351 }
10352 resultobj = SWIG_From_int(static_cast< int >(result));
10353 return resultobj;
10354 fail:
10355 return NULL;
10356 }
10357
10358
10359 SWIGINTERN PyObject *_wrap_Rect2D_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10360 PyObject *resultobj = 0;
10361 wxRect2D *arg1 = (wxRect2D *) 0 ;
10362 wxPoint2D *arg2 = 0 ;
10363 bool result;
10364 void *argp1 = 0 ;
10365 int res1 = 0 ;
10366 wxPoint2D temp2 ;
10367 PyObject * obj0 = 0 ;
10368 PyObject * obj1 = 0 ;
10369 char * kwnames[] = {
10370 (char *) "self",(char *) "pt", NULL
10371 };
10372
10373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
10374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10375 if (!SWIG_IsOK(res1)) {
10376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Contains" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10377 }
10378 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10379 {
10380 arg2 = &temp2;
10381 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10382 }
10383 {
10384 result = (bool)((wxRect2D const *)arg1)->Contains((wxPoint2D const &)*arg2);
10385 if (PyErr_Occurred()) SWIG_fail;
10386 }
10387 {
10388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10389 }
10390 return resultobj;
10391 fail:
10392 return NULL;
10393 }
10394
10395
10396 SWIGINTERN PyObject *_wrap_Rect2D_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10397 PyObject *resultobj = 0;
10398 wxRect2D *arg1 = (wxRect2D *) 0 ;
10399 wxRect2D *arg2 = 0 ;
10400 bool result;
10401 void *argp1 = 0 ;
10402 int res1 = 0 ;
10403 wxRect2D temp2 ;
10404 PyObject * obj0 = 0 ;
10405 PyObject * obj1 = 0 ;
10406 char * kwnames[] = {
10407 (char *) "self",(char *) "rect", NULL
10408 };
10409
10410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
10411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10412 if (!SWIG_IsOK(res1)) {
10413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ContainsRect" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10414 }
10415 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10416 {
10417 arg2 = &temp2;
10418 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10419 }
10420 {
10421 result = (bool)((wxRect2D const *)arg1)->Contains((wxRect2D const &)*arg2);
10422 if (PyErr_Occurred()) SWIG_fail;
10423 }
10424 {
10425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10426 }
10427 return resultobj;
10428 fail:
10429 return NULL;
10430 }
10431
10432
10433 SWIGINTERN PyObject *_wrap_Rect2D_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10434 PyObject *resultobj = 0;
10435 wxRect2D *arg1 = (wxRect2D *) 0 ;
10436 bool result;
10437 void *argp1 = 0 ;
10438 int res1 = 0 ;
10439 PyObject *swig_obj[1] ;
10440
10441 if (!args) SWIG_fail;
10442 swig_obj[0] = args;
10443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10444 if (!SWIG_IsOK(res1)) {
10445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_IsEmpty" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10446 }
10447 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10448 {
10449 result = (bool)((wxRect2D const *)arg1)->IsEmpty();
10450 if (PyErr_Occurred()) SWIG_fail;
10451 }
10452 {
10453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10454 }
10455 return resultobj;
10456 fail:
10457 return NULL;
10458 }
10459
10460
10461 SWIGINTERN PyObject *_wrap_Rect2D_HaveEqualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10462 PyObject *resultobj = 0;
10463 wxRect2D *arg1 = (wxRect2D *) 0 ;
10464 wxRect2D *arg2 = 0 ;
10465 bool result;
10466 void *argp1 = 0 ;
10467 int res1 = 0 ;
10468 wxRect2D temp2 ;
10469 PyObject * obj0 = 0 ;
10470 PyObject * obj1 = 0 ;
10471 char * kwnames[] = {
10472 (char *) "self",(char *) "rect", NULL
10473 };
10474
10475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_HaveEqualSize",kwnames,&obj0,&obj1)) SWIG_fail;
10476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10477 if (!SWIG_IsOK(res1)) {
10478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_HaveEqualSize" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10479 }
10480 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10481 {
10482 arg2 = &temp2;
10483 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10484 }
10485 {
10486 result = (bool)((wxRect2D const *)arg1)->HaveEqualSize((wxRect2D const &)*arg2);
10487 if (PyErr_Occurred()) SWIG_fail;
10488 }
10489 {
10490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10491 }
10492 return resultobj;
10493 fail:
10494 return NULL;
10495 }
10496
10497
10498 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10499 PyObject *resultobj = 0;
10500 wxRect2D *arg1 = (wxRect2D *) 0 ;
10501 wxDouble arg2 ;
10502 wxDouble arg3 ;
10503 void *argp1 = 0 ;
10504 int res1 = 0 ;
10505 void *argp2 ;
10506 int res2 = 0 ;
10507 void *argp3 ;
10508 int res3 = 0 ;
10509
10510 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10512 if (!SWIG_IsOK(res1)) {
10513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10514 }
10515 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10516 {
10517 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10518 if (!SWIG_IsOK(res2)) {
10519 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10520 }
10521 if (!argp2) {
10522 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10523 } else {
10524 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10525 arg2 = *temp;
10526 if (SWIG_IsNewObj(res2)) delete temp;
10527 }
10528 }
10529 {
10530 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10531 if (!SWIG_IsOK(res3)) {
10532 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10533 }
10534 if (!argp3) {
10535 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10536 } else {
10537 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10538 arg3 = *temp;
10539 if (SWIG_IsNewObj(res3)) delete temp;
10540 }
10541 }
10542 {
10543 (arg1)->Inset(arg2,arg3);
10544 if (PyErr_Occurred()) SWIG_fail;
10545 }
10546 resultobj = SWIG_Py_Void();
10547 return resultobj;
10548 fail:
10549 return NULL;
10550 }
10551
10552
10553 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10554 PyObject *resultobj = 0;
10555 wxRect2D *arg1 = (wxRect2D *) 0 ;
10556 wxDouble arg2 ;
10557 wxDouble arg3 ;
10558 wxDouble arg4 ;
10559 wxDouble arg5 ;
10560 void *argp1 = 0 ;
10561 int res1 = 0 ;
10562 void *argp2 ;
10563 int res2 = 0 ;
10564 void *argp3 ;
10565 int res3 = 0 ;
10566 void *argp4 ;
10567 int res4 = 0 ;
10568 void *argp5 ;
10569 int res5 = 0 ;
10570
10571 if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
10572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10573 if (!SWIG_IsOK(res1)) {
10574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10575 }
10576 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10577 {
10578 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10579 if (!SWIG_IsOK(res2)) {
10580 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10581 }
10582 if (!argp2) {
10583 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10584 } else {
10585 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10586 arg2 = *temp;
10587 if (SWIG_IsNewObj(res2)) delete temp;
10588 }
10589 }
10590 {
10591 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10592 if (!SWIG_IsOK(res3)) {
10593 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10594 }
10595 if (!argp3) {
10596 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10597 } else {
10598 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10599 arg3 = *temp;
10600 if (SWIG_IsNewObj(res3)) delete temp;
10601 }
10602 }
10603 {
10604 res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
10605 if (!SWIG_IsOK(res4)) {
10606 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10607 }
10608 if (!argp4) {
10609 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10610 } else {
10611 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
10612 arg4 = *temp;
10613 if (SWIG_IsNewObj(res4)) delete temp;
10614 }
10615 }
10616 {
10617 res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
10618 if (!SWIG_IsOK(res5)) {
10619 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10620 }
10621 if (!argp5) {
10622 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10623 } else {
10624 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
10625 arg5 = *temp;
10626 if (SWIG_IsNewObj(res5)) delete temp;
10627 }
10628 }
10629 {
10630 (arg1)->Inset(arg2,arg3,arg4,arg5);
10631 if (PyErr_Occurred()) SWIG_fail;
10632 }
10633 resultobj = SWIG_Py_Void();
10634 return resultobj;
10635 fail:
10636 return NULL;
10637 }
10638
10639
10640 SWIGINTERN PyObject *_wrap_Rect2D_Inset(PyObject *self, PyObject *args) {
10641 int argc;
10642 PyObject *argv[6];
10643
10644 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Inset",0,5,argv))) SWIG_fail;
10645 --argc;
10646 if (argc == 3) {
10647 return _wrap_Rect2D_Inset__SWIG_0(self, argc, argv);
10648 }
10649 if (argc == 5) {
10650 return _wrap_Rect2D_Inset__SWIG_1(self, argc, argv);
10651 }
10652
10653 fail:
10654 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Inset'");
10655 return NULL;
10656 }
10657
10658
10659 SWIGINTERN PyObject *_wrap_Rect2D_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10660 PyObject *resultobj = 0;
10661 wxRect2D *arg1 = (wxRect2D *) 0 ;
10662 wxPoint2D *arg2 = 0 ;
10663 void *argp1 = 0 ;
10664 int res1 = 0 ;
10665 wxPoint2D temp2 ;
10666 PyObject * obj0 = 0 ;
10667 PyObject * obj1 = 0 ;
10668 char * kwnames[] = {
10669 (char *) "self",(char *) "pt", NULL
10670 };
10671
10672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
10673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10674 if (!SWIG_IsOK(res1)) {
10675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Offset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10676 }
10677 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10678 {
10679 arg2 = &temp2;
10680 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10681 }
10682 {
10683 (arg1)->Offset((wxPoint2D const &)*arg2);
10684 if (PyErr_Occurred()) SWIG_fail;
10685 }
10686 resultobj = SWIG_Py_Void();
10687 return resultobj;
10688 fail:
10689 return NULL;
10690 }
10691
10692
10693 SWIGINTERN PyObject *_wrap_Rect2D_ConstrainTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10694 PyObject *resultobj = 0;
10695 wxRect2D *arg1 = (wxRect2D *) 0 ;
10696 wxRect2D *arg2 = 0 ;
10697 void *argp1 = 0 ;
10698 int res1 = 0 ;
10699 wxRect2D temp2 ;
10700 PyObject * obj0 = 0 ;
10701 PyObject * obj1 = 0 ;
10702 char * kwnames[] = {
10703 (char *) "self",(char *) "rect", NULL
10704 };
10705
10706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ConstrainTo",kwnames,&obj0,&obj1)) SWIG_fail;
10707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10708 if (!SWIG_IsOK(res1)) {
10709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ConstrainTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10710 }
10711 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10712 {
10713 arg2 = &temp2;
10714 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10715 }
10716 {
10717 (arg1)->ConstrainTo((wxRect2D const &)*arg2);
10718 if (PyErr_Occurred()) SWIG_fail;
10719 }
10720 resultobj = SWIG_Py_Void();
10721 return resultobj;
10722 fail:
10723 return NULL;
10724 }
10725
10726
10727 SWIGINTERN PyObject *_wrap_Rect2D_Interpolate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10728 PyObject *resultobj = 0;
10729 wxRect2D *arg1 = (wxRect2D *) 0 ;
10730 int arg2 ;
10731 int arg3 ;
10732 wxPoint2D result;
10733 void *argp1 = 0 ;
10734 int res1 = 0 ;
10735 int val2 ;
10736 int ecode2 = 0 ;
10737 int val3 ;
10738 int ecode3 = 0 ;
10739 PyObject * obj0 = 0 ;
10740 PyObject * obj1 = 0 ;
10741 PyObject * obj2 = 0 ;
10742 char * kwnames[] = {
10743 (char *) "self",(char *) "widthfactor",(char *) "heightfactor", NULL
10744 };
10745
10746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect2D_Interpolate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10748 if (!SWIG_IsOK(res1)) {
10749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Interpolate" "', expected argument " "1"" of type '" "wxRect2D *""'");
10750 }
10751 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10752 ecode2 = SWIG_AsVal_int(obj1, &val2);
10753 if (!SWIG_IsOK(ecode2)) {
10754 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Interpolate" "', expected argument " "2"" of type '" "int""'");
10755 }
10756 arg2 = static_cast< int >(val2);
10757 ecode3 = SWIG_AsVal_int(obj2, &val3);
10758 if (!SWIG_IsOK(ecode3)) {
10759 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Interpolate" "', expected argument " "3"" of type '" "int""'");
10760 }
10761 arg3 = static_cast< int >(val3);
10762 {
10763 result = (arg1)->Interpolate(arg2,arg3);
10764 if (PyErr_Occurred()) SWIG_fail;
10765 }
10766 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10767 return resultobj;
10768 fail:
10769 return NULL;
10770 }
10771
10772
10773 SWIGINTERN PyObject *_wrap_Rect2D_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10774 PyObject *resultobj = 0;
10775 wxRect2D *arg1 = (wxRect2D *) 0 ;
10776 wxRect2D *arg2 = 0 ;
10777 void *argp1 = 0 ;
10778 int res1 = 0 ;
10779 wxRect2D temp2 ;
10780 PyObject * obj0 = 0 ;
10781 PyObject * obj1 = 0 ;
10782 char * kwnames[] = {
10783 (char *) "self",(char *) "otherRect", NULL
10784 };
10785
10786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
10787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10788 if (!SWIG_IsOK(res1)) {
10789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersect" "', expected argument " "1"" of type '" "wxRect2D *""'");
10790 }
10791 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10792 {
10793 arg2 = &temp2;
10794 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10795 }
10796 {
10797 (arg1)->Intersect((wxRect2D const &)*arg2);
10798 if (PyErr_Occurred()) SWIG_fail;
10799 }
10800 resultobj = SWIG_Py_Void();
10801 return resultobj;
10802 fail:
10803 return NULL;
10804 }
10805
10806
10807 SWIGINTERN PyObject *_wrap_Rect2D_CreateIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10808 PyObject *resultobj = 0;
10809 wxRect2D *arg1 = (wxRect2D *) 0 ;
10810 wxRect2D *arg2 = 0 ;
10811 wxRect2D result;
10812 void *argp1 = 0 ;
10813 int res1 = 0 ;
10814 wxRect2D temp2 ;
10815 PyObject * obj0 = 0 ;
10816 PyObject * obj1 = 0 ;
10817 char * kwnames[] = {
10818 (char *) "self",(char *) "otherRect", NULL
10819 };
10820
10821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateIntersection",kwnames,&obj0,&obj1)) SWIG_fail;
10822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10823 if (!SWIG_IsOK(res1)) {
10824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateIntersection" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10825 }
10826 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10827 {
10828 arg2 = &temp2;
10829 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10830 }
10831 {
10832 result = ((wxRect2D const *)arg1)->CreateIntersection((wxRect2D const &)*arg2);
10833 if (PyErr_Occurred()) SWIG_fail;
10834 }
10835 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10836 return resultobj;
10837 fail:
10838 return NULL;
10839 }
10840
10841
10842 SWIGINTERN PyObject *_wrap_Rect2D_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10843 PyObject *resultobj = 0;
10844 wxRect2D *arg1 = (wxRect2D *) 0 ;
10845 wxRect2D *arg2 = 0 ;
10846 bool result;
10847 void *argp1 = 0 ;
10848 int res1 = 0 ;
10849 wxRect2D temp2 ;
10850 PyObject * obj0 = 0 ;
10851 PyObject * obj1 = 0 ;
10852 char * kwnames[] = {
10853 (char *) "self",(char *) "rect", NULL
10854 };
10855
10856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
10857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10858 if (!SWIG_IsOK(res1)) {
10859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersects" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10860 }
10861 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10862 {
10863 arg2 = &temp2;
10864 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10865 }
10866 {
10867 result = (bool)((wxRect2D const *)arg1)->Intersects((wxRect2D const &)*arg2);
10868 if (PyErr_Occurred()) SWIG_fail;
10869 }
10870 {
10871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10872 }
10873 return resultobj;
10874 fail:
10875 return NULL;
10876 }
10877
10878
10879 SWIGINTERN PyObject *_wrap_Rect2D_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10880 PyObject *resultobj = 0;
10881 wxRect2D *arg1 = (wxRect2D *) 0 ;
10882 wxRect2D *arg2 = 0 ;
10883 void *argp1 = 0 ;
10884 int res1 = 0 ;
10885 wxRect2D temp2 ;
10886 PyObject * obj0 = 0 ;
10887 PyObject * obj1 = 0 ;
10888 char * kwnames[] = {
10889 (char *) "self",(char *) "otherRect", NULL
10890 };
10891
10892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Union",kwnames,&obj0,&obj1)) SWIG_fail;
10893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10894 if (!SWIG_IsOK(res1)) {
10895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Union" "', expected argument " "1"" of type '" "wxRect2D *""'");
10896 }
10897 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10898 {
10899 arg2 = &temp2;
10900 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10901 }
10902 {
10903 (arg1)->Union((wxRect2D const &)*arg2);
10904 if (PyErr_Occurred()) SWIG_fail;
10905 }
10906 resultobj = SWIG_Py_Void();
10907 return resultobj;
10908 fail:
10909 return NULL;
10910 }
10911
10912
10913 SWIGINTERN PyObject *_wrap_Rect2D_CreateUnion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10914 PyObject *resultobj = 0;
10915 wxRect2D *arg1 = (wxRect2D *) 0 ;
10916 wxRect2D *arg2 = 0 ;
10917 wxRect2D result;
10918 void *argp1 = 0 ;
10919 int res1 = 0 ;
10920 wxRect2D temp2 ;
10921 PyObject * obj0 = 0 ;
10922 PyObject * obj1 = 0 ;
10923 char * kwnames[] = {
10924 (char *) "self",(char *) "otherRect", NULL
10925 };
10926
10927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateUnion",kwnames,&obj0,&obj1)) SWIG_fail;
10928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10929 if (!SWIG_IsOK(res1)) {
10930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateUnion" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10931 }
10932 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10933 {
10934 arg2 = &temp2;
10935 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10936 }
10937 {
10938 result = ((wxRect2D const *)arg1)->CreateUnion((wxRect2D const &)*arg2);
10939 if (PyErr_Occurred()) SWIG_fail;
10940 }
10941 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10942 return resultobj;
10943 fail:
10944 return NULL;
10945 }
10946
10947
10948 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10949 PyObject *resultobj = 0;
10950 wxRect2D *arg1 = (wxRect2D *) 0 ;
10951 wxDouble arg2 ;
10952 void *argp1 = 0 ;
10953 int res1 = 0 ;
10954 void *argp2 ;
10955 int res2 = 0 ;
10956
10957 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
10958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10959 if (!SWIG_IsOK(res1)) {
10960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10961 }
10962 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10963 {
10964 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10965 if (!SWIG_IsOK(res2)) {
10966 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10967 }
10968 if (!argp2) {
10969 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10970 } else {
10971 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10972 arg2 = *temp;
10973 if (SWIG_IsNewObj(res2)) delete temp;
10974 }
10975 }
10976 {
10977 (arg1)->Scale(arg2);
10978 if (PyErr_Occurred()) SWIG_fail;
10979 }
10980 resultobj = SWIG_Py_Void();
10981 return resultobj;
10982 fail:
10983 return NULL;
10984 }
10985
10986
10987 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10988 PyObject *resultobj = 0;
10989 wxRect2D *arg1 = (wxRect2D *) 0 ;
10990 int arg2 ;
10991 int arg3 ;
10992 void *argp1 = 0 ;
10993 int res1 = 0 ;
10994 int val2 ;
10995 int ecode2 = 0 ;
10996 int val3 ;
10997 int ecode3 = 0 ;
10998
10999 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
11000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11001 if (!SWIG_IsOK(res1)) {
11002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
11003 }
11004 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11005 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11006 if (!SWIG_IsOK(ecode2)) {
11007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "int""'");
11008 }
11009 arg2 = static_cast< int >(val2);
11010 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11011 if (!SWIG_IsOK(ecode3)) {
11012 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Scale" "', expected argument " "3"" of type '" "int""'");
11013 }
11014 arg3 = static_cast< int >(val3);
11015 {
11016 (arg1)->Scale(arg2,arg3);
11017 if (PyErr_Occurred()) SWIG_fail;
11018 }
11019 resultobj = SWIG_Py_Void();
11020 return resultobj;
11021 fail:
11022 return NULL;
11023 }
11024
11025
11026 SWIGINTERN PyObject *_wrap_Rect2D_Scale(PyObject *self, PyObject *args) {
11027 int argc;
11028 PyObject *argv[4];
11029
11030 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Scale",0,3,argv))) SWIG_fail;
11031 --argc;
11032 if (argc == 2) {
11033 return _wrap_Rect2D_Scale__SWIG_0(self, argc, argv);
11034 }
11035 if (argc == 3) {
11036 return _wrap_Rect2D_Scale__SWIG_1(self, argc, argv);
11037 }
11038
11039 fail:
11040 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Scale'");
11041 return NULL;
11042 }
11043
11044
11045 SWIGINTERN PyObject *_wrap_Rect2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11046 PyObject *resultobj = 0;
11047 wxRect2D *arg1 = (wxRect2D *) 0 ;
11048 PyObject *arg2 = (PyObject *) 0 ;
11049 bool result;
11050 void *argp1 = 0 ;
11051 int res1 = 0 ;
11052 PyObject * obj0 = 0 ;
11053 PyObject * obj1 = 0 ;
11054 char * kwnames[] = {
11055 (char *) "self",(char *) "other", NULL
11056 };
11057
11058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
11059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11060 if (!SWIG_IsOK(res1)) {
11061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___eq__" "', expected argument " "1"" of type '" "wxRect2D *""'");
11062 }
11063 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11064 arg2 = obj1;
11065 {
11066 result = (bool)wxRect2D___eq__(arg1,arg2);
11067 if (PyErr_Occurred()) SWIG_fail;
11068 }
11069 {
11070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11071 }
11072 return resultobj;
11073 fail:
11074 return NULL;
11075 }
11076
11077
11078 SWIGINTERN PyObject *_wrap_Rect2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11079 PyObject *resultobj = 0;
11080 wxRect2D *arg1 = (wxRect2D *) 0 ;
11081 PyObject *arg2 = (PyObject *) 0 ;
11082 bool result;
11083 void *argp1 = 0 ;
11084 int res1 = 0 ;
11085 PyObject * obj0 = 0 ;
11086 PyObject * obj1 = 0 ;
11087 char * kwnames[] = {
11088 (char *) "self",(char *) "other", NULL
11089 };
11090
11091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
11092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11093 if (!SWIG_IsOK(res1)) {
11094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___ne__" "', expected argument " "1"" of type '" "wxRect2D *""'");
11095 }
11096 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11097 arg2 = obj1;
11098 {
11099 result = (bool)wxRect2D___ne__(arg1,arg2);
11100 if (PyErr_Occurred()) SWIG_fail;
11101 }
11102 {
11103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11104 }
11105 return resultobj;
11106 fail:
11107 return NULL;
11108 }
11109
11110
11111 SWIGINTERN PyObject *_wrap_Rect2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11112 PyObject *resultobj = 0;
11113 wxRect2D *arg1 = (wxRect2D *) 0 ;
11114 wxDouble arg2 ;
11115 void *argp1 = 0 ;
11116 int res1 = 0 ;
11117 void *argp2 ;
11118 int res2 = 0 ;
11119 PyObject *swig_obj[2] ;
11120
11121 if (!SWIG_Python_UnpackTuple(args,"Rect2D_x_set",2,2,swig_obj)) SWIG_fail;
11122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11123 if (!SWIG_IsOK(res1)) {
11124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11125 }
11126 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11127 {
11128 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11129 if (!SWIG_IsOK(res2)) {
11130 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11131 }
11132 if (!argp2) {
11133 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11134 } else {
11135 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11136 arg2 = *temp;
11137 if (SWIG_IsNewObj(res2)) delete temp;
11138 }
11139 }
11140 if (arg1) (arg1)->m_x = arg2;
11141
11142 resultobj = SWIG_Py_Void();
11143 return resultobj;
11144 fail:
11145 return NULL;
11146 }
11147
11148
11149 SWIGINTERN PyObject *_wrap_Rect2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11150 PyObject *resultobj = 0;
11151 wxRect2D *arg1 = (wxRect2D *) 0 ;
11152 wxDouble result;
11153 void *argp1 = 0 ;
11154 int res1 = 0 ;
11155 PyObject *swig_obj[1] ;
11156
11157 if (!args) SWIG_fail;
11158 swig_obj[0] = args;
11159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11160 if (!SWIG_IsOK(res1)) {
11161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11162 }
11163 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11164 result = ((arg1)->m_x);
11165 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11166 return resultobj;
11167 fail:
11168 return NULL;
11169 }
11170
11171
11172 SWIGINTERN PyObject *_wrap_Rect2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11173 PyObject *resultobj = 0;
11174 wxRect2D *arg1 = (wxRect2D *) 0 ;
11175 wxDouble arg2 ;
11176 void *argp1 = 0 ;
11177 int res1 = 0 ;
11178 void *argp2 ;
11179 int res2 = 0 ;
11180 PyObject *swig_obj[2] ;
11181
11182 if (!SWIG_Python_UnpackTuple(args,"Rect2D_y_set",2,2,swig_obj)) SWIG_fail;
11183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11184 if (!SWIG_IsOK(res1)) {
11185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11186 }
11187 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11188 {
11189 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11190 if (!SWIG_IsOK(res2)) {
11191 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11192 }
11193 if (!argp2) {
11194 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11195 } else {
11196 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11197 arg2 = *temp;
11198 if (SWIG_IsNewObj(res2)) delete temp;
11199 }
11200 }
11201 if (arg1) (arg1)->m_y = arg2;
11202
11203 resultobj = SWIG_Py_Void();
11204 return resultobj;
11205 fail:
11206 return NULL;
11207 }
11208
11209
11210 SWIGINTERN PyObject *_wrap_Rect2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11211 PyObject *resultobj = 0;
11212 wxRect2D *arg1 = (wxRect2D *) 0 ;
11213 wxDouble result;
11214 void *argp1 = 0 ;
11215 int res1 = 0 ;
11216 PyObject *swig_obj[1] ;
11217
11218 if (!args) SWIG_fail;
11219 swig_obj[0] = args;
11220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11221 if (!SWIG_IsOK(res1)) {
11222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11223 }
11224 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11225 result = ((arg1)->m_y);
11226 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11227 return resultobj;
11228 fail:
11229 return NULL;
11230 }
11231
11232
11233 SWIGINTERN PyObject *_wrap_Rect2D_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11234 PyObject *resultobj = 0;
11235 wxRect2D *arg1 = (wxRect2D *) 0 ;
11236 wxDouble arg2 ;
11237 void *argp1 = 0 ;
11238 int res1 = 0 ;
11239 void *argp2 ;
11240 int res2 = 0 ;
11241 PyObject *swig_obj[2] ;
11242
11243 if (!SWIG_Python_UnpackTuple(args,"Rect2D_width_set",2,2,swig_obj)) SWIG_fail;
11244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11245 if (!SWIG_IsOK(res1)) {
11246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11247 }
11248 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11249 {
11250 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11251 if (!SWIG_IsOK(res2)) {
11252 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11253 }
11254 if (!argp2) {
11255 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11256 } else {
11257 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11258 arg2 = *temp;
11259 if (SWIG_IsNewObj(res2)) delete temp;
11260 }
11261 }
11262 if (arg1) (arg1)->m_width = arg2;
11263
11264 resultobj = SWIG_Py_Void();
11265 return resultobj;
11266 fail:
11267 return NULL;
11268 }
11269
11270
11271 SWIGINTERN PyObject *_wrap_Rect2D_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11272 PyObject *resultobj = 0;
11273 wxRect2D *arg1 = (wxRect2D *) 0 ;
11274 wxDouble result;
11275 void *argp1 = 0 ;
11276 int res1 = 0 ;
11277 PyObject *swig_obj[1] ;
11278
11279 if (!args) SWIG_fail;
11280 swig_obj[0] = args;
11281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11282 if (!SWIG_IsOK(res1)) {
11283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11284 }
11285 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11286 result = ((arg1)->m_width);
11287 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11288 return resultobj;
11289 fail:
11290 return NULL;
11291 }
11292
11293
11294 SWIGINTERN PyObject *_wrap_Rect2D_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11295 PyObject *resultobj = 0;
11296 wxRect2D *arg1 = (wxRect2D *) 0 ;
11297 wxDouble arg2 ;
11298 void *argp1 = 0 ;
11299 int res1 = 0 ;
11300 void *argp2 ;
11301 int res2 = 0 ;
11302 PyObject *swig_obj[2] ;
11303
11304 if (!SWIG_Python_UnpackTuple(args,"Rect2D_height_set",2,2,swig_obj)) SWIG_fail;
11305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11306 if (!SWIG_IsOK(res1)) {
11307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11308 }
11309 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11310 {
11311 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11312 if (!SWIG_IsOK(res2)) {
11313 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11314 }
11315 if (!argp2) {
11316 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11317 } else {
11318 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11319 arg2 = *temp;
11320 if (SWIG_IsNewObj(res2)) delete temp;
11321 }
11322 }
11323 if (arg1) (arg1)->m_height = arg2;
11324
11325 resultobj = SWIG_Py_Void();
11326 return resultobj;
11327 fail:
11328 return NULL;
11329 }
11330
11331
11332 SWIGINTERN PyObject *_wrap_Rect2D_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11333 PyObject *resultobj = 0;
11334 wxRect2D *arg1 = (wxRect2D *) 0 ;
11335 wxDouble result;
11336 void *argp1 = 0 ;
11337 int res1 = 0 ;
11338 PyObject *swig_obj[1] ;
11339
11340 if (!args) SWIG_fail;
11341 swig_obj[0] = args;
11342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11343 if (!SWIG_IsOK(res1)) {
11344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11345 }
11346 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11347 result = ((arg1)->m_height);
11348 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11349 return resultobj;
11350 fail:
11351 return NULL;
11352 }
11353
11354
11355 SWIGINTERN PyObject *_wrap_Rect2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11356 PyObject *resultobj = 0;
11357 wxRect2D *arg1 = (wxRect2D *) 0 ;
11358 wxDouble arg2 = (wxDouble) 0 ;
11359 wxDouble arg3 = (wxDouble) 0 ;
11360 wxDouble arg4 = (wxDouble) 0 ;
11361 wxDouble arg5 = (wxDouble) 0 ;
11362 void *argp1 = 0 ;
11363 int res1 = 0 ;
11364 void *argp2 ;
11365 int res2 = 0 ;
11366 void *argp3 ;
11367 int res3 = 0 ;
11368 void *argp4 ;
11369 int res4 = 0 ;
11370 void *argp5 ;
11371 int res5 = 0 ;
11372 PyObject * obj0 = 0 ;
11373 PyObject * obj1 = 0 ;
11374 PyObject * obj2 = 0 ;
11375 PyObject * obj3 = 0 ;
11376 PyObject * obj4 = 0 ;
11377 char * kwnames[] = {
11378 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
11379 };
11380
11381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect2D_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11383 if (!SWIG_IsOK(res1)) {
11384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11385 }
11386 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11387 if (obj1) {
11388 {
11389 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11390 if (!SWIG_IsOK(res2)) {
11391 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11392 }
11393 if (!argp2) {
11394 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11395 } else {
11396 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11397 arg2 = *temp;
11398 if (SWIG_IsNewObj(res2)) delete temp;
11399 }
11400 }
11401 }
11402 if (obj2) {
11403 {
11404 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
11405 if (!SWIG_IsOK(res3)) {
11406 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11407 }
11408 if (!argp3) {
11409 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11410 } else {
11411 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
11412 arg3 = *temp;
11413 if (SWIG_IsNewObj(res3)) delete temp;
11414 }
11415 }
11416 }
11417 if (obj3) {
11418 {
11419 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
11420 if (!SWIG_IsOK(res4)) {
11421 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11422 }
11423 if (!argp4) {
11424 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11425 } else {
11426 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
11427 arg4 = *temp;
11428 if (SWIG_IsNewObj(res4)) delete temp;
11429 }
11430 }
11431 }
11432 if (obj4) {
11433 {
11434 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
11435 if (!SWIG_IsOK(res5)) {
11436 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11437 }
11438 if (!argp5) {
11439 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11440 } else {
11441 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
11442 arg5 = *temp;
11443 if (SWIG_IsNewObj(res5)) delete temp;
11444 }
11445 }
11446 }
11447 {
11448 wxRect2D_Set(arg1,arg2,arg3,arg4,arg5);
11449 if (PyErr_Occurred()) SWIG_fail;
11450 }
11451 resultobj = SWIG_Py_Void();
11452 return resultobj;
11453 fail:
11454 return NULL;
11455 }
11456
11457
11458 SWIGINTERN PyObject *_wrap_Rect2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11459 PyObject *resultobj = 0;
11460 wxRect2D *arg1 = (wxRect2D *) 0 ;
11461 PyObject *result = 0 ;
11462 void *argp1 = 0 ;
11463 int res1 = 0 ;
11464 PyObject *swig_obj[1] ;
11465
11466 if (!args) SWIG_fail;
11467 swig_obj[0] = args;
11468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11469 if (!SWIG_IsOK(res1)) {
11470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11471 }
11472 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11473 {
11474 result = (PyObject *)wxRect2D_Get(arg1);
11475 if (PyErr_Occurred()) SWIG_fail;
11476 }
11477 resultobj = result;
11478 return resultobj;
11479 fail:
11480 return NULL;
11481 }
11482
11483
11484 SWIGINTERN PyObject *Rect2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11485 PyObject *obj;
11486 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11487 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect2D, SWIG_NewClientData(obj));
11488 return SWIG_Py_Void();
11489 }
11490
11491 SWIGINTERN PyObject *Rect2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11492 return SWIG_Python_InitShadowInstance(args);
11493 }
11494
11495 SWIGINTERN PyObject *_wrap_new_Position(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11496 PyObject *resultobj = 0;
11497 int arg1 = (int) 0 ;
11498 int arg2 = (int) 0 ;
11499 wxPosition *result = 0 ;
11500 int val1 ;
11501 int ecode1 = 0 ;
11502 int val2 ;
11503 int ecode2 = 0 ;
11504 PyObject * obj0 = 0 ;
11505 PyObject * obj1 = 0 ;
11506 char * kwnames[] = {
11507 (char *) "row",(char *) "col", NULL
11508 };
11509
11510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Position",kwnames,&obj0,&obj1)) SWIG_fail;
11511 if (obj0) {
11512 ecode1 = SWIG_AsVal_int(obj0, &val1);
11513 if (!SWIG_IsOK(ecode1)) {
11514 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Position" "', expected argument " "1"" of type '" "int""'");
11515 }
11516 arg1 = static_cast< int >(val1);
11517 }
11518 if (obj1) {
11519 ecode2 = SWIG_AsVal_int(obj1, &val2);
11520 if (!SWIG_IsOK(ecode2)) {
11521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Position" "', expected argument " "2"" of type '" "int""'");
11522 }
11523 arg2 = static_cast< int >(val2);
11524 }
11525 {
11526 result = (wxPosition *)new wxPosition(arg1,arg2);
11527 if (PyErr_Occurred()) SWIG_fail;
11528 }
11529 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPosition, SWIG_POINTER_NEW | 0 );
11530 return resultobj;
11531 fail:
11532 return NULL;
11533 }
11534
11535
11536 SWIGINTERN PyObject *_wrap_delete_Position(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11537 PyObject *resultobj = 0;
11538 wxPosition *arg1 = (wxPosition *) 0 ;
11539 void *argp1 = 0 ;
11540 int res1 = 0 ;
11541 PyObject *swig_obj[1] ;
11542
11543 if (!args) SWIG_fail;
11544 swig_obj[0] = args;
11545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPosition, SWIG_POINTER_DISOWN | 0 );
11546 if (!SWIG_IsOK(res1)) {
11547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Position" "', expected argument " "1"" of type '" "wxPosition *""'");
11548 }
11549 arg1 = reinterpret_cast< wxPosition * >(argp1);
11550 {
11551 delete arg1;
11552
11553 if (PyErr_Occurred()) SWIG_fail;
11554 }
11555 resultobj = SWIG_Py_Void();
11556 return resultobj;
11557 fail:
11558 return NULL;
11559 }
11560
11561
11562 SWIGINTERN PyObject *_wrap_Position_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11563 PyObject *resultobj = 0;
11564 wxPosition *arg1 = (wxPosition *) 0 ;
11565 int result;
11566 void *argp1 = 0 ;
11567 int res1 = 0 ;
11568 PyObject *swig_obj[1] ;
11569
11570 if (!args) SWIG_fail;
11571 swig_obj[0] = args;
11572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11573 if (!SWIG_IsOK(res1)) {
11574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_GetRow" "', expected argument " "1"" of type '" "wxPosition const *""'");
11575 }
11576 arg1 = reinterpret_cast< wxPosition * >(argp1);
11577 {
11578 result = (int)((wxPosition const *)arg1)->GetRow();
11579 if (PyErr_Occurred()) SWIG_fail;
11580 }
11581 resultobj = SWIG_From_int(static_cast< int >(result));
11582 return resultobj;
11583 fail:
11584 return NULL;
11585 }
11586
11587
11588 SWIGINTERN PyObject *_wrap_Position_GetColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11589 PyObject *resultobj = 0;
11590 wxPosition *arg1 = (wxPosition *) 0 ;
11591 int result;
11592 void *argp1 = 0 ;
11593 int res1 = 0 ;
11594 PyObject *swig_obj[1] ;
11595
11596 if (!args) SWIG_fail;
11597 swig_obj[0] = args;
11598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11599 if (!SWIG_IsOK(res1)) {
11600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_GetColumn" "', expected argument " "1"" of type '" "wxPosition const *""'");
11601 }
11602 arg1 = reinterpret_cast< wxPosition * >(argp1);
11603 {
11604 result = (int)((wxPosition const *)arg1)->GetColumn();
11605 if (PyErr_Occurred()) SWIG_fail;
11606 }
11607 resultobj = SWIG_From_int(static_cast< int >(result));
11608 return resultobj;
11609 fail:
11610 return NULL;
11611 }
11612
11613
11614 SWIGINTERN PyObject *_wrap_Position_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11615 PyObject *resultobj = 0;
11616 wxPosition *arg1 = (wxPosition *) 0 ;
11617 int result;
11618 void *argp1 = 0 ;
11619 int res1 = 0 ;
11620 PyObject *swig_obj[1] ;
11621
11622 if (!args) SWIG_fail;
11623 swig_obj[0] = args;
11624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11625 if (!SWIG_IsOK(res1)) {
11626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_GetCol" "', expected argument " "1"" of type '" "wxPosition const *""'");
11627 }
11628 arg1 = reinterpret_cast< wxPosition * >(argp1);
11629 {
11630 result = (int)((wxPosition const *)arg1)->GetCol();
11631 if (PyErr_Occurred()) SWIG_fail;
11632 }
11633 resultobj = SWIG_From_int(static_cast< int >(result));
11634 return resultobj;
11635 fail:
11636 return NULL;
11637 }
11638
11639
11640 SWIGINTERN PyObject *_wrap_Position_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11641 PyObject *resultobj = 0;
11642 wxPosition *arg1 = (wxPosition *) 0 ;
11643 int arg2 ;
11644 void *argp1 = 0 ;
11645 int res1 = 0 ;
11646 int val2 ;
11647 int ecode2 = 0 ;
11648 PyObject * obj0 = 0 ;
11649 PyObject * obj1 = 0 ;
11650 char * kwnames[] = {
11651 (char *) "self",(char *) "row", NULL
11652 };
11653
11654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Position_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
11655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11656 if (!SWIG_IsOK(res1)) {
11657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_SetRow" "', expected argument " "1"" of type '" "wxPosition *""'");
11658 }
11659 arg1 = reinterpret_cast< wxPosition * >(argp1);
11660 ecode2 = SWIG_AsVal_int(obj1, &val2);
11661 if (!SWIG_IsOK(ecode2)) {
11662 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Position_SetRow" "', expected argument " "2"" of type '" "int""'");
11663 }
11664 arg2 = static_cast< int >(val2);
11665 {
11666 (arg1)->SetRow(arg2);
11667 if (PyErr_Occurred()) SWIG_fail;
11668 }
11669 resultobj = SWIG_Py_Void();
11670 return resultobj;
11671 fail:
11672 return NULL;
11673 }
11674
11675
11676 SWIGINTERN PyObject *_wrap_Position_SetColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11677 PyObject *resultobj = 0;
11678 wxPosition *arg1 = (wxPosition *) 0 ;
11679 int arg2 ;
11680 void *argp1 = 0 ;
11681 int res1 = 0 ;
11682 int val2 ;
11683 int ecode2 = 0 ;
11684 PyObject * obj0 = 0 ;
11685 PyObject * obj1 = 0 ;
11686 char * kwnames[] = {
11687 (char *) "self",(char *) "column", NULL
11688 };
11689
11690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Position_SetColumn",kwnames,&obj0,&obj1)) SWIG_fail;
11691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11692 if (!SWIG_IsOK(res1)) {
11693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_SetColumn" "', expected argument " "1"" of type '" "wxPosition *""'");
11694 }
11695 arg1 = reinterpret_cast< wxPosition * >(argp1);
11696 ecode2 = SWIG_AsVal_int(obj1, &val2);
11697 if (!SWIG_IsOK(ecode2)) {
11698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Position_SetColumn" "', expected argument " "2"" of type '" "int""'");
11699 }
11700 arg2 = static_cast< int >(val2);
11701 {
11702 (arg1)->SetColumn(arg2);
11703 if (PyErr_Occurred()) SWIG_fail;
11704 }
11705 resultobj = SWIG_Py_Void();
11706 return resultobj;
11707 fail:
11708 return NULL;
11709 }
11710
11711
11712 SWIGINTERN PyObject *_wrap_Position_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11713 PyObject *resultobj = 0;
11714 wxPosition *arg1 = (wxPosition *) 0 ;
11715 int arg2 ;
11716 void *argp1 = 0 ;
11717 int res1 = 0 ;
11718 int val2 ;
11719 int ecode2 = 0 ;
11720 PyObject * obj0 = 0 ;
11721 PyObject * obj1 = 0 ;
11722 char * kwnames[] = {
11723 (char *) "self",(char *) "column", NULL
11724 };
11725
11726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Position_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
11727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11728 if (!SWIG_IsOK(res1)) {
11729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_SetCol" "', expected argument " "1"" of type '" "wxPosition *""'");
11730 }
11731 arg1 = reinterpret_cast< wxPosition * >(argp1);
11732 ecode2 = SWIG_AsVal_int(obj1, &val2);
11733 if (!SWIG_IsOK(ecode2)) {
11734 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Position_SetCol" "', expected argument " "2"" of type '" "int""'");
11735 }
11736 arg2 = static_cast< int >(val2);
11737 {
11738 (arg1)->SetCol(arg2);
11739 if (PyErr_Occurred()) SWIG_fail;
11740 }
11741 resultobj = SWIG_Py_Void();
11742 return resultobj;
11743 fail:
11744 return NULL;
11745 }
11746
11747
11748 SWIGINTERN PyObject *_wrap_Position___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11749 PyObject *resultobj = 0;
11750 wxPosition *arg1 = (wxPosition *) 0 ;
11751 PyObject *arg2 = (PyObject *) 0 ;
11752 bool result;
11753 void *argp1 = 0 ;
11754 int res1 = 0 ;
11755 PyObject * obj0 = 0 ;
11756 PyObject * obj1 = 0 ;
11757 char * kwnames[] = {
11758 (char *) "self",(char *) "other", NULL
11759 };
11760
11761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Position___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
11762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11763 if (!SWIG_IsOK(res1)) {
11764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position___eq__" "', expected argument " "1"" of type '" "wxPosition *""'");
11765 }
11766 arg1 = reinterpret_cast< wxPosition * >(argp1);
11767 arg2 = obj1;
11768 {
11769 result = (bool)wxPosition___eq__(arg1,arg2);
11770 if (PyErr_Occurred()) SWIG_fail;
11771 }
11772 {
11773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11774 }
11775 return resultobj;
11776 fail:
11777 return NULL;
11778 }
11779
11780
11781 SWIGINTERN PyObject *_wrap_Position___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11782 PyObject *resultobj = 0;
11783 wxPosition *arg1 = (wxPosition *) 0 ;
11784 PyObject *arg2 = (PyObject *) 0 ;
11785 bool result;
11786 void *argp1 = 0 ;
11787 int res1 = 0 ;
11788 PyObject * obj0 = 0 ;
11789 PyObject * obj1 = 0 ;
11790 char * kwnames[] = {
11791 (char *) "self",(char *) "other", NULL
11792 };
11793
11794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Position___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
11795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11796 if (!SWIG_IsOK(res1)) {
11797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position___ne__" "', expected argument " "1"" of type '" "wxPosition *""'");
11798 }
11799 arg1 = reinterpret_cast< wxPosition * >(argp1);
11800 arg2 = obj1;
11801 {
11802 result = (bool)wxPosition___ne__(arg1,arg2);
11803 if (PyErr_Occurred()) SWIG_fail;
11804 }
11805 {
11806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11807 }
11808 return resultobj;
11809 fail:
11810 return NULL;
11811 }
11812
11813
11814 SWIGINTERN PyObject *_wrap_Position___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11815 PyObject *resultobj = 0;
11816 wxPosition *arg1 = (wxPosition *) 0 ;
11817 wxPosition *arg2 = 0 ;
11818 wxPosition result;
11819 void *argp1 = 0 ;
11820 int res1 = 0 ;
11821 void *argp2 = 0 ;
11822 int res2 = 0 ;
11823
11824 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
11825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11826 if (!SWIG_IsOK(res1)) {
11827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position___add__" "', expected argument " "1"" of type '" "wxPosition const *""'");
11828 }
11829 arg1 = reinterpret_cast< wxPosition * >(argp1);
11830 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxPosition, 0 | 0);
11831 if (!SWIG_IsOK(res2)) {
11832 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Position___add__" "', expected argument " "2"" of type '" "wxPosition const &""'");
11833 }
11834 if (!argp2) {
11835 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Position___add__" "', expected argument " "2"" of type '" "wxPosition const &""'");
11836 }
11837 arg2 = reinterpret_cast< wxPosition * >(argp2);
11838 {
11839 result = ((wxPosition const *)arg1)->operator +((wxPosition const &)*arg2);
11840 if (PyErr_Occurred()) SWIG_fail;
11841 }
11842 resultobj = SWIG_NewPointerObj((new wxPosition(static_cast< const wxPosition& >(result))), SWIGTYPE_p_wxPosition, SWIG_POINTER_OWN | 0 );
11843 return resultobj;
11844 fail:
11845 return NULL;
11846 }
11847
11848
11849 SWIGINTERN PyObject *_wrap_Position___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11850 PyObject *resultobj = 0;
11851 wxPosition *arg1 = (wxPosition *) 0 ;
11852 wxPosition *arg2 = 0 ;
11853 wxPosition result;
11854 void *argp1 = 0 ;
11855 int res1 = 0 ;
11856 void *argp2 = 0 ;
11857 int res2 = 0 ;
11858
11859 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
11860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11861 if (!SWIG_IsOK(res1)) {
11862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position___sub__" "', expected argument " "1"" of type '" "wxPosition const *""'");
11863 }
11864 arg1 = reinterpret_cast< wxPosition * >(argp1);
11865 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxPosition, 0 | 0);
11866 if (!SWIG_IsOK(res2)) {
11867 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Position___sub__" "', expected argument " "2"" of type '" "wxPosition const &""'");
11868 }
11869 if (!argp2) {
11870 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Position___sub__" "', expected argument " "2"" of type '" "wxPosition const &""'");
11871 }
11872 arg2 = reinterpret_cast< wxPosition * >(argp2);
11873 {
11874 result = ((wxPosition const *)arg1)->operator -((wxPosition const &)*arg2);
11875 if (PyErr_Occurred()) SWIG_fail;
11876 }
11877 resultobj = SWIG_NewPointerObj((new wxPosition(static_cast< const wxPosition& >(result))), SWIGTYPE_p_wxPosition, SWIG_POINTER_OWN | 0 );
11878 return resultobj;
11879 fail:
11880 return NULL;
11881 }
11882
11883
11884 SWIGINTERN PyObject *_wrap_Position___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11885 PyObject *resultobj = 0;
11886 wxPosition *arg1 = (wxPosition *) 0 ;
11887 wxSize *arg2 = 0 ;
11888 wxPosition result;
11889 void *argp1 = 0 ;
11890 int res1 = 0 ;
11891 wxSize temp2 ;
11892
11893 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
11894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11895 if (!SWIG_IsOK(res1)) {
11896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position___add__" "', expected argument " "1"" of type '" "wxPosition const *""'");
11897 }
11898 arg1 = reinterpret_cast< wxPosition * >(argp1);
11899 {
11900 arg2 = &temp2;
11901 if ( ! wxSize_helper(swig_obj[1], &arg2)) SWIG_fail;
11902 }
11903 {
11904 result = ((wxPosition const *)arg1)->operator +((wxSize const &)*arg2);
11905 if (PyErr_Occurred()) SWIG_fail;
11906 }
11907 resultobj = SWIG_NewPointerObj((new wxPosition(static_cast< const wxPosition& >(result))), SWIGTYPE_p_wxPosition, SWIG_POINTER_OWN | 0 );
11908 return resultobj;
11909 fail:
11910 return NULL;
11911 }
11912
11913
11914 SWIGINTERN PyObject *_wrap_Position___add__(PyObject *self, PyObject *args) {
11915 int argc;
11916 PyObject *argv[3];
11917
11918 if (!(argc = SWIG_Python_UnpackTuple(args,"Position___add__",0,2,argv))) SWIG_fail;
11919 --argc;
11920 if (argc == 2) {
11921 int _v = 0;
11922 {
11923 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxPosition, 0);
11924 _v = SWIG_CheckState(res);
11925 }
11926 if (!_v) goto check_1;
11927 return _wrap_Position___add____SWIG_0(self, argc, argv);
11928 }
11929 check_1:
11930
11931 if (argc == 2) {
11932 return _wrap_Position___add____SWIG_1(self, argc, argv);
11933 }
11934
11935 fail:
11936 Py_INCREF(Py_NotImplemented);
11937 return Py_NotImplemented;
11938 }
11939
11940
11941 SWIGINTERN PyObject *_wrap_Position___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11942 PyObject *resultobj = 0;
11943 wxPosition *arg1 = (wxPosition *) 0 ;
11944 wxSize *arg2 = 0 ;
11945 wxPosition result;
11946 void *argp1 = 0 ;
11947 int res1 = 0 ;
11948 wxSize temp2 ;
11949
11950 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
11951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11952 if (!SWIG_IsOK(res1)) {
11953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position___sub__" "', expected argument " "1"" of type '" "wxPosition const *""'");
11954 }
11955 arg1 = reinterpret_cast< wxPosition * >(argp1);
11956 {
11957 arg2 = &temp2;
11958 if ( ! wxSize_helper(swig_obj[1], &arg2)) SWIG_fail;
11959 }
11960 {
11961 result = ((wxPosition const *)arg1)->operator -((wxSize const &)*arg2);
11962 if (PyErr_Occurred()) SWIG_fail;
11963 }
11964 resultobj = SWIG_NewPointerObj((new wxPosition(static_cast< const wxPosition& >(result))), SWIGTYPE_p_wxPosition, SWIG_POINTER_OWN | 0 );
11965 return resultobj;
11966 fail:
11967 return NULL;
11968 }
11969
11970
11971 SWIGINTERN PyObject *_wrap_Position___sub__(PyObject *self, PyObject *args) {
11972 int argc;
11973 PyObject *argv[3];
11974
11975 if (!(argc = SWIG_Python_UnpackTuple(args,"Position___sub__",0,2,argv))) SWIG_fail;
11976 --argc;
11977 if (argc == 2) {
11978 int _v = 0;
11979 {
11980 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxPosition, 0);
11981 _v = SWIG_CheckState(res);
11982 }
11983 if (!_v) goto check_1;
11984 return _wrap_Position___sub____SWIG_0(self, argc, argv);
11985 }
11986 check_1:
11987
11988 if (argc == 2) {
11989 return _wrap_Position___sub____SWIG_1(self, argc, argv);
11990 }
11991
11992 fail:
11993 Py_INCREF(Py_NotImplemented);
11994 return Py_NotImplemented;
11995 }
11996
11997
11998 SWIGINTERN PyObject *Position_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11999 PyObject *obj;
12000 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12001 SWIG_TypeNewClientData(SWIGTYPE_p_wxPosition, SWIG_NewClientData(obj));
12002 return SWIG_Py_Void();
12003 }
12004
12005 SWIGINTERN PyObject *Position_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12006 return SWIG_Python_InitShadowInstance(args);
12007 }
12008
12009 SWIGINTERN int DefaultPosition_set(PyObject *) {
12010 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
12011 return 1;
12012 }
12013
12014
12015 SWIGINTERN PyObject *DefaultPosition_get(void) {
12016 PyObject *pyobj = 0;
12017
12018 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
12019 return pyobj;
12020 }
12021
12022
12023 SWIGINTERN int DefaultSize_set(PyObject *) {
12024 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
12025 return 1;
12026 }
12027
12028
12029 SWIGINTERN PyObject *DefaultSize_get(void) {
12030 PyObject *pyobj = 0;
12031
12032 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
12033 return pyobj;
12034 }
12035
12036
12037 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12038 PyObject *resultobj = 0;
12039 PyObject *arg1 = (PyObject *) 0 ;
12040 wxPyInputStream *result = 0 ;
12041 PyObject * obj0 = 0 ;
12042 char * kwnames[] = {
12043 (char *) "p", NULL
12044 };
12045
12046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
12047 arg1 = obj0;
12048 {
12049 PyThreadState* __tstate = wxPyBeginAllowThreads();
12050 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
12051 wxPyEndAllowThreads(__tstate);
12052 if (PyErr_Occurred()) SWIG_fail;
12053 }
12054 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
12055 return resultobj;
12056 fail:
12057 return NULL;
12058 }
12059
12060
12061 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12062 PyObject *resultobj = 0;
12063 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12064 void *argp1 = 0 ;
12065 int res1 = 0 ;
12066 PyObject *swig_obj[1] ;
12067
12068 if (!args) SWIG_fail;
12069 swig_obj[0] = args;
12070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
12071 if (!SWIG_IsOK(res1)) {
12072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12073 }
12074 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12075 {
12076 PyThreadState* __tstate = wxPyBeginAllowThreads();
12077 delete arg1;
12078
12079 wxPyEndAllowThreads(__tstate);
12080 if (PyErr_Occurred()) SWIG_fail;
12081 }
12082 resultobj = SWIG_Py_Void();
12083 return resultobj;
12084 fail:
12085 return NULL;
12086 }
12087
12088
12089 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12090 PyObject *resultobj = 0;
12091 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12092 void *argp1 = 0 ;
12093 int res1 = 0 ;
12094 PyObject *swig_obj[1] ;
12095
12096 if (!args) SWIG_fail;
12097 swig_obj[0] = args;
12098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12099 if (!SWIG_IsOK(res1)) {
12100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12101 }
12102 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12103 {
12104 PyThreadState* __tstate = wxPyBeginAllowThreads();
12105 (arg1)->close();
12106 wxPyEndAllowThreads(__tstate);
12107 if (PyErr_Occurred()) SWIG_fail;
12108 }
12109 resultobj = SWIG_Py_Void();
12110 return resultobj;
12111 fail:
12112 return NULL;
12113 }
12114
12115
12116 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12117 PyObject *resultobj = 0;
12118 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12119 void *argp1 = 0 ;
12120 int res1 = 0 ;
12121 PyObject *swig_obj[1] ;
12122
12123 if (!args) SWIG_fail;
12124 swig_obj[0] = args;
12125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12126 if (!SWIG_IsOK(res1)) {
12127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12128 }
12129 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12130 {
12131 PyThreadState* __tstate = wxPyBeginAllowThreads();
12132 (arg1)->flush();
12133 wxPyEndAllowThreads(__tstate);
12134 if (PyErr_Occurred()) SWIG_fail;
12135 }
12136 resultobj = SWIG_Py_Void();
12137 return resultobj;
12138 fail:
12139 return NULL;
12140 }
12141
12142
12143 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12144 PyObject *resultobj = 0;
12145 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12146 bool result;
12147 void *argp1 = 0 ;
12148 int res1 = 0 ;
12149 PyObject *swig_obj[1] ;
12150
12151 if (!args) SWIG_fail;
12152 swig_obj[0] = args;
12153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12154 if (!SWIG_IsOK(res1)) {
12155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12156 }
12157 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12158 {
12159 PyThreadState* __tstate = wxPyBeginAllowThreads();
12160 result = (bool)(arg1)->eof();
12161 wxPyEndAllowThreads(__tstate);
12162 if (PyErr_Occurred()) SWIG_fail;
12163 }
12164 {
12165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12166 }
12167 return resultobj;
12168 fail:
12169 return NULL;
12170 }
12171
12172
12173 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12174 PyObject *resultobj = 0;
12175 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12176 int arg2 = (int) -1 ;
12177 PyObject *result = 0 ;
12178 void *argp1 = 0 ;
12179 int res1 = 0 ;
12180 int val2 ;
12181 int ecode2 = 0 ;
12182 PyObject * obj0 = 0 ;
12183 PyObject * obj1 = 0 ;
12184 char * kwnames[] = {
12185 (char *) "self",(char *) "size", NULL
12186 };
12187
12188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
12189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12190 if (!SWIG_IsOK(res1)) {
12191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12192 }
12193 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12194 if (obj1) {
12195 ecode2 = SWIG_AsVal_int(obj1, &val2);
12196 if (!SWIG_IsOK(ecode2)) {
12197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
12198 }
12199 arg2 = static_cast< int >(val2);
12200 }
12201 {
12202 PyThreadState* __tstate = wxPyBeginAllowThreads();
12203 result = (PyObject *)(arg1)->read(arg2);
12204 wxPyEndAllowThreads(__tstate);
12205 if (PyErr_Occurred()) SWIG_fail;
12206 }
12207 resultobj = result;
12208 return resultobj;
12209 fail:
12210 return NULL;
12211 }
12212
12213
12214 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12215 PyObject *resultobj = 0;
12216 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12217 int arg2 = (int) -1 ;
12218 PyObject *result = 0 ;
12219 void *argp1 = 0 ;
12220 int res1 = 0 ;
12221 int val2 ;
12222 int ecode2 = 0 ;
12223 PyObject * obj0 = 0 ;
12224 PyObject * obj1 = 0 ;
12225 char * kwnames[] = {
12226 (char *) "self",(char *) "size", NULL
12227 };
12228
12229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
12230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12231 if (!SWIG_IsOK(res1)) {
12232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12233 }
12234 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12235 if (obj1) {
12236 ecode2 = SWIG_AsVal_int(obj1, &val2);
12237 if (!SWIG_IsOK(ecode2)) {
12238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
12239 }
12240 arg2 = static_cast< int >(val2);
12241 }
12242 {
12243 PyThreadState* __tstate = wxPyBeginAllowThreads();
12244 result = (PyObject *)(arg1)->readline(arg2);
12245 wxPyEndAllowThreads(__tstate);
12246 if (PyErr_Occurred()) SWIG_fail;
12247 }
12248 resultobj = result;
12249 return resultobj;
12250 fail:
12251 return NULL;
12252 }
12253
12254
12255 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12256 PyObject *resultobj = 0;
12257 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12258 int arg2 = (int) -1 ;
12259 PyObject *result = 0 ;
12260 void *argp1 = 0 ;
12261 int res1 = 0 ;
12262 int val2 ;
12263 int ecode2 = 0 ;
12264 PyObject * obj0 = 0 ;
12265 PyObject * obj1 = 0 ;
12266 char * kwnames[] = {
12267 (char *) "self",(char *) "sizehint", NULL
12268 };
12269
12270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
12271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12272 if (!SWIG_IsOK(res1)) {
12273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12274 }
12275 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12276 if (obj1) {
12277 ecode2 = SWIG_AsVal_int(obj1, &val2);
12278 if (!SWIG_IsOK(ecode2)) {
12279 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
12280 }
12281 arg2 = static_cast< int >(val2);
12282 }
12283 {
12284 PyThreadState* __tstate = wxPyBeginAllowThreads();
12285 result = (PyObject *)(arg1)->readlines(arg2);
12286 wxPyEndAllowThreads(__tstate);
12287 if (PyErr_Occurred()) SWIG_fail;
12288 }
12289 resultobj = result;
12290 return resultobj;
12291 fail:
12292 return NULL;
12293 }
12294
12295
12296 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12297 PyObject *resultobj = 0;
12298 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12299 int arg2 ;
12300 int arg3 = (int) 0 ;
12301 void *argp1 = 0 ;
12302 int res1 = 0 ;
12303 int val2 ;
12304 int ecode2 = 0 ;
12305 int val3 ;
12306 int ecode3 = 0 ;
12307 PyObject * obj0 = 0 ;
12308 PyObject * obj1 = 0 ;
12309 PyObject * obj2 = 0 ;
12310 char * kwnames[] = {
12311 (char *) "self",(char *) "offset",(char *) "whence", NULL
12312 };
12313
12314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12316 if (!SWIG_IsOK(res1)) {
12317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12318 }
12319 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12320 ecode2 = SWIG_AsVal_int(obj1, &val2);
12321 if (!SWIG_IsOK(ecode2)) {
12322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
12323 }
12324 arg2 = static_cast< int >(val2);
12325 if (obj2) {
12326 ecode3 = SWIG_AsVal_int(obj2, &val3);
12327 if (!SWIG_IsOK(ecode3)) {
12328 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
12329 }
12330 arg3 = static_cast< int >(val3);
12331 }
12332 {
12333 PyThreadState* __tstate = wxPyBeginAllowThreads();
12334 (arg1)->seek(arg2,arg3);
12335 wxPyEndAllowThreads(__tstate);
12336 if (PyErr_Occurred()) SWIG_fail;
12337 }
12338 resultobj = SWIG_Py_Void();
12339 return resultobj;
12340 fail:
12341 return NULL;
12342 }
12343
12344
12345 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12346 PyObject *resultobj = 0;
12347 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12348 int result;
12349 void *argp1 = 0 ;
12350 int res1 = 0 ;
12351 PyObject *swig_obj[1] ;
12352
12353 if (!args) SWIG_fail;
12354 swig_obj[0] = args;
12355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12356 if (!SWIG_IsOK(res1)) {
12357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12358 }
12359 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12360 {
12361 PyThreadState* __tstate = wxPyBeginAllowThreads();
12362 result = (int)(arg1)->tell();
12363 wxPyEndAllowThreads(__tstate);
12364 if (PyErr_Occurred()) SWIG_fail;
12365 }
12366 resultobj = SWIG_From_int(static_cast< int >(result));
12367 return resultobj;
12368 fail:
12369 return NULL;
12370 }
12371
12372
12373 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12374 PyObject *resultobj = 0;
12375 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12376 char result;
12377 void *argp1 = 0 ;
12378 int res1 = 0 ;
12379 PyObject *swig_obj[1] ;
12380
12381 if (!args) SWIG_fail;
12382 swig_obj[0] = args;
12383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12384 if (!SWIG_IsOK(res1)) {
12385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12386 }
12387 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12388 {
12389 PyThreadState* __tstate = wxPyBeginAllowThreads();
12390 result = (char)(arg1)->Peek();
12391 wxPyEndAllowThreads(__tstate);
12392 if (PyErr_Occurred()) SWIG_fail;
12393 }
12394 resultobj = SWIG_From_char(static_cast< char >(result));
12395 return resultobj;
12396 fail:
12397 return NULL;
12398 }
12399
12400
12401 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12402 PyObject *resultobj = 0;
12403 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12404 char result;
12405 void *argp1 = 0 ;
12406 int res1 = 0 ;
12407 PyObject *swig_obj[1] ;
12408
12409 if (!args) SWIG_fail;
12410 swig_obj[0] = args;
12411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12412 if (!SWIG_IsOK(res1)) {
12413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12414 }
12415 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12416 {
12417 PyThreadState* __tstate = wxPyBeginAllowThreads();
12418 result = (char)(arg1)->GetC();
12419 wxPyEndAllowThreads(__tstate);
12420 if (PyErr_Occurred()) SWIG_fail;
12421 }
12422 resultobj = SWIG_From_char(static_cast< char >(result));
12423 return resultobj;
12424 fail:
12425 return NULL;
12426 }
12427
12428
12429 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12430 PyObject *resultobj = 0;
12431 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12432 size_t result;
12433 void *argp1 = 0 ;
12434 int res1 = 0 ;
12435 PyObject *swig_obj[1] ;
12436
12437 if (!args) SWIG_fail;
12438 swig_obj[0] = args;
12439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12440 if (!SWIG_IsOK(res1)) {
12441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12442 }
12443 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12444 {
12445 PyThreadState* __tstate = wxPyBeginAllowThreads();
12446 result = (size_t)(arg1)->LastRead();
12447 wxPyEndAllowThreads(__tstate);
12448 if (PyErr_Occurred()) SWIG_fail;
12449 }
12450 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12451 return resultobj;
12452 fail:
12453 return NULL;
12454 }
12455
12456
12457 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12458 PyObject *resultobj = 0;
12459 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12460 bool result;
12461 void *argp1 = 0 ;
12462 int res1 = 0 ;
12463 PyObject *swig_obj[1] ;
12464
12465 if (!args) SWIG_fail;
12466 swig_obj[0] = args;
12467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12468 if (!SWIG_IsOK(res1)) {
12469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12470 }
12471 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12472 {
12473 PyThreadState* __tstate = wxPyBeginAllowThreads();
12474 result = (bool)(arg1)->CanRead();
12475 wxPyEndAllowThreads(__tstate);
12476 if (PyErr_Occurred()) SWIG_fail;
12477 }
12478 {
12479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12480 }
12481 return resultobj;
12482 fail:
12483 return NULL;
12484 }
12485
12486
12487 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12488 PyObject *resultobj = 0;
12489 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12490 bool result;
12491 void *argp1 = 0 ;
12492 int res1 = 0 ;
12493 PyObject *swig_obj[1] ;
12494
12495 if (!args) SWIG_fail;
12496 swig_obj[0] = args;
12497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12498 if (!SWIG_IsOK(res1)) {
12499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12500 }
12501 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12502 {
12503 PyThreadState* __tstate = wxPyBeginAllowThreads();
12504 result = (bool)(arg1)->Eof();
12505 wxPyEndAllowThreads(__tstate);
12506 if (PyErr_Occurred()) SWIG_fail;
12507 }
12508 {
12509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12510 }
12511 return resultobj;
12512 fail:
12513 return NULL;
12514 }
12515
12516
12517 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12518 PyObject *resultobj = 0;
12519 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12520 char arg2 ;
12521 bool result;
12522 void *argp1 = 0 ;
12523 int res1 = 0 ;
12524 char val2 ;
12525 int ecode2 = 0 ;
12526 PyObject * obj0 = 0 ;
12527 PyObject * obj1 = 0 ;
12528 char * kwnames[] = {
12529 (char *) "self",(char *) "c", NULL
12530 };
12531
12532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
12533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12534 if (!SWIG_IsOK(res1)) {
12535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12536 }
12537 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12538 ecode2 = SWIG_AsVal_char(obj1, &val2);
12539 if (!SWIG_IsOK(ecode2)) {
12540 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
12541 }
12542 arg2 = static_cast< char >(val2);
12543 {
12544 PyThreadState* __tstate = wxPyBeginAllowThreads();
12545 result = (bool)(arg1)->Ungetch(arg2);
12546 wxPyEndAllowThreads(__tstate);
12547 if (PyErr_Occurred()) SWIG_fail;
12548 }
12549 {
12550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12551 }
12552 return resultobj;
12553 fail:
12554 return NULL;
12555 }
12556
12557
12558 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12559 PyObject *resultobj = 0;
12560 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12561 long arg2 ;
12562 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
12563 long result;
12564 void *argp1 = 0 ;
12565 int res1 = 0 ;
12566 long val2 ;
12567 int ecode2 = 0 ;
12568 int val3 ;
12569 int ecode3 = 0 ;
12570 PyObject * obj0 = 0 ;
12571 PyObject * obj1 = 0 ;
12572 PyObject * obj2 = 0 ;
12573 char * kwnames[] = {
12574 (char *) "self",(char *) "pos",(char *) "mode", NULL
12575 };
12576
12577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12579 if (!SWIG_IsOK(res1)) {
12580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12581 }
12582 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12583 ecode2 = SWIG_AsVal_long(obj1, &val2);
12584 if (!SWIG_IsOK(ecode2)) {
12585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
12586 }
12587 arg2 = static_cast< long >(val2);
12588 if (obj2) {
12589 ecode3 = SWIG_AsVal_int(obj2, &val3);
12590 if (!SWIG_IsOK(ecode3)) {
12591 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
12592 }
12593 arg3 = static_cast< wxSeekMode >(val3);
12594 }
12595 {
12596 PyThreadState* __tstate = wxPyBeginAllowThreads();
12597 result = (long)(arg1)->SeekI(arg2,arg3);
12598 wxPyEndAllowThreads(__tstate);
12599 if (PyErr_Occurred()) SWIG_fail;
12600 }
12601 resultobj = SWIG_From_long(static_cast< long >(result));
12602 return resultobj;
12603 fail:
12604 return NULL;
12605 }
12606
12607
12608 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12609 PyObject *resultobj = 0;
12610 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12611 long result;
12612 void *argp1 = 0 ;
12613 int res1 = 0 ;
12614 PyObject *swig_obj[1] ;
12615
12616 if (!args) SWIG_fail;
12617 swig_obj[0] = args;
12618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12619 if (!SWIG_IsOK(res1)) {
12620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12621 }
12622 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12623 {
12624 PyThreadState* __tstate = wxPyBeginAllowThreads();
12625 result = (long)(arg1)->TellI();
12626 wxPyEndAllowThreads(__tstate);
12627 if (PyErr_Occurred()) SWIG_fail;
12628 }
12629 resultobj = SWIG_From_long(static_cast< long >(result));
12630 return resultobj;
12631 fail:
12632 return NULL;
12633 }
12634
12635
12636 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12637 PyObject *obj;
12638 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12639 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
12640 return SWIG_Py_Void();
12641 }
12642
12643 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12644 return SWIG_Python_InitShadowInstance(args);
12645 }
12646
12647 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12648 PyObject *resultobj = 0;
12649 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12650 PyObject *arg2 = (PyObject *) 0 ;
12651 void *argp1 = 0 ;
12652 int res1 = 0 ;
12653 PyObject * obj0 = 0 ;
12654 PyObject * obj1 = 0 ;
12655 char * kwnames[] = {
12656 (char *) "self",(char *) "obj", NULL
12657 };
12658
12659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
12660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12661 if (!SWIG_IsOK(res1)) {
12662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
12663 }
12664 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12665 arg2 = obj1;
12666 {
12667 PyThreadState* __tstate = wxPyBeginAllowThreads();
12668 wxOutputStream_write(arg1,arg2);
12669 wxPyEndAllowThreads(__tstate);
12670 if (PyErr_Occurred()) SWIG_fail;
12671 }
12672 resultobj = SWIG_Py_Void();
12673 return resultobj;
12674 fail:
12675 return NULL;
12676 }
12677
12678
12679 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12680 PyObject *resultobj = 0;
12681 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12682 size_t result;
12683 void *argp1 = 0 ;
12684 int res1 = 0 ;
12685 PyObject *swig_obj[1] ;
12686
12687 if (!args) SWIG_fail;
12688 swig_obj[0] = args;
12689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12690 if (!SWIG_IsOK(res1)) {
12691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
12692 }
12693 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12694 {
12695 PyThreadState* __tstate = wxPyBeginAllowThreads();
12696 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
12697 wxPyEndAllowThreads(__tstate);
12698 if (PyErr_Occurred()) SWIG_fail;
12699 }
12700 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12701 return resultobj;
12702 fail:
12703 return NULL;
12704 }
12705
12706
12707 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12708 PyObject *obj;
12709 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12710 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
12711 return SWIG_Py_Void();
12712 }
12713
12714 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12715 PyObject *resultobj = 0;
12716 wxInputStream *arg1 = (wxInputStream *) 0 ;
12717 wxString *arg2 = 0 ;
12718 wxString *arg3 = 0 ;
12719 wxString *arg4 = 0 ;
12720 wxDateTime arg5 ;
12721 wxFSFile *result = 0 ;
12722 wxPyInputStream *temp1 ;
12723 bool temp2 = false ;
12724 bool temp3 = false ;
12725 bool temp4 = false ;
12726 void *argp5 ;
12727 int res5 = 0 ;
12728 PyObject * obj0 = 0 ;
12729 PyObject * obj1 = 0 ;
12730 PyObject * obj2 = 0 ;
12731 PyObject * obj3 = 0 ;
12732 PyObject * obj4 = 0 ;
12733 char * kwnames[] = {
12734 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
12735 };
12736
12737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
12738 {
12739 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12740 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
12741 } else {
12742 PyErr_Clear(); // clear the failure of the wxPyConvert above
12743 arg1 = wxPyCBInputStream_create(obj0, true);
12744 if (arg1 == NULL) {
12745 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12746 SWIG_fail;
12747 }
12748 }
12749 }
12750 {
12751 arg2 = wxString_in_helper(obj1);
12752 if (arg2 == NULL) SWIG_fail;
12753 temp2 = true;
12754 }
12755 {
12756 arg3 = wxString_in_helper(obj2);
12757 if (arg3 == NULL) SWIG_fail;
12758 temp3 = true;
12759 }
12760 {
12761 arg4 = wxString_in_helper(obj3);
12762 if (arg4 == NULL) SWIG_fail;
12763 temp4 = true;
12764 }
12765 {
12766 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
12767 if (!SWIG_IsOK(res5)) {
12768 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12769 }
12770 if (!argp5) {
12771 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12772 } else {
12773 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
12774 arg5 = *temp;
12775 if (SWIG_IsNewObj(res5)) delete temp;
12776 }
12777 }
12778 {
12779 PyThreadState* __tstate = wxPyBeginAllowThreads();
12780 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
12781 wxPyEndAllowThreads(__tstate);
12782 if (PyErr_Occurred()) SWIG_fail;
12783 }
12784 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
12785 {
12786 if (temp2)
12787 delete arg2;
12788 }
12789 {
12790 if (temp3)
12791 delete arg3;
12792 }
12793 {
12794 if (temp4)
12795 delete arg4;
12796 }
12797 return resultobj;
12798 fail:
12799 {
12800 if (temp2)
12801 delete arg2;
12802 }
12803 {
12804 if (temp3)
12805 delete arg3;
12806 }
12807 {
12808 if (temp4)
12809 delete arg4;
12810 }
12811 return NULL;
12812 }
12813
12814
12815 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12816 PyObject *resultobj = 0;
12817 wxFSFile *arg1 = (wxFSFile *) 0 ;
12818 void *argp1 = 0 ;
12819 int res1 = 0 ;
12820 PyObject *swig_obj[1] ;
12821
12822 if (!args) SWIG_fail;
12823 swig_obj[0] = args;
12824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
12825 if (!SWIG_IsOK(res1)) {
12826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
12827 }
12828 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12829 {
12830 PyThreadState* __tstate = wxPyBeginAllowThreads();
12831 delete arg1;
12832
12833 wxPyEndAllowThreads(__tstate);
12834 if (PyErr_Occurred()) SWIG_fail;
12835 }
12836 resultobj = SWIG_Py_Void();
12837 return resultobj;
12838 fail:
12839 return NULL;
12840 }
12841
12842
12843 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12844 PyObject *resultobj = 0;
12845 wxFSFile *arg1 = (wxFSFile *) 0 ;
12846 wxInputStream *result = 0 ;
12847 void *argp1 = 0 ;
12848 int res1 = 0 ;
12849 PyObject *swig_obj[1] ;
12850
12851 if (!args) SWIG_fail;
12852 swig_obj[0] = args;
12853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12854 if (!SWIG_IsOK(res1)) {
12855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12856 }
12857 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12858 {
12859 PyThreadState* __tstate = wxPyBeginAllowThreads();
12860 result = (wxInputStream *)(arg1)->GetStream();
12861 wxPyEndAllowThreads(__tstate);
12862 if (PyErr_Occurred()) SWIG_fail;
12863 }
12864 {
12865 wxPyInputStream * _ptr = NULL;
12866
12867 if (result) {
12868 _ptr = new wxPyInputStream(result);
12869 }
12870 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
12871 }
12872 return resultobj;
12873 fail:
12874 return NULL;
12875 }
12876
12877
12878 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12879 PyObject *resultobj = 0;
12880 wxFSFile *arg1 = (wxFSFile *) 0 ;
12881 void *argp1 = 0 ;
12882 int res1 = 0 ;
12883 PyObject *swig_obj[1] ;
12884
12885 if (!args) SWIG_fail;
12886 swig_obj[0] = args;
12887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12888 if (!SWIG_IsOK(res1)) {
12889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12890 }
12891 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12892 {
12893 PyThreadState* __tstate = wxPyBeginAllowThreads();
12894 (arg1)->DetachStream();
12895 wxPyEndAllowThreads(__tstate);
12896 if (PyErr_Occurred()) SWIG_fail;
12897 }
12898 resultobj = SWIG_Py_Void();
12899 return resultobj;
12900 fail:
12901 return NULL;
12902 }
12903
12904
12905 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12906 PyObject *resultobj = 0;
12907 wxFSFile *arg1 = (wxFSFile *) 0 ;
12908 wxString *result = 0 ;
12909 void *argp1 = 0 ;
12910 int res1 = 0 ;
12911 PyObject *swig_obj[1] ;
12912
12913 if (!args) SWIG_fail;
12914 swig_obj[0] = args;
12915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12916 if (!SWIG_IsOK(res1)) {
12917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
12918 }
12919 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12920 {
12921 PyThreadState* __tstate = wxPyBeginAllowThreads();
12922 {
12923 wxString const &_result_ref = (arg1)->GetMimeType();
12924 result = (wxString *) &_result_ref;
12925 }
12926 wxPyEndAllowThreads(__tstate);
12927 if (PyErr_Occurred()) SWIG_fail;
12928 }
12929 {
12930 #if wxUSE_UNICODE
12931 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12932 #else
12933 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12934 #endif
12935 }
12936 return resultobj;
12937 fail:
12938 return NULL;
12939 }
12940
12941
12942 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12943 PyObject *resultobj = 0;
12944 wxFSFile *arg1 = (wxFSFile *) 0 ;
12945 wxString *result = 0 ;
12946 void *argp1 = 0 ;
12947 int res1 = 0 ;
12948 PyObject *swig_obj[1] ;
12949
12950 if (!args) SWIG_fail;
12951 swig_obj[0] = args;
12952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12953 if (!SWIG_IsOK(res1)) {
12954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
12955 }
12956 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12957 {
12958 PyThreadState* __tstate = wxPyBeginAllowThreads();
12959 {
12960 wxString const &_result_ref = (arg1)->GetLocation();
12961 result = (wxString *) &_result_ref;
12962 }
12963 wxPyEndAllowThreads(__tstate);
12964 if (PyErr_Occurred()) SWIG_fail;
12965 }
12966 {
12967 #if wxUSE_UNICODE
12968 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12969 #else
12970 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12971 #endif
12972 }
12973 return resultobj;
12974 fail:
12975 return NULL;
12976 }
12977
12978
12979 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12980 PyObject *resultobj = 0;
12981 wxFSFile *arg1 = (wxFSFile *) 0 ;
12982 wxString *result = 0 ;
12983 void *argp1 = 0 ;
12984 int res1 = 0 ;
12985 PyObject *swig_obj[1] ;
12986
12987 if (!args) SWIG_fail;
12988 swig_obj[0] = args;
12989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12990 if (!SWIG_IsOK(res1)) {
12991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
12992 }
12993 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12994 {
12995 PyThreadState* __tstate = wxPyBeginAllowThreads();
12996 {
12997 wxString const &_result_ref = (arg1)->GetAnchor();
12998 result = (wxString *) &_result_ref;
12999 }
13000 wxPyEndAllowThreads(__tstate);
13001 if (PyErr_Occurred()) SWIG_fail;
13002 }
13003 {
13004 #if wxUSE_UNICODE
13005 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13006 #else
13007 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13008 #endif
13009 }
13010 return resultobj;
13011 fail:
13012 return NULL;
13013 }
13014
13015
13016 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13017 PyObject *resultobj = 0;
13018 wxFSFile *arg1 = (wxFSFile *) 0 ;
13019 wxDateTime result;
13020 void *argp1 = 0 ;
13021 int res1 = 0 ;
13022 PyObject *swig_obj[1] ;
13023
13024 if (!args) SWIG_fail;
13025 swig_obj[0] = args;
13026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
13027 if (!SWIG_IsOK(res1)) {
13028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
13029 }
13030 arg1 = reinterpret_cast< wxFSFile * >(argp1);
13031 {
13032 PyThreadState* __tstate = wxPyBeginAllowThreads();
13033 result = (arg1)->GetModificationTime();
13034 wxPyEndAllowThreads(__tstate);
13035 if (PyErr_Occurred()) SWIG_fail;
13036 }
13037 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
13038 return resultobj;
13039 fail:
13040 return NULL;
13041 }
13042
13043
13044 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13045 PyObject *obj;
13046 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13047 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
13048 return SWIG_Py_Void();
13049 }
13050
13051 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13052 return SWIG_Python_InitShadowInstance(args);
13053 }
13054
13055 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13056 PyObject *resultobj = 0;
13057 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13058 void *argp1 = 0 ;
13059 int res1 = 0 ;
13060 PyObject *swig_obj[1] ;
13061
13062 if (!args) SWIG_fail;
13063 swig_obj[0] = args;
13064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
13065 if (!SWIG_IsOK(res1)) {
13066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13067 }
13068 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
13069 {
13070 PyThreadState* __tstate = wxPyBeginAllowThreads();
13071 delete arg1;
13072
13073 wxPyEndAllowThreads(__tstate);
13074 if (PyErr_Occurred()) SWIG_fail;
13075 }
13076 resultobj = SWIG_Py_Void();
13077 return resultobj;
13078 fail:
13079 return NULL;
13080 }
13081
13082
13083 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13084 PyObject *obj;
13085 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13086 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
13087 return SWIG_Py_Void();
13088 }
13089
13090 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13091 PyObject *resultobj = 0;
13092 wxPyFileSystemHandler *result = 0 ;
13093
13094 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
13095 {
13096 PyThreadState* __tstate = wxPyBeginAllowThreads();
13097 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
13098 wxPyEndAllowThreads(__tstate);
13099 if (PyErr_Occurred()) SWIG_fail;
13100 }
13101 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
13102 return resultobj;
13103 fail:
13104 return NULL;
13105 }
13106
13107
13108 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13109 PyObject *resultobj = 0;
13110 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13111 PyObject *arg2 = (PyObject *) 0 ;
13112 PyObject *arg3 = (PyObject *) 0 ;
13113 void *argp1 = 0 ;
13114 int res1 = 0 ;
13115 PyObject * obj0 = 0 ;
13116 PyObject * obj1 = 0 ;
13117 PyObject * obj2 = 0 ;
13118 char * kwnames[] = {
13119 (char *) "self",(char *) "self",(char *) "_class", NULL
13120 };
13121
13122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13124 if (!SWIG_IsOK(res1)) {
13125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13126 }
13127 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13128 arg2 = obj1;
13129 arg3 = obj2;
13130 {
13131 PyThreadState* __tstate = wxPyBeginAllowThreads();
13132 (arg1)->_setCallbackInfo(arg2,arg3);
13133 wxPyEndAllowThreads(__tstate);
13134 if (PyErr_Occurred()) SWIG_fail;
13135 }
13136 resultobj = SWIG_Py_Void();
13137 return resultobj;
13138 fail:
13139 return NULL;
13140 }
13141
13142
13143 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13144 PyObject *resultobj = 0;
13145 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13146 wxString *arg2 = 0 ;
13147 bool result;
13148 void *argp1 = 0 ;
13149 int res1 = 0 ;
13150 bool temp2 = false ;
13151 PyObject * obj0 = 0 ;
13152 PyObject * obj1 = 0 ;
13153 char * kwnames[] = {
13154 (char *) "self",(char *) "location", NULL
13155 };
13156
13157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13159 if (!SWIG_IsOK(res1)) {
13160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13161 }
13162 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13163 {
13164 arg2 = wxString_in_helper(obj1);
13165 if (arg2 == NULL) SWIG_fail;
13166 temp2 = true;
13167 }
13168 {
13169 PyThreadState* __tstate = wxPyBeginAllowThreads();
13170 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13171 wxPyEndAllowThreads(__tstate);
13172 if (PyErr_Occurred()) SWIG_fail;
13173 }
13174 {
13175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13176 }
13177 {
13178 if (temp2)
13179 delete arg2;
13180 }
13181 return resultobj;
13182 fail:
13183 {
13184 if (temp2)
13185 delete arg2;
13186 }
13187 return NULL;
13188 }
13189
13190
13191 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13192 PyObject *resultobj = 0;
13193 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13194 wxFileSystem *arg2 = 0 ;
13195 wxString *arg3 = 0 ;
13196 wxFSFile *result = 0 ;
13197 void *argp1 = 0 ;
13198 int res1 = 0 ;
13199 void *argp2 = 0 ;
13200 int res2 = 0 ;
13201 bool temp3 = false ;
13202 PyObject * obj0 = 0 ;
13203 PyObject * obj1 = 0 ;
13204 PyObject * obj2 = 0 ;
13205 char * kwnames[] = {
13206 (char *) "self",(char *) "fs",(char *) "location", NULL
13207 };
13208
13209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13211 if (!SWIG_IsOK(res1)) {
13212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13213 }
13214 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13215 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13216 if (!SWIG_IsOK(res2)) {
13217 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13218 }
13219 if (!argp2) {
13220 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13221 }
13222 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13223 {
13224 arg3 = wxString_in_helper(obj2);
13225 if (arg3 == NULL) SWIG_fail;
13226 temp3 = true;
13227 }
13228 {
13229 PyThreadState* __tstate = wxPyBeginAllowThreads();
13230 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13231 wxPyEndAllowThreads(__tstate);
13232 if (PyErr_Occurred()) SWIG_fail;
13233 }
13234 {
13235 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13236 }
13237 {
13238 if (temp3)
13239 delete arg3;
13240 }
13241 return resultobj;
13242 fail:
13243 {
13244 if (temp3)
13245 delete arg3;
13246 }
13247 return NULL;
13248 }
13249
13250
13251 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13252 PyObject *resultobj = 0;
13253 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13254 wxString *arg2 = 0 ;
13255 int arg3 = (int) 0 ;
13256 wxString result;
13257 void *argp1 = 0 ;
13258 int res1 = 0 ;
13259 bool temp2 = false ;
13260 int val3 ;
13261 int ecode3 = 0 ;
13262 PyObject * obj0 = 0 ;
13263 PyObject * obj1 = 0 ;
13264 PyObject * obj2 = 0 ;
13265 char * kwnames[] = {
13266 (char *) "self",(char *) "spec",(char *) "flags", NULL
13267 };
13268
13269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13271 if (!SWIG_IsOK(res1)) {
13272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13273 }
13274 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13275 {
13276 arg2 = wxString_in_helper(obj1);
13277 if (arg2 == NULL) SWIG_fail;
13278 temp2 = true;
13279 }
13280 if (obj2) {
13281 ecode3 = SWIG_AsVal_int(obj2, &val3);
13282 if (!SWIG_IsOK(ecode3)) {
13283 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
13284 }
13285 arg3 = static_cast< int >(val3);
13286 }
13287 {
13288 PyThreadState* __tstate = wxPyBeginAllowThreads();
13289 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13290 wxPyEndAllowThreads(__tstate);
13291 if (PyErr_Occurred()) SWIG_fail;
13292 }
13293 {
13294 #if wxUSE_UNICODE
13295 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13296 #else
13297 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13298 #endif
13299 }
13300 {
13301 if (temp2)
13302 delete arg2;
13303 }
13304 return resultobj;
13305 fail:
13306 {
13307 if (temp2)
13308 delete arg2;
13309 }
13310 return NULL;
13311 }
13312
13313
13314 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13315 PyObject *resultobj = 0;
13316 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13317 wxString result;
13318 void *argp1 = 0 ;
13319 int res1 = 0 ;
13320 PyObject *swig_obj[1] ;
13321
13322 if (!args) SWIG_fail;
13323 swig_obj[0] = args;
13324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13325 if (!SWIG_IsOK(res1)) {
13326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13327 }
13328 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13329 {
13330 PyThreadState* __tstate = wxPyBeginAllowThreads();
13331 result = (arg1)->FindNext();
13332 wxPyEndAllowThreads(__tstate);
13333 if (PyErr_Occurred()) SWIG_fail;
13334 }
13335 {
13336 #if wxUSE_UNICODE
13337 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13338 #else
13339 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13340 #endif
13341 }
13342 return resultobj;
13343 fail:
13344 return NULL;
13345 }
13346
13347
13348 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13349 PyObject *resultobj = 0;
13350 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13351 wxString *arg2 = 0 ;
13352 wxString result;
13353 void *argp1 = 0 ;
13354 int res1 = 0 ;
13355 bool temp2 = false ;
13356 PyObject * obj0 = 0 ;
13357 PyObject * obj1 = 0 ;
13358 char * kwnames[] = {
13359 (char *) "self",(char *) "location", NULL
13360 };
13361
13362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
13363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13364 if (!SWIG_IsOK(res1)) {
13365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13366 }
13367 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13368 {
13369 arg2 = wxString_in_helper(obj1);
13370 if (arg2 == NULL) SWIG_fail;
13371 temp2 = true;
13372 }
13373 {
13374 PyThreadState* __tstate = wxPyBeginAllowThreads();
13375 result = (arg1)->GetProtocol((wxString const &)*arg2);
13376 wxPyEndAllowThreads(__tstate);
13377 if (PyErr_Occurred()) SWIG_fail;
13378 }
13379 {
13380 #if wxUSE_UNICODE
13381 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13382 #else
13383 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13384 #endif
13385 }
13386 {
13387 if (temp2)
13388 delete arg2;
13389 }
13390 return resultobj;
13391 fail:
13392 {
13393 if (temp2)
13394 delete arg2;
13395 }
13396 return NULL;
13397 }
13398
13399
13400 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13401 PyObject *resultobj = 0;
13402 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13403 wxString *arg2 = 0 ;
13404 wxString result;
13405 void *argp1 = 0 ;
13406 int res1 = 0 ;
13407 bool temp2 = false ;
13408 PyObject * obj0 = 0 ;
13409 PyObject * obj1 = 0 ;
13410 char * kwnames[] = {
13411 (char *) "self",(char *) "location", NULL
13412 };
13413
13414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
13415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13416 if (!SWIG_IsOK(res1)) {
13417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13418 }
13419 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13420 {
13421 arg2 = wxString_in_helper(obj1);
13422 if (arg2 == NULL) SWIG_fail;
13423 temp2 = true;
13424 }
13425 {
13426 PyThreadState* __tstate = wxPyBeginAllowThreads();
13427 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
13428 wxPyEndAllowThreads(__tstate);
13429 if (PyErr_Occurred()) SWIG_fail;
13430 }
13431 {
13432 #if wxUSE_UNICODE
13433 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13434 #else
13435 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13436 #endif
13437 }
13438 {
13439 if (temp2)
13440 delete arg2;
13441 }
13442 return resultobj;
13443 fail:
13444 {
13445 if (temp2)
13446 delete arg2;
13447 }
13448 return NULL;
13449 }
13450
13451
13452 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13453 PyObject *resultobj = 0;
13454 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13455 wxString *arg2 = 0 ;
13456 wxString result;
13457 void *argp1 = 0 ;
13458 int res1 = 0 ;
13459 bool temp2 = false ;
13460 PyObject * obj0 = 0 ;
13461 PyObject * obj1 = 0 ;
13462 char * kwnames[] = {
13463 (char *) "self",(char *) "location", NULL
13464 };
13465
13466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
13467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13468 if (!SWIG_IsOK(res1)) {
13469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13470 }
13471 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13472 {
13473 arg2 = wxString_in_helper(obj1);
13474 if (arg2 == NULL) SWIG_fail;
13475 temp2 = true;
13476 }
13477 {
13478 PyThreadState* __tstate = wxPyBeginAllowThreads();
13479 result = (arg1)->GetAnchor((wxString const &)*arg2);
13480 wxPyEndAllowThreads(__tstate);
13481 if (PyErr_Occurred()) SWIG_fail;
13482 }
13483 {
13484 #if wxUSE_UNICODE
13485 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13486 #else
13487 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13488 #endif
13489 }
13490 {
13491 if (temp2)
13492 delete arg2;
13493 }
13494 return resultobj;
13495 fail:
13496 {
13497 if (temp2)
13498 delete arg2;
13499 }
13500 return NULL;
13501 }
13502
13503
13504 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13505 PyObject *resultobj = 0;
13506 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13507 wxString *arg2 = 0 ;
13508 wxString result;
13509 void *argp1 = 0 ;
13510 int res1 = 0 ;
13511 bool temp2 = false ;
13512 PyObject * obj0 = 0 ;
13513 PyObject * obj1 = 0 ;
13514 char * kwnames[] = {
13515 (char *) "self",(char *) "location", NULL
13516 };
13517
13518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
13519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13520 if (!SWIG_IsOK(res1)) {
13521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13522 }
13523 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13524 {
13525 arg2 = wxString_in_helper(obj1);
13526 if (arg2 == NULL) SWIG_fail;
13527 temp2 = true;
13528 }
13529 {
13530 PyThreadState* __tstate = wxPyBeginAllowThreads();
13531 result = (arg1)->GetRightLocation((wxString const &)*arg2);
13532 wxPyEndAllowThreads(__tstate);
13533 if (PyErr_Occurred()) SWIG_fail;
13534 }
13535 {
13536 #if wxUSE_UNICODE
13537 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13538 #else
13539 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13540 #endif
13541 }
13542 {
13543 if (temp2)
13544 delete arg2;
13545 }
13546 return resultobj;
13547 fail:
13548 {
13549 if (temp2)
13550 delete arg2;
13551 }
13552 return NULL;
13553 }
13554
13555
13556 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13557 PyObject *resultobj = 0;
13558 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13559 wxString *arg2 = 0 ;
13560 wxString result;
13561 void *argp1 = 0 ;
13562 int res1 = 0 ;
13563 bool temp2 = false ;
13564 PyObject * obj0 = 0 ;
13565 PyObject * obj1 = 0 ;
13566 char * kwnames[] = {
13567 (char *) "self",(char *) "location", NULL
13568 };
13569
13570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
13571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13572 if (!SWIG_IsOK(res1)) {
13573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13574 }
13575 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13576 {
13577 arg2 = wxString_in_helper(obj1);
13578 if (arg2 == NULL) SWIG_fail;
13579 temp2 = true;
13580 }
13581 {
13582 PyThreadState* __tstate = wxPyBeginAllowThreads();
13583 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
13584 wxPyEndAllowThreads(__tstate);
13585 if (PyErr_Occurred()) SWIG_fail;
13586 }
13587 {
13588 #if wxUSE_UNICODE
13589 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13590 #else
13591 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13592 #endif
13593 }
13594 {
13595 if (temp2)
13596 delete arg2;
13597 }
13598 return resultobj;
13599 fail:
13600 {
13601 if (temp2)
13602 delete arg2;
13603 }
13604 return NULL;
13605 }
13606
13607
13608 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13609 PyObject *obj;
13610 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13611 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
13612 return SWIG_Py_Void();
13613 }
13614
13615 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13616 return SWIG_Python_InitShadowInstance(args);
13617 }
13618
13619 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13620 PyObject *resultobj = 0;
13621 wxFileSystem *result = 0 ;
13622
13623 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
13624 {
13625 PyThreadState* __tstate = wxPyBeginAllowThreads();
13626 result = (wxFileSystem *)new wxFileSystem();
13627 wxPyEndAllowThreads(__tstate);
13628 if (PyErr_Occurred()) SWIG_fail;
13629 }
13630 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystem, SWIG_POINTER_NEW | 0 );
13631 return resultobj;
13632 fail:
13633 return NULL;
13634 }
13635
13636
13637 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13638 PyObject *resultobj = 0;
13639 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13640 void *argp1 = 0 ;
13641 int res1 = 0 ;
13642 PyObject *swig_obj[1] ;
13643
13644 if (!args) SWIG_fail;
13645 swig_obj[0] = args;
13646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
13647 if (!SWIG_IsOK(res1)) {
13648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13649 }
13650 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13651 {
13652 PyThreadState* __tstate = wxPyBeginAllowThreads();
13653 delete arg1;
13654
13655 wxPyEndAllowThreads(__tstate);
13656 if (PyErr_Occurred()) SWIG_fail;
13657 }
13658 resultobj = SWIG_Py_Void();
13659 return resultobj;
13660 fail:
13661 return NULL;
13662 }
13663
13664
13665 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13666 PyObject *resultobj = 0;
13667 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13668 wxString *arg2 = 0 ;
13669 bool arg3 = (bool) false ;
13670 void *argp1 = 0 ;
13671 int res1 = 0 ;
13672 bool temp2 = false ;
13673 bool val3 ;
13674 int ecode3 = 0 ;
13675 PyObject * obj0 = 0 ;
13676 PyObject * obj1 = 0 ;
13677 PyObject * obj2 = 0 ;
13678 char * kwnames[] = {
13679 (char *) "self",(char *) "location",(char *) "is_dir", NULL
13680 };
13681
13682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13684 if (!SWIG_IsOK(res1)) {
13685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13686 }
13687 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13688 {
13689 arg2 = wxString_in_helper(obj1);
13690 if (arg2 == NULL) SWIG_fail;
13691 temp2 = true;
13692 }
13693 if (obj2) {
13694 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13695 if (!SWIG_IsOK(ecode3)) {
13696 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
13697 }
13698 arg3 = static_cast< bool >(val3);
13699 }
13700 {
13701 PyThreadState* __tstate = wxPyBeginAllowThreads();
13702 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
13703 wxPyEndAllowThreads(__tstate);
13704 if (PyErr_Occurred()) SWIG_fail;
13705 }
13706 resultobj = SWIG_Py_Void();
13707 {
13708 if (temp2)
13709 delete arg2;
13710 }
13711 return resultobj;
13712 fail:
13713 {
13714 if (temp2)
13715 delete arg2;
13716 }
13717 return NULL;
13718 }
13719
13720
13721 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13722 PyObject *resultobj = 0;
13723 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13724 wxString result;
13725 void *argp1 = 0 ;
13726 int res1 = 0 ;
13727 PyObject *swig_obj[1] ;
13728
13729 if (!args) SWIG_fail;
13730 swig_obj[0] = args;
13731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13732 if (!SWIG_IsOK(res1)) {
13733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13734 }
13735 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13736 {
13737 PyThreadState* __tstate = wxPyBeginAllowThreads();
13738 result = (arg1)->GetPath();
13739 wxPyEndAllowThreads(__tstate);
13740 if (PyErr_Occurred()) SWIG_fail;
13741 }
13742 {
13743 #if wxUSE_UNICODE
13744 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13745 #else
13746 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13747 #endif
13748 }
13749 return resultobj;
13750 fail:
13751 return NULL;
13752 }
13753
13754
13755 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13756 PyObject *resultobj = 0;
13757 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13758 wxString *arg2 = 0 ;
13759 wxFSFile *result = 0 ;
13760 void *argp1 = 0 ;
13761 int res1 = 0 ;
13762 bool temp2 = false ;
13763 PyObject * obj0 = 0 ;
13764 PyObject * obj1 = 0 ;
13765 char * kwnames[] = {
13766 (char *) "self",(char *) "location", NULL
13767 };
13768
13769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
13770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13771 if (!SWIG_IsOK(res1)) {
13772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13773 }
13774 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13775 {
13776 arg2 = wxString_in_helper(obj1);
13777 if (arg2 == NULL) SWIG_fail;
13778 temp2 = true;
13779 }
13780 {
13781 PyThreadState* __tstate = wxPyBeginAllowThreads();
13782 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
13783 wxPyEndAllowThreads(__tstate);
13784 if (PyErr_Occurred()) SWIG_fail;
13785 }
13786 {
13787 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13788 }
13789 {
13790 if (temp2)
13791 delete arg2;
13792 }
13793 return resultobj;
13794 fail:
13795 {
13796 if (temp2)
13797 delete arg2;
13798 }
13799 return NULL;
13800 }
13801
13802
13803 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13804 PyObject *resultobj = 0;
13805 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13806 wxString *arg2 = 0 ;
13807 int arg3 = (int) 0 ;
13808 wxString result;
13809 void *argp1 = 0 ;
13810 int res1 = 0 ;
13811 bool temp2 = false ;
13812 int val3 ;
13813 int ecode3 = 0 ;
13814 PyObject * obj0 = 0 ;
13815 PyObject * obj1 = 0 ;
13816 PyObject * obj2 = 0 ;
13817 char * kwnames[] = {
13818 (char *) "self",(char *) "spec",(char *) "flags", NULL
13819 };
13820
13821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13823 if (!SWIG_IsOK(res1)) {
13824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13825 }
13826 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13827 {
13828 arg2 = wxString_in_helper(obj1);
13829 if (arg2 == NULL) SWIG_fail;
13830 temp2 = true;
13831 }
13832 if (obj2) {
13833 ecode3 = SWIG_AsVal_int(obj2, &val3);
13834 if (!SWIG_IsOK(ecode3)) {
13835 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
13836 }
13837 arg3 = static_cast< int >(val3);
13838 }
13839 {
13840 PyThreadState* __tstate = wxPyBeginAllowThreads();
13841 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13842 wxPyEndAllowThreads(__tstate);
13843 if (PyErr_Occurred()) SWIG_fail;
13844 }
13845 {
13846 #if wxUSE_UNICODE
13847 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13848 #else
13849 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13850 #endif
13851 }
13852 {
13853 if (temp2)
13854 delete arg2;
13855 }
13856 return resultobj;
13857 fail:
13858 {
13859 if (temp2)
13860 delete arg2;
13861 }
13862 return NULL;
13863 }
13864
13865
13866 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13867 PyObject *resultobj = 0;
13868 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13869 wxString result;
13870 void *argp1 = 0 ;
13871 int res1 = 0 ;
13872 PyObject *swig_obj[1] ;
13873
13874 if (!args) SWIG_fail;
13875 swig_obj[0] = args;
13876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13877 if (!SWIG_IsOK(res1)) {
13878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13879 }
13880 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13881 {
13882 PyThreadState* __tstate = wxPyBeginAllowThreads();
13883 result = (arg1)->FindNext();
13884 wxPyEndAllowThreads(__tstate);
13885 if (PyErr_Occurred()) SWIG_fail;
13886 }
13887 {
13888 #if wxUSE_UNICODE
13889 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13890 #else
13891 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13892 #endif
13893 }
13894 return resultobj;
13895 fail:
13896 return NULL;
13897 }
13898
13899
13900 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13901 PyObject *resultobj = 0;
13902 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13903 int res1 = 0 ;
13904 PyObject * obj0 = 0 ;
13905 char * kwnames[] = {
13906 (char *) "handler", NULL
13907 };
13908
13909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
13910 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
13911 if (!SWIG_IsOK(res1)) {
13912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13913 }
13914 {
13915 PyThreadState* __tstate = wxPyBeginAllowThreads();
13916 wxFileSystem::AddHandler(arg1);
13917 wxPyEndAllowThreads(__tstate);
13918 if (PyErr_Occurred()) SWIG_fail;
13919 }
13920 resultobj = SWIG_Py_Void();
13921 return resultobj;
13922 fail:
13923 return NULL;
13924 }
13925
13926
13927 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13928 PyObject *resultobj = 0;
13929 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13930 wxFileSystemHandler *result = 0 ;
13931 void *argp1 = 0 ;
13932 int res1 = 0 ;
13933 PyObject * obj0 = 0 ;
13934 char * kwnames[] = {
13935 (char *) "handler", NULL
13936 };
13937
13938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
13939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
13940 if (!SWIG_IsOK(res1)) {
13941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13942 }
13943 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
13944 {
13945 PyThreadState* __tstate = wxPyBeginAllowThreads();
13946 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
13947 wxPyEndAllowThreads(__tstate);
13948 if (PyErr_Occurred()) SWIG_fail;
13949 }
13950 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
13951 return resultobj;
13952 fail:
13953 return NULL;
13954 }
13955
13956
13957 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13958 PyObject *resultobj = 0;
13959
13960 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
13961 {
13962 PyThreadState* __tstate = wxPyBeginAllowThreads();
13963 wxFileSystem::CleanUpHandlers();
13964 wxPyEndAllowThreads(__tstate);
13965 if (PyErr_Occurred()) SWIG_fail;
13966 }
13967 resultobj = SWIG_Py_Void();
13968 return resultobj;
13969 fail:
13970 return NULL;
13971 }
13972
13973
13974 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13975 PyObject *resultobj = 0;
13976 wxString *arg1 = 0 ;
13977 wxString result;
13978 bool temp1 = false ;
13979 PyObject * obj0 = 0 ;
13980 char * kwnames[] = {
13981 (char *) "filename", NULL
13982 };
13983
13984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
13985 {
13986 arg1 = wxString_in_helper(obj0);
13987 if (arg1 == NULL) SWIG_fail;
13988 temp1 = true;
13989 }
13990 {
13991 PyThreadState* __tstate = wxPyBeginAllowThreads();
13992 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
13993 wxPyEndAllowThreads(__tstate);
13994 if (PyErr_Occurred()) SWIG_fail;
13995 }
13996 {
13997 #if wxUSE_UNICODE
13998 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13999 #else
14000 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14001 #endif
14002 }
14003 {
14004 if (temp1)
14005 delete arg1;
14006 }
14007 return resultobj;
14008 fail:
14009 {
14010 if (temp1)
14011 delete arg1;
14012 }
14013 return NULL;
14014 }
14015
14016
14017 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14018 PyObject *resultobj = 0;
14019 wxString *arg1 = 0 ;
14020 wxString result;
14021 bool temp1 = false ;
14022 PyObject * obj0 = 0 ;
14023 char * kwnames[] = {
14024 (char *) "url", NULL
14025 };
14026
14027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
14028 {
14029 arg1 = wxString_in_helper(obj0);
14030 if (arg1 == NULL) SWIG_fail;
14031 temp1 = true;
14032 }
14033 {
14034 PyThreadState* __tstate = wxPyBeginAllowThreads();
14035 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
14036 wxPyEndAllowThreads(__tstate);
14037 if (PyErr_Occurred()) SWIG_fail;
14038 }
14039 {
14040 #if wxUSE_UNICODE
14041 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14042 #else
14043 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14044 #endif
14045 }
14046 {
14047 if (temp1)
14048 delete arg1;
14049 }
14050 return resultobj;
14051 fail:
14052 {
14053 if (temp1)
14054 delete arg1;
14055 }
14056 return NULL;
14057 }
14058
14059
14060 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14061 PyObject *obj;
14062 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14063 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
14064 return SWIG_Py_Void();
14065 }
14066
14067 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14068 return SWIG_Python_InitShadowInstance(args);
14069 }
14070
14071 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14072 PyObject *resultobj = 0;
14073 wxInternetFSHandler *result = 0 ;
14074
14075 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
14076 {
14077 PyThreadState* __tstate = wxPyBeginAllowThreads();
14078 result = (wxInternetFSHandler *)new wxInternetFSHandler();
14079 wxPyEndAllowThreads(__tstate);
14080 if (PyErr_Occurred()) SWIG_fail;
14081 }
14082 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
14083 return resultobj;
14084 fail:
14085 return NULL;
14086 }
14087
14088
14089 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14090 PyObject *resultobj = 0;
14091 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
14092 wxString *arg2 = 0 ;
14093 bool result;
14094 void *argp1 = 0 ;
14095 int res1 = 0 ;
14096 bool temp2 = false ;
14097 PyObject * obj0 = 0 ;
14098 PyObject * obj1 = 0 ;
14099 char * kwnames[] = {
14100 (char *) "self",(char *) "location", NULL
14101 };
14102
14103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
14104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
14105 if (!SWIG_IsOK(res1)) {
14106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
14107 }
14108 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
14109 {
14110 arg2 = wxString_in_helper(obj1);
14111 if (arg2 == NULL) SWIG_fail;
14112 temp2 = true;
14113 }
14114 {
14115 PyThreadState* __tstate = wxPyBeginAllowThreads();
14116 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
14117 wxPyEndAllowThreads(__tstate);
14118 if (PyErr_Occurred()) SWIG_fail;
14119 }
14120 {
14121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14122 }
14123 {
14124 if (temp2)
14125 delete arg2;
14126 }
14127 return resultobj;
14128 fail:
14129 {
14130 if (temp2)
14131 delete arg2;
14132 }
14133 return NULL;
14134 }
14135
14136
14137 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14138 PyObject *resultobj = 0;
14139 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
14140 wxFileSystem *arg2 = 0 ;
14141 wxString *arg3 = 0 ;
14142 wxFSFile *result = 0 ;
14143 void *argp1 = 0 ;
14144 int res1 = 0 ;
14145 void *argp2 = 0 ;
14146 int res2 = 0 ;
14147 bool temp3 = false ;
14148 PyObject * obj0 = 0 ;
14149 PyObject * obj1 = 0 ;
14150 PyObject * obj2 = 0 ;
14151 char * kwnames[] = {
14152 (char *) "self",(char *) "fs",(char *) "location", NULL
14153 };
14154
14155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
14157 if (!SWIG_IsOK(res1)) {
14158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
14159 }
14160 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
14161 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
14162 if (!SWIG_IsOK(res2)) {
14163 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14164 }
14165 if (!argp2) {
14166 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14167 }
14168 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
14169 {
14170 arg3 = wxString_in_helper(obj2);
14171 if (arg3 == NULL) SWIG_fail;
14172 temp3 = true;
14173 }
14174 {
14175 PyThreadState* __tstate = wxPyBeginAllowThreads();
14176 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
14177 wxPyEndAllowThreads(__tstate);
14178 if (PyErr_Occurred()) SWIG_fail;
14179 }
14180 {
14181 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
14182 }
14183 {
14184 if (temp3)
14185 delete arg3;
14186 }
14187 return resultobj;
14188 fail:
14189 {
14190 if (temp3)
14191 delete arg3;
14192 }
14193 return NULL;
14194 }
14195
14196
14197 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14198 PyObject *obj;
14199 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14200 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
14201 return SWIG_Py_Void();
14202 }
14203
14204 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14205 return SWIG_Python_InitShadowInstance(args);
14206 }
14207
14208 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14209 PyObject *resultobj = 0;
14210 wxZipFSHandler *result = 0 ;
14211
14212 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
14213 {
14214 PyThreadState* __tstate = wxPyBeginAllowThreads();
14215 result = (wxZipFSHandler *)new wxZipFSHandler();
14216 wxPyEndAllowThreads(__tstate);
14217 if (PyErr_Occurred()) SWIG_fail;
14218 }
14219 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
14220 return resultobj;
14221 fail:
14222 return NULL;
14223 }
14224
14225
14226 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14227 PyObject *resultobj = 0;
14228 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
14229 wxString *arg2 = 0 ;
14230 bool result;
14231 void *argp1 = 0 ;
14232 int res1 = 0 ;
14233 bool temp2 = false ;
14234 PyObject * obj0 = 0 ;
14235 PyObject * obj1 = 0 ;
14236 char * kwnames[] = {
14237 (char *) "self",(char *) "location", NULL
14238 };
14239
14240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
14241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
14242 if (!SWIG_IsOK(res1)) {
14243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
14244 }
14245 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
14246 {
14247 arg2 = wxString_in_helper(obj1);
14248 if (arg2 == NULL) SWIG_fail;
14249 temp2 = true;
14250 }
14251 {
14252 PyThreadState* __tstate = wxPyBeginAllowThreads();
14253 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
14254 wxPyEndAllowThreads(__tstate);
14255 if (PyErr_Occurred()) SWIG_fail;
14256 }
14257 {
14258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14259 }
14260 {
14261 if (temp2)
14262 delete arg2;
14263 }
14264 return resultobj;
14265 fail:
14266 {
14267 if (temp2)
14268 delete arg2;
14269 }
14270 return NULL;
14271 }
14272
14273
14274 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14275 PyObject *resultobj = 0;
14276 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
14277 wxFileSystem *arg2 = 0 ;
14278 wxString *arg3 = 0 ;
14279 wxFSFile *result = 0 ;
14280 void *argp1 = 0 ;
14281 int res1 = 0 ;
14282 void *argp2 = 0 ;
14283 int res2 = 0 ;
14284 bool temp3 = false ;
14285 PyObject * obj0 = 0 ;
14286 PyObject * obj1 = 0 ;
14287 PyObject * obj2 = 0 ;
14288 char * kwnames[] = {
14289 (char *) "self",(char *) "fs",(char *) "location", NULL
14290 };
14291
14292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
14294 if (!SWIG_IsOK(res1)) {
14295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
14296 }
14297 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
14298 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
14299 if (!SWIG_IsOK(res2)) {
14300 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14301 }
14302 if (!argp2) {
14303 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14304 }
14305 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
14306 {
14307 arg3 = wxString_in_helper(obj2);
14308 if (arg3 == NULL) SWIG_fail;
14309 temp3 = true;
14310 }
14311 {
14312 PyThreadState* __tstate = wxPyBeginAllowThreads();
14313 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
14314 wxPyEndAllowThreads(__tstate);
14315 if (PyErr_Occurred()) SWIG_fail;
14316 }
14317 {
14318 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
14319 }
14320 {
14321 if (temp3)
14322 delete arg3;
14323 }
14324 return resultobj;
14325 fail:
14326 {
14327 if (temp3)
14328 delete arg3;
14329 }
14330 return NULL;
14331 }
14332
14333
14334 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14335 PyObject *resultobj = 0;
14336 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
14337 wxString *arg2 = 0 ;
14338 int arg3 = (int) 0 ;
14339 wxString result;
14340 void *argp1 = 0 ;
14341 int res1 = 0 ;
14342 bool temp2 = false ;
14343 int val3 ;
14344 int ecode3 = 0 ;
14345 PyObject * obj0 = 0 ;
14346 PyObject * obj1 = 0 ;
14347 PyObject * obj2 = 0 ;
14348 char * kwnames[] = {
14349 (char *) "self",(char *) "spec",(char *) "flags", NULL
14350 };
14351
14352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
14354 if (!SWIG_IsOK(res1)) {
14355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
14356 }
14357 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
14358 {
14359 arg2 = wxString_in_helper(obj1);
14360 if (arg2 == NULL) SWIG_fail;
14361 temp2 = true;
14362 }
14363 if (obj2) {
14364 ecode3 = SWIG_AsVal_int(obj2, &val3);
14365 if (!SWIG_IsOK(ecode3)) {
14366 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
14367 }
14368 arg3 = static_cast< int >(val3);
14369 }
14370 {
14371 PyThreadState* __tstate = wxPyBeginAllowThreads();
14372 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
14373 wxPyEndAllowThreads(__tstate);
14374 if (PyErr_Occurred()) SWIG_fail;
14375 }
14376 {
14377 #if wxUSE_UNICODE
14378 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14379 #else
14380 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14381 #endif
14382 }
14383 {
14384 if (temp2)
14385 delete arg2;
14386 }
14387 return resultobj;
14388 fail:
14389 {
14390 if (temp2)
14391 delete arg2;
14392 }
14393 return NULL;
14394 }
14395
14396
14397 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14398 PyObject *resultobj = 0;
14399 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
14400 wxString result;
14401 void *argp1 = 0 ;
14402 int res1 = 0 ;
14403 PyObject *swig_obj[1] ;
14404
14405 if (!args) SWIG_fail;
14406 swig_obj[0] = args;
14407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
14408 if (!SWIG_IsOK(res1)) {
14409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
14410 }
14411 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
14412 {
14413 PyThreadState* __tstate = wxPyBeginAllowThreads();
14414 result = (arg1)->FindNext();
14415 wxPyEndAllowThreads(__tstate);
14416 if (PyErr_Occurred()) SWIG_fail;
14417 }
14418 {
14419 #if wxUSE_UNICODE
14420 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14421 #else
14422 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14423 #endif
14424 }
14425 return resultobj;
14426 fail:
14427 return NULL;
14428 }
14429
14430
14431 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14432 PyObject *obj;
14433 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14434 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
14435 return SWIG_Py_Void();
14436 }
14437
14438 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14439 return SWIG_Python_InitShadowInstance(args);
14440 }
14441
14442 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14443 PyObject *resultobj = 0;
14444 wxString *arg1 = 0 ;
14445 wxImage *arg2 = 0 ;
14446 long arg3 ;
14447 bool temp1 = false ;
14448 void *argp2 = 0 ;
14449 int res2 = 0 ;
14450 long val3 ;
14451 int ecode3 = 0 ;
14452 PyObject * obj0 = 0 ;
14453 PyObject * obj1 = 0 ;
14454 PyObject * obj2 = 0 ;
14455 char * kwnames[] = {
14456 (char *) "filename",(char *) "image",(char *) "type", NULL
14457 };
14458
14459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14460 {
14461 arg1 = wxString_in_helper(obj0);
14462 if (arg1 == NULL) SWIG_fail;
14463 temp1 = true;
14464 }
14465 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
14466 if (!SWIG_IsOK(res2)) {
14467 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
14468 }
14469 if (!argp2) {
14470 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
14471 }
14472 arg2 = reinterpret_cast< wxImage * >(argp2);
14473 ecode3 = SWIG_AsVal_long(obj2, &val3);
14474 if (!SWIG_IsOK(ecode3)) {
14475 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
14476 }
14477 arg3 = static_cast< long >(val3);
14478 {
14479 PyThreadState* __tstate = wxPyBeginAllowThreads();
14480 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
14481 wxPyEndAllowThreads(__tstate);
14482 if (PyErr_Occurred()) SWIG_fail;
14483 }
14484 resultobj = SWIG_Py_Void();
14485 {
14486 if (temp1)
14487 delete arg1;
14488 }
14489 return resultobj;
14490 fail:
14491 {
14492 if (temp1)
14493 delete arg1;
14494 }
14495 return NULL;
14496 }
14497
14498
14499 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14500 PyObject *resultobj = 0;
14501 wxString *arg1 = 0 ;
14502 wxBitmap *arg2 = 0 ;
14503 long arg3 ;
14504 bool temp1 = false ;
14505 void *argp2 = 0 ;
14506 int res2 = 0 ;
14507 long val3 ;
14508 int ecode3 = 0 ;
14509 PyObject * obj0 = 0 ;
14510 PyObject * obj1 = 0 ;
14511 PyObject * obj2 = 0 ;
14512 char * kwnames[] = {
14513 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
14514 };
14515
14516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14517 {
14518 arg1 = wxString_in_helper(obj0);
14519 if (arg1 == NULL) SWIG_fail;
14520 temp1 = true;
14521 }
14522 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
14523 if (!SWIG_IsOK(res2)) {
14524 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
14525 }
14526 if (!argp2) {
14527 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
14528 }
14529 arg2 = reinterpret_cast< wxBitmap * >(argp2);
14530 ecode3 = SWIG_AsVal_long(obj2, &val3);
14531 if (!SWIG_IsOK(ecode3)) {
14532 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
14533 }
14534 arg3 = static_cast< long >(val3);
14535 {
14536 PyThreadState* __tstate = wxPyBeginAllowThreads();
14537 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
14538 wxPyEndAllowThreads(__tstate);
14539 if (PyErr_Occurred()) SWIG_fail;
14540 }
14541 resultobj = SWIG_Py_Void();
14542 {
14543 if (temp1)
14544 delete arg1;
14545 }
14546 return resultobj;
14547 fail:
14548 {
14549 if (temp1)
14550 delete arg1;
14551 }
14552 return NULL;
14553 }
14554
14555
14556 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14557 PyObject *resultobj = 0;
14558 wxString *arg1 = 0 ;
14559 PyObject *arg2 = (PyObject *) 0 ;
14560 bool temp1 = false ;
14561 PyObject * obj0 = 0 ;
14562 PyObject * obj1 = 0 ;
14563 char * kwnames[] = {
14564 (char *) "filename",(char *) "data", NULL
14565 };
14566
14567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
14568 {
14569 arg1 = wxString_in_helper(obj0);
14570 if (arg1 == NULL) SWIG_fail;
14571 temp1 = true;
14572 }
14573 arg2 = obj1;
14574 {
14575 PyThreadState* __tstate = wxPyBeginAllowThreads();
14576 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
14577 wxPyEndAllowThreads(__tstate);
14578 if (PyErr_Occurred()) SWIG_fail;
14579 }
14580 resultobj = SWIG_Py_Void();
14581 {
14582 if (temp1)
14583 delete arg1;
14584 }
14585 return resultobj;
14586 fail:
14587 {
14588 if (temp1)
14589 delete arg1;
14590 }
14591 return NULL;
14592 }
14593
14594
14595 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14596 PyObject *resultobj = 0;
14597 wxMemoryFSHandler *result = 0 ;
14598
14599 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
14600 {
14601 PyThreadState* __tstate = wxPyBeginAllowThreads();
14602 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
14603 wxPyEndAllowThreads(__tstate);
14604 if (PyErr_Occurred()) SWIG_fail;
14605 }
14606 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
14607 return resultobj;
14608 fail:
14609 return NULL;
14610 }
14611
14612
14613 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14614 PyObject *resultobj = 0;
14615 wxString *arg1 = 0 ;
14616 bool temp1 = false ;
14617 PyObject * obj0 = 0 ;
14618 char * kwnames[] = {
14619 (char *) "filename", NULL
14620 };
14621
14622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
14623 {
14624 arg1 = wxString_in_helper(obj0);
14625 if (arg1 == NULL) SWIG_fail;
14626 temp1 = true;
14627 }
14628 {
14629 PyThreadState* __tstate = wxPyBeginAllowThreads();
14630 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
14631 wxPyEndAllowThreads(__tstate);
14632 if (PyErr_Occurred()) SWIG_fail;
14633 }
14634 resultobj = SWIG_Py_Void();
14635 {
14636 if (temp1)
14637 delete arg1;
14638 }
14639 return resultobj;
14640 fail:
14641 {
14642 if (temp1)
14643 delete arg1;
14644 }
14645 return NULL;
14646 }
14647
14648
14649 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14650 PyObject *resultobj = 0;
14651 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14652 wxString *arg2 = 0 ;
14653 bool result;
14654 void *argp1 = 0 ;
14655 int res1 = 0 ;
14656 bool temp2 = false ;
14657 PyObject * obj0 = 0 ;
14658 PyObject * obj1 = 0 ;
14659 char * kwnames[] = {
14660 (char *) "self",(char *) "location", NULL
14661 };
14662
14663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
14664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14665 if (!SWIG_IsOK(res1)) {
14666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14667 }
14668 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14669 {
14670 arg2 = wxString_in_helper(obj1);
14671 if (arg2 == NULL) SWIG_fail;
14672 temp2 = true;
14673 }
14674 {
14675 PyThreadState* __tstate = wxPyBeginAllowThreads();
14676 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
14677 wxPyEndAllowThreads(__tstate);
14678 if (PyErr_Occurred()) SWIG_fail;
14679 }
14680 {
14681 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14682 }
14683 {
14684 if (temp2)
14685 delete arg2;
14686 }
14687 return resultobj;
14688 fail:
14689 {
14690 if (temp2)
14691 delete arg2;
14692 }
14693 return NULL;
14694 }
14695
14696
14697 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14698 PyObject *resultobj = 0;
14699 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14700 wxFileSystem *arg2 = 0 ;
14701 wxString *arg3 = 0 ;
14702 wxFSFile *result = 0 ;
14703 void *argp1 = 0 ;
14704 int res1 = 0 ;
14705 void *argp2 = 0 ;
14706 int res2 = 0 ;
14707 bool temp3 = false ;
14708 PyObject * obj0 = 0 ;
14709 PyObject * obj1 = 0 ;
14710 PyObject * obj2 = 0 ;
14711 char * kwnames[] = {
14712 (char *) "self",(char *) "fs",(char *) "location", NULL
14713 };
14714
14715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14717 if (!SWIG_IsOK(res1)) {
14718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14719 }
14720 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14721 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
14722 if (!SWIG_IsOK(res2)) {
14723 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14724 }
14725 if (!argp2) {
14726 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14727 }
14728 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
14729 {
14730 arg3 = wxString_in_helper(obj2);
14731 if (arg3 == NULL) SWIG_fail;
14732 temp3 = true;
14733 }
14734 {
14735 PyThreadState* __tstate = wxPyBeginAllowThreads();
14736 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
14737 wxPyEndAllowThreads(__tstate);
14738 if (PyErr_Occurred()) SWIG_fail;
14739 }
14740 {
14741 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
14742 }
14743 {
14744 if (temp3)
14745 delete arg3;
14746 }
14747 return resultobj;
14748 fail:
14749 {
14750 if (temp3)
14751 delete arg3;
14752 }
14753 return NULL;
14754 }
14755
14756
14757 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14758 PyObject *resultobj = 0;
14759 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14760 wxString *arg2 = 0 ;
14761 int arg3 = (int) 0 ;
14762 wxString result;
14763 void *argp1 = 0 ;
14764 int res1 = 0 ;
14765 bool temp2 = false ;
14766 int val3 ;
14767 int ecode3 = 0 ;
14768 PyObject * obj0 = 0 ;
14769 PyObject * obj1 = 0 ;
14770 PyObject * obj2 = 0 ;
14771 char * kwnames[] = {
14772 (char *) "self",(char *) "spec",(char *) "flags", NULL
14773 };
14774
14775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14777 if (!SWIG_IsOK(res1)) {
14778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14779 }
14780 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14781 {
14782 arg2 = wxString_in_helper(obj1);
14783 if (arg2 == NULL) SWIG_fail;
14784 temp2 = true;
14785 }
14786 if (obj2) {
14787 ecode3 = SWIG_AsVal_int(obj2, &val3);
14788 if (!SWIG_IsOK(ecode3)) {
14789 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
14790 }
14791 arg3 = static_cast< int >(val3);
14792 }
14793 {
14794 PyThreadState* __tstate = wxPyBeginAllowThreads();
14795 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
14796 wxPyEndAllowThreads(__tstate);
14797 if (PyErr_Occurred()) SWIG_fail;
14798 }
14799 {
14800 #if wxUSE_UNICODE
14801 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14802 #else
14803 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14804 #endif
14805 }
14806 {
14807 if (temp2)
14808 delete arg2;
14809 }
14810 return resultobj;
14811 fail:
14812 {
14813 if (temp2)
14814 delete arg2;
14815 }
14816 return NULL;
14817 }
14818
14819
14820 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14821 PyObject *resultobj = 0;
14822 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14823 wxString result;
14824 void *argp1 = 0 ;
14825 int res1 = 0 ;
14826 PyObject *swig_obj[1] ;
14827
14828 if (!args) SWIG_fail;
14829 swig_obj[0] = args;
14830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14831 if (!SWIG_IsOK(res1)) {
14832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14833 }
14834 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14835 {
14836 PyThreadState* __tstate = wxPyBeginAllowThreads();
14837 result = (arg1)->FindNext();
14838 wxPyEndAllowThreads(__tstate);
14839 if (PyErr_Occurred()) SWIG_fail;
14840 }
14841 {
14842 #if wxUSE_UNICODE
14843 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14844 #else
14845 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14846 #endif
14847 }
14848 return resultobj;
14849 fail:
14850 return NULL;
14851 }
14852
14853
14854 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14855 PyObject *obj;
14856 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14857 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
14858 return SWIG_Py_Void();
14859 }
14860
14861 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14862 return SWIG_Python_InitShadowInstance(args);
14863 }
14864
14865 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14866 PyObject *resultobj = 0;
14867 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14868 wxString result;
14869 void *argp1 = 0 ;
14870 int res1 = 0 ;
14871 PyObject *swig_obj[1] ;
14872
14873 if (!args) SWIG_fail;
14874 swig_obj[0] = args;
14875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14876 if (!SWIG_IsOK(res1)) {
14877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14878 }
14879 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14880 {
14881 PyThreadState* __tstate = wxPyBeginAllowThreads();
14882 result = (arg1)->GetName();
14883 wxPyEndAllowThreads(__tstate);
14884 if (PyErr_Occurred()) SWIG_fail;
14885 }
14886 {
14887 #if wxUSE_UNICODE
14888 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14889 #else
14890 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14891 #endif
14892 }
14893 return resultobj;
14894 fail:
14895 return NULL;
14896 }
14897
14898
14899 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14900 PyObject *resultobj = 0;
14901 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14902 wxString result;
14903 void *argp1 = 0 ;
14904 int res1 = 0 ;
14905 PyObject *swig_obj[1] ;
14906
14907 if (!args) SWIG_fail;
14908 swig_obj[0] = args;
14909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14910 if (!SWIG_IsOK(res1)) {
14911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14912 }
14913 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14914 {
14915 PyThreadState* __tstate = wxPyBeginAllowThreads();
14916 result = (arg1)->GetExtension();
14917 wxPyEndAllowThreads(__tstate);
14918 if (PyErr_Occurred()) SWIG_fail;
14919 }
14920 {
14921 #if wxUSE_UNICODE
14922 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14923 #else
14924 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14925 #endif
14926 }
14927 return resultobj;
14928 fail:
14929 return NULL;
14930 }
14931
14932
14933 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14934 PyObject *resultobj = 0;
14935 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14936 long result;
14937 void *argp1 = 0 ;
14938 int res1 = 0 ;
14939 PyObject *swig_obj[1] ;
14940
14941 if (!args) SWIG_fail;
14942 swig_obj[0] = args;
14943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14944 if (!SWIG_IsOK(res1)) {
14945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14946 }
14947 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14948 {
14949 PyThreadState* __tstate = wxPyBeginAllowThreads();
14950 result = (long)(arg1)->GetType();
14951 wxPyEndAllowThreads(__tstate);
14952 if (PyErr_Occurred()) SWIG_fail;
14953 }
14954 resultobj = SWIG_From_long(static_cast< long >(result));
14955 return resultobj;
14956 fail:
14957 return NULL;
14958 }
14959
14960
14961 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14962 PyObject *resultobj = 0;
14963 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14964 wxString result;
14965 void *argp1 = 0 ;
14966 int res1 = 0 ;
14967 PyObject *swig_obj[1] ;
14968
14969 if (!args) SWIG_fail;
14970 swig_obj[0] = args;
14971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14972 if (!SWIG_IsOK(res1)) {
14973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14974 }
14975 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14976 {
14977 PyThreadState* __tstate = wxPyBeginAllowThreads();
14978 result = (arg1)->GetMimeType();
14979 wxPyEndAllowThreads(__tstate);
14980 if (PyErr_Occurred()) SWIG_fail;
14981 }
14982 {
14983 #if wxUSE_UNICODE
14984 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14985 #else
14986 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14987 #endif
14988 }
14989 return resultobj;
14990 fail:
14991 return NULL;
14992 }
14993
14994
14995 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14996 PyObject *resultobj = 0;
14997 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14998 wxString *arg2 = 0 ;
14999 bool result;
15000 void *argp1 = 0 ;
15001 int res1 = 0 ;
15002 bool temp2 = false ;
15003 PyObject * obj0 = 0 ;
15004 PyObject * obj1 = 0 ;
15005 char * kwnames[] = {
15006 (char *) "self",(char *) "name", NULL
15007 };
15008
15009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
15010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
15011 if (!SWIG_IsOK(res1)) {
15012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
15013 }
15014 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
15015 {
15016 arg2 = wxString_in_helper(obj1);
15017 if (arg2 == NULL) SWIG_fail;
15018 temp2 = true;
15019 }
15020 {
15021 PyThreadState* __tstate = wxPyBeginAllowThreads();
15022 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
15023 wxPyEndAllowThreads(__tstate);
15024 if (PyErr_Occurred()) SWIG_fail;
15025 }
15026 {
15027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15028 }
15029 {
15030 if (temp2)
15031 delete arg2;
15032 }
15033 return resultobj;
15034 fail:
15035 {
15036 if (temp2)
15037 delete arg2;
15038 }
15039 return NULL;
15040 }
15041
15042
15043 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15044 PyObject *resultobj = 0;
15045 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
15046 wxInputStream *arg2 = 0 ;
15047 bool result;
15048 void *argp1 = 0 ;
15049 int res1 = 0 ;
15050 wxPyInputStream *temp2 ;
15051 bool created2 ;
15052 PyObject * obj0 = 0 ;
15053 PyObject * obj1 = 0 ;
15054 char * kwnames[] = {
15055 (char *) "self",(char *) "stream", NULL
15056 };
15057
15058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
15059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
15060 if (!SWIG_IsOK(res1)) {
15061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
15062 }
15063 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
15064 {
15065 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15066 arg2 = temp2->m_wxis;
15067 created2 = false;
15068 } else {
15069 PyErr_Clear(); // clear the failure of the wxPyConvert above
15070 arg2 = wxPyCBInputStream_create(obj1, false);
15071 if (arg2 == NULL) {
15072 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15073 SWIG_fail;
15074 }
15075 created2 = true;
15076 }
15077 }
15078 {
15079 PyThreadState* __tstate = wxPyBeginAllowThreads();
15080 result = (bool)(arg1)->CanRead(*arg2);
15081 wxPyEndAllowThreads(__tstate);
15082 if (PyErr_Occurred()) SWIG_fail;
15083 }
15084 {
15085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15086 }
15087 {
15088 if (created2) delete arg2;
15089 }
15090 return resultobj;
15091 fail:
15092 {
15093 if (created2) delete arg2;
15094 }
15095 return NULL;
15096 }
15097
15098
15099 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15100 PyObject *resultobj = 0;
15101 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
15102 wxString *arg2 = 0 ;
15103 void *argp1 = 0 ;
15104 int res1 = 0 ;
15105 bool temp2 = false ;
15106 PyObject * obj0 = 0 ;
15107 PyObject * obj1 = 0 ;
15108 char * kwnames[] = {
15109 (char *) "self",(char *) "name", NULL
15110 };
15111
15112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
15113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
15114 if (!SWIG_IsOK(res1)) {
15115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
15116 }
15117 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
15118 {
15119 arg2 = wxString_in_helper(obj1);
15120 if (arg2 == NULL) SWIG_fail;
15121 temp2 = true;
15122 }
15123 {
15124 PyThreadState* __tstate = wxPyBeginAllowThreads();
15125 (arg1)->SetName((wxString const &)*arg2);
15126 wxPyEndAllowThreads(__tstate);
15127 if (PyErr_Occurred()) SWIG_fail;
15128 }
15129 resultobj = SWIG_Py_Void();
15130 {
15131 if (temp2)
15132 delete arg2;
15133 }
15134 return resultobj;
15135 fail:
15136 {
15137 if (temp2)
15138 delete arg2;
15139 }
15140 return NULL;
15141 }
15142
15143
15144 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15145 PyObject *resultobj = 0;
15146 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
15147 wxString *arg2 = 0 ;
15148 void *argp1 = 0 ;
15149 int res1 = 0 ;
15150 bool temp2 = false ;
15151 PyObject * obj0 = 0 ;
15152 PyObject * obj1 = 0 ;
15153 char * kwnames[] = {
15154 (char *) "self",(char *) "extension", NULL
15155 };
15156
15157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
15158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
15159 if (!SWIG_IsOK(res1)) {
15160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
15161 }
15162 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
15163 {
15164 arg2 = wxString_in_helper(obj1);
15165 if (arg2 == NULL) SWIG_fail;
15166 temp2 = true;
15167 }
15168 {
15169 PyThreadState* __tstate = wxPyBeginAllowThreads();
15170 (arg1)->SetExtension((wxString const &)*arg2);
15171 wxPyEndAllowThreads(__tstate);
15172 if (PyErr_Occurred()) SWIG_fail;
15173 }
15174 resultobj = SWIG_Py_Void();
15175 {
15176 if (temp2)
15177 delete arg2;
15178 }
15179 return resultobj;
15180 fail:
15181 {
15182 if (temp2)
15183 delete arg2;
15184 }
15185 return NULL;
15186 }
15187
15188
15189 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15190 PyObject *resultobj = 0;
15191 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
15192 long arg2 ;
15193 void *argp1 = 0 ;
15194 int res1 = 0 ;
15195 long val2 ;
15196 int ecode2 = 0 ;
15197 PyObject * obj0 = 0 ;
15198 PyObject * obj1 = 0 ;
15199 char * kwnames[] = {
15200 (char *) "self",(char *) "type", NULL
15201 };
15202
15203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
15204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
15205 if (!SWIG_IsOK(res1)) {
15206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
15207 }
15208 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
15209 ecode2 = SWIG_AsVal_long(obj1, &val2);
15210 if (!SWIG_IsOK(ecode2)) {
15211 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
15212 }
15213 arg2 = static_cast< long >(val2);
15214 {
15215 PyThreadState* __tstate = wxPyBeginAllowThreads();
15216 (arg1)->SetType(arg2);
15217 wxPyEndAllowThreads(__tstate);
15218 if (PyErr_Occurred()) SWIG_fail;
15219 }
15220 resultobj = SWIG_Py_Void();
15221 return resultobj;
15222 fail:
15223 return NULL;
15224 }
15225
15226
15227 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15228 PyObject *resultobj = 0;
15229 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
15230 wxString *arg2 = 0 ;
15231 void *argp1 = 0 ;
15232 int res1 = 0 ;
15233 bool temp2 = false ;
15234 PyObject * obj0 = 0 ;
15235 PyObject * obj1 = 0 ;
15236 char * kwnames[] = {
15237 (char *) "self",(char *) "mimetype", NULL
15238 };
15239
15240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
15241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
15242 if (!SWIG_IsOK(res1)) {
15243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
15244 }
15245 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
15246 {
15247 arg2 = wxString_in_helper(obj1);
15248 if (arg2 == NULL) SWIG_fail;
15249 temp2 = true;
15250 }
15251 {
15252 PyThreadState* __tstate = wxPyBeginAllowThreads();
15253 (arg1)->SetMimeType((wxString const &)*arg2);
15254 wxPyEndAllowThreads(__tstate);
15255 if (PyErr_Occurred()) SWIG_fail;
15256 }
15257 resultobj = SWIG_Py_Void();
15258 {
15259 if (temp2)
15260 delete arg2;
15261 }
15262 return resultobj;
15263 fail:
15264 {
15265 if (temp2)
15266 delete arg2;
15267 }
15268 return NULL;
15269 }
15270
15271
15272 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15273 PyObject *obj;
15274 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15275 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
15276 return SWIG_Py_Void();
15277 }
15278
15279 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15280 PyObject *resultobj = 0;
15281 wxPyImageHandler *result = 0 ;
15282
15283 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
15284 {
15285 PyThreadState* __tstate = wxPyBeginAllowThreads();
15286 result = (wxPyImageHandler *)new wxPyImageHandler();
15287 wxPyEndAllowThreads(__tstate);
15288 if (PyErr_Occurred()) SWIG_fail;
15289 }
15290 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
15291 return resultobj;
15292 fail:
15293 return NULL;
15294 }
15295
15296
15297 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15298 PyObject *resultobj = 0;
15299 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
15300 PyObject *arg2 = (PyObject *) 0 ;
15301 void *argp1 = 0 ;
15302 int res1 = 0 ;
15303 PyObject * obj0 = 0 ;
15304 PyObject * obj1 = 0 ;
15305 char * kwnames[] = {
15306 (char *) "self",(char *) "self", NULL
15307 };
15308
15309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
15310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
15311 if (!SWIG_IsOK(res1)) {
15312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
15313 }
15314 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
15315 arg2 = obj1;
15316 {
15317 PyThreadState* __tstate = wxPyBeginAllowThreads();
15318 (arg1)->_SetSelf(arg2);
15319 wxPyEndAllowThreads(__tstate);
15320 if (PyErr_Occurred()) SWIG_fail;
15321 }
15322 resultobj = SWIG_Py_Void();
15323 return resultobj;
15324 fail:
15325 return NULL;
15326 }
15327
15328
15329 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15330 PyObject *obj;
15331 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15332 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
15333 return SWIG_Py_Void();
15334 }
15335
15336 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15337 return SWIG_Python_InitShadowInstance(args);
15338 }
15339
15340 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15341 PyObject *resultobj = 0;
15342 wxImageHistogram *result = 0 ;
15343
15344 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
15345 {
15346 PyThreadState* __tstate = wxPyBeginAllowThreads();
15347 result = (wxImageHistogram *)new wxImageHistogram();
15348 wxPyEndAllowThreads(__tstate);
15349 if (PyErr_Occurred()) SWIG_fail;
15350 }
15351 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
15352 return resultobj;
15353 fail:
15354 return NULL;
15355 }
15356
15357
15358 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15359 PyObject *resultobj = 0;
15360 byte arg1 ;
15361 byte arg2 ;
15362 byte arg3 ;
15363 unsigned long result;
15364 unsigned char val1 ;
15365 int ecode1 = 0 ;
15366 unsigned char val2 ;
15367 int ecode2 = 0 ;
15368 unsigned char val3 ;
15369 int ecode3 = 0 ;
15370 PyObject * obj0 = 0 ;
15371 PyObject * obj1 = 0 ;
15372 PyObject * obj2 = 0 ;
15373 char * kwnames[] = {
15374 (char *) "r",(char *) "g",(char *) "b", NULL
15375 };
15376
15377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15378 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
15379 if (!SWIG_IsOK(ecode1)) {
15380 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
15381 }
15382 arg1 = static_cast< byte >(val1);
15383 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15384 if (!SWIG_IsOK(ecode2)) {
15385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
15386 }
15387 arg2 = static_cast< byte >(val2);
15388 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15389 if (!SWIG_IsOK(ecode3)) {
15390 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
15391 }
15392 arg3 = static_cast< byte >(val3);
15393 {
15394 PyThreadState* __tstate = wxPyBeginAllowThreads();
15395 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
15396 wxPyEndAllowThreads(__tstate);
15397 if (PyErr_Occurred()) SWIG_fail;
15398 }
15399 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15400 return resultobj;
15401 fail:
15402 return NULL;
15403 }
15404
15405
15406 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15407 PyObject *resultobj = 0;
15408 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
15409 byte *arg2 = (byte *) 0 ;
15410 byte *arg3 = (byte *) 0 ;
15411 byte *arg4 = (byte *) 0 ;
15412 byte arg5 = (byte) 1 ;
15413 byte arg6 = (byte) 0 ;
15414 byte arg7 = (byte) 0 ;
15415 bool result;
15416 void *argp1 = 0 ;
15417 int res1 = 0 ;
15418 byte temp2 ;
15419 int res2 = SWIG_TMPOBJ ;
15420 byte temp3 ;
15421 int res3 = SWIG_TMPOBJ ;
15422 byte temp4 ;
15423 int res4 = SWIG_TMPOBJ ;
15424 unsigned char val5 ;
15425 int ecode5 = 0 ;
15426 unsigned char val6 ;
15427 int ecode6 = 0 ;
15428 unsigned char val7 ;
15429 int ecode7 = 0 ;
15430 PyObject * obj0 = 0 ;
15431 PyObject * obj1 = 0 ;
15432 PyObject * obj2 = 0 ;
15433 PyObject * obj3 = 0 ;
15434 char * kwnames[] = {
15435 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
15436 };
15437
15438 arg2 = &temp2;
15439 arg3 = &temp3;
15440 arg4 = &temp4;
15441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
15443 if (!SWIG_IsOK(res1)) {
15444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
15445 }
15446 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
15447 if (obj1) {
15448 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
15449 if (!SWIG_IsOK(ecode5)) {
15450 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
15451 }
15452 arg5 = static_cast< byte >(val5);
15453 }
15454 if (obj2) {
15455 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
15456 if (!SWIG_IsOK(ecode6)) {
15457 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
15458 }
15459 arg6 = static_cast< byte >(val6);
15460 }
15461 if (obj3) {
15462 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
15463 if (!SWIG_IsOK(ecode7)) {
15464 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
15465 }
15466 arg7 = static_cast< byte >(val7);
15467 }
15468 {
15469 PyThreadState* __tstate = wxPyBeginAllowThreads();
15470 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
15471 wxPyEndAllowThreads(__tstate);
15472 if (PyErr_Occurred()) SWIG_fail;
15473 }
15474 {
15475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15476 }
15477 if (SWIG_IsTmpObj(res2)) {
15478 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15479 } else {
15480 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15481 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15482 }
15483 if (SWIG_IsTmpObj(res3)) {
15484 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15485 } else {
15486 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15487 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15488 }
15489 if (SWIG_IsTmpObj(res4)) {
15490 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15491 } else {
15492 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15493 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15494 }
15495 return resultobj;
15496 fail:
15497 return NULL;
15498 }
15499
15500
15501 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15502 PyObject *resultobj = 0;
15503 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
15504 unsigned long arg2 ;
15505 unsigned long result;
15506 void *argp1 = 0 ;
15507 int res1 = 0 ;
15508 unsigned long val2 ;
15509 int ecode2 = 0 ;
15510 PyObject * obj0 = 0 ;
15511 PyObject * obj1 = 0 ;
15512 char * kwnames[] = {
15513 (char *) "self",(char *) "key", NULL
15514 };
15515
15516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
15517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
15518 if (!SWIG_IsOK(res1)) {
15519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
15520 }
15521 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
15522 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
15523 if (!SWIG_IsOK(ecode2)) {
15524 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
15525 }
15526 arg2 = static_cast< unsigned long >(val2);
15527 {
15528 PyThreadState* __tstate = wxPyBeginAllowThreads();
15529 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
15530 wxPyEndAllowThreads(__tstate);
15531 if (PyErr_Occurred()) SWIG_fail;
15532 }
15533 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15534 return resultobj;
15535 fail:
15536 return NULL;
15537 }
15538
15539
15540 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15541 PyObject *resultobj = 0;
15542 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
15543 byte arg2 ;
15544 byte arg3 ;
15545 byte arg4 ;
15546 unsigned long result;
15547 void *argp1 = 0 ;
15548 int res1 = 0 ;
15549 unsigned char val2 ;
15550 int ecode2 = 0 ;
15551 unsigned char val3 ;
15552 int ecode3 = 0 ;
15553 unsigned char val4 ;
15554 int ecode4 = 0 ;
15555 PyObject * obj0 = 0 ;
15556 PyObject * obj1 = 0 ;
15557 PyObject * obj2 = 0 ;
15558 PyObject * obj3 = 0 ;
15559 char * kwnames[] = {
15560 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15561 };
15562
15563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
15565 if (!SWIG_IsOK(res1)) {
15566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
15567 }
15568 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
15569 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15570 if (!SWIG_IsOK(ecode2)) {
15571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
15572 }
15573 arg2 = static_cast< byte >(val2);
15574 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15575 if (!SWIG_IsOK(ecode3)) {
15576 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
15577 }
15578 arg3 = static_cast< byte >(val3);
15579 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15580 if (!SWIG_IsOK(ecode4)) {
15581 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
15582 }
15583 arg4 = static_cast< byte >(val4);
15584 {
15585 PyThreadState* __tstate = wxPyBeginAllowThreads();
15586 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
15587 wxPyEndAllowThreads(__tstate);
15588 if (PyErr_Occurred()) SWIG_fail;
15589 }
15590 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15591 return resultobj;
15592 fail:
15593 return NULL;
15594 }
15595
15596
15597 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15598 PyObject *resultobj = 0;
15599 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
15600 wxColour *arg2 = 0 ;
15601 unsigned long result;
15602 void *argp1 = 0 ;
15603 int res1 = 0 ;
15604 wxColour temp2 ;
15605 PyObject * obj0 = 0 ;
15606 PyObject * obj1 = 0 ;
15607 char * kwnames[] = {
15608 (char *) "self",(char *) "colour", NULL
15609 };
15610
15611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
15612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
15613 if (!SWIG_IsOK(res1)) {
15614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
15615 }
15616 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
15617 {
15618 arg2 = &temp2;
15619 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
15620 }
15621 {
15622 PyThreadState* __tstate = wxPyBeginAllowThreads();
15623 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
15624 wxPyEndAllowThreads(__tstate);
15625 if (PyErr_Occurred()) SWIG_fail;
15626 }
15627 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15628 return resultobj;
15629 fail:
15630 return NULL;
15631 }
15632
15633
15634 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15635 PyObject *obj;
15636 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15637 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
15638 return SWIG_Py_Void();
15639 }
15640
15641 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15642 return SWIG_Python_InitShadowInstance(args);
15643 }
15644
15645 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15646 PyObject *resultobj = 0;
15647 byte arg1 = (byte) 0 ;
15648 byte arg2 = (byte) 0 ;
15649 byte arg3 = (byte) 0 ;
15650 wxImage_RGBValue *result = 0 ;
15651 unsigned char val1 ;
15652 int ecode1 = 0 ;
15653 unsigned char val2 ;
15654 int ecode2 = 0 ;
15655 unsigned char val3 ;
15656 int ecode3 = 0 ;
15657 PyObject * obj0 = 0 ;
15658 PyObject * obj1 = 0 ;
15659 PyObject * obj2 = 0 ;
15660 char * kwnames[] = {
15661 (char *) "r",(char *) "g",(char *) "b", NULL
15662 };
15663
15664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15665 if (obj0) {
15666 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
15667 if (!SWIG_IsOK(ecode1)) {
15668 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
15669 }
15670 arg1 = static_cast< byte >(val1);
15671 }
15672 if (obj1) {
15673 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15674 if (!SWIG_IsOK(ecode2)) {
15675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
15676 }
15677 arg2 = static_cast< byte >(val2);
15678 }
15679 if (obj2) {
15680 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15681 if (!SWIG_IsOK(ecode3)) {
15682 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
15683 }
15684 arg3 = static_cast< byte >(val3);
15685 }
15686 {
15687 PyThreadState* __tstate = wxPyBeginAllowThreads();
15688 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
15689 wxPyEndAllowThreads(__tstate);
15690 if (PyErr_Occurred()) SWIG_fail;
15691 }
15692 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
15693 return resultobj;
15694 fail:
15695 return NULL;
15696 }
15697
15698
15699 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15700 PyObject *resultobj = 0;
15701 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15702 byte arg2 ;
15703 void *argp1 = 0 ;
15704 int res1 = 0 ;
15705 unsigned char val2 ;
15706 int ecode2 = 0 ;
15707 PyObject *swig_obj[2] ;
15708
15709 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
15710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15711 if (!SWIG_IsOK(res1)) {
15712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15713 }
15714 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15715 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15716 if (!SWIG_IsOK(ecode2)) {
15717 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
15718 }
15719 arg2 = static_cast< byte >(val2);
15720 if (arg1) (arg1)->red = arg2;
15721
15722 resultobj = SWIG_Py_Void();
15723 return resultobj;
15724 fail:
15725 return NULL;
15726 }
15727
15728
15729 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15730 PyObject *resultobj = 0;
15731 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15732 byte result;
15733 void *argp1 = 0 ;
15734 int res1 = 0 ;
15735 PyObject *swig_obj[1] ;
15736
15737 if (!args) SWIG_fail;
15738 swig_obj[0] = args;
15739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15740 if (!SWIG_IsOK(res1)) {
15741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15742 }
15743 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15744 result = (byte) ((arg1)->red);
15745 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15746 return resultobj;
15747 fail:
15748 return NULL;
15749 }
15750
15751
15752 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15753 PyObject *resultobj = 0;
15754 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15755 byte arg2 ;
15756 void *argp1 = 0 ;
15757 int res1 = 0 ;
15758 unsigned char val2 ;
15759 int ecode2 = 0 ;
15760 PyObject *swig_obj[2] ;
15761
15762 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
15763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15764 if (!SWIG_IsOK(res1)) {
15765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15766 }
15767 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15768 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15769 if (!SWIG_IsOK(ecode2)) {
15770 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
15771 }
15772 arg2 = static_cast< byte >(val2);
15773 if (arg1) (arg1)->green = arg2;
15774
15775 resultobj = SWIG_Py_Void();
15776 return resultobj;
15777 fail:
15778 return NULL;
15779 }
15780
15781
15782 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15783 PyObject *resultobj = 0;
15784 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15785 byte result;
15786 void *argp1 = 0 ;
15787 int res1 = 0 ;
15788 PyObject *swig_obj[1] ;
15789
15790 if (!args) SWIG_fail;
15791 swig_obj[0] = args;
15792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15793 if (!SWIG_IsOK(res1)) {
15794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15795 }
15796 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15797 result = (byte) ((arg1)->green);
15798 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15799 return resultobj;
15800 fail:
15801 return NULL;
15802 }
15803
15804
15805 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15806 PyObject *resultobj = 0;
15807 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15808 byte arg2 ;
15809 void *argp1 = 0 ;
15810 int res1 = 0 ;
15811 unsigned char val2 ;
15812 int ecode2 = 0 ;
15813 PyObject *swig_obj[2] ;
15814
15815 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
15816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15817 if (!SWIG_IsOK(res1)) {
15818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15819 }
15820 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15821 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15822 if (!SWIG_IsOK(ecode2)) {
15823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
15824 }
15825 arg2 = static_cast< byte >(val2);
15826 if (arg1) (arg1)->blue = arg2;
15827
15828 resultobj = SWIG_Py_Void();
15829 return resultobj;
15830 fail:
15831 return NULL;
15832 }
15833
15834
15835 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15836 PyObject *resultobj = 0;
15837 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15838 byte result;
15839 void *argp1 = 0 ;
15840 int res1 = 0 ;
15841 PyObject *swig_obj[1] ;
15842
15843 if (!args) SWIG_fail;
15844 swig_obj[0] = args;
15845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15846 if (!SWIG_IsOK(res1)) {
15847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15848 }
15849 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15850 result = (byte) ((arg1)->blue);
15851 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15852 return resultobj;
15853 fail:
15854 return NULL;
15855 }
15856
15857
15858 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15859 PyObject *obj;
15860 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15861 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
15862 return SWIG_Py_Void();
15863 }
15864
15865 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15866 return SWIG_Python_InitShadowInstance(args);
15867 }
15868
15869 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15870 PyObject *resultobj = 0;
15871 double arg1 = (double) 0.0 ;
15872 double arg2 = (double) 0.0 ;
15873 double arg3 = (double) 0.0 ;
15874 wxImage_HSVValue *result = 0 ;
15875 double val1 ;
15876 int ecode1 = 0 ;
15877 double val2 ;
15878 int ecode2 = 0 ;
15879 double val3 ;
15880 int ecode3 = 0 ;
15881 PyObject * obj0 = 0 ;
15882 PyObject * obj1 = 0 ;
15883 PyObject * obj2 = 0 ;
15884 char * kwnames[] = {
15885 (char *) "h",(char *) "s",(char *) "v", NULL
15886 };
15887
15888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15889 if (obj0) {
15890 ecode1 = SWIG_AsVal_double(obj0, &val1);
15891 if (!SWIG_IsOK(ecode1)) {
15892 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
15893 }
15894 arg1 = static_cast< double >(val1);
15895 }
15896 if (obj1) {
15897 ecode2 = SWIG_AsVal_double(obj1, &val2);
15898 if (!SWIG_IsOK(ecode2)) {
15899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
15900 }
15901 arg2 = static_cast< double >(val2);
15902 }
15903 if (obj2) {
15904 ecode3 = SWIG_AsVal_double(obj2, &val3);
15905 if (!SWIG_IsOK(ecode3)) {
15906 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
15907 }
15908 arg3 = static_cast< double >(val3);
15909 }
15910 {
15911 PyThreadState* __tstate = wxPyBeginAllowThreads();
15912 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
15913 wxPyEndAllowThreads(__tstate);
15914 if (PyErr_Occurred()) SWIG_fail;
15915 }
15916 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
15917 return resultobj;
15918 fail:
15919 return NULL;
15920 }
15921
15922
15923 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15924 PyObject *resultobj = 0;
15925 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15926 double arg2 ;
15927 void *argp1 = 0 ;
15928 int res1 = 0 ;
15929 double val2 ;
15930 int ecode2 = 0 ;
15931 PyObject *swig_obj[2] ;
15932
15933 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
15934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15935 if (!SWIG_IsOK(res1)) {
15936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15937 }
15938 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15939 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15940 if (!SWIG_IsOK(ecode2)) {
15941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
15942 }
15943 arg2 = static_cast< double >(val2);
15944 if (arg1) (arg1)->hue = arg2;
15945
15946 resultobj = SWIG_Py_Void();
15947 return resultobj;
15948 fail:
15949 return NULL;
15950 }
15951
15952
15953 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15954 PyObject *resultobj = 0;
15955 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15956 double result;
15957 void *argp1 = 0 ;
15958 int res1 = 0 ;
15959 PyObject *swig_obj[1] ;
15960
15961 if (!args) SWIG_fail;
15962 swig_obj[0] = args;
15963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15964 if (!SWIG_IsOK(res1)) {
15965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15966 }
15967 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15968 result = (double) ((arg1)->hue);
15969 resultobj = SWIG_From_double(static_cast< double >(result));
15970 return resultobj;
15971 fail:
15972 return NULL;
15973 }
15974
15975
15976 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15977 PyObject *resultobj = 0;
15978 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15979 double arg2 ;
15980 void *argp1 = 0 ;
15981 int res1 = 0 ;
15982 double val2 ;
15983 int ecode2 = 0 ;
15984 PyObject *swig_obj[2] ;
15985
15986 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
15987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15988 if (!SWIG_IsOK(res1)) {
15989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15990 }
15991 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15992 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15993 if (!SWIG_IsOK(ecode2)) {
15994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
15995 }
15996 arg2 = static_cast< double >(val2);
15997 if (arg1) (arg1)->saturation = arg2;
15998
15999 resultobj = SWIG_Py_Void();
16000 return resultobj;
16001 fail:
16002 return NULL;
16003 }
16004
16005
16006 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16007 PyObject *resultobj = 0;
16008 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
16009 double result;
16010 void *argp1 = 0 ;
16011 int res1 = 0 ;
16012 PyObject *swig_obj[1] ;
16013
16014 if (!args) SWIG_fail;
16015 swig_obj[0] = args;
16016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
16017 if (!SWIG_IsOK(res1)) {
16018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
16019 }
16020 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
16021 result = (double) ((arg1)->saturation);
16022 resultobj = SWIG_From_double(static_cast< double >(result));
16023 return resultobj;
16024 fail:
16025 return NULL;
16026 }
16027
16028
16029 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16030 PyObject *resultobj = 0;
16031 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
16032 double arg2 ;
16033 void *argp1 = 0 ;
16034 int res1 = 0 ;
16035 double val2 ;
16036 int ecode2 = 0 ;
16037 PyObject *swig_obj[2] ;
16038
16039 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
16040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
16041 if (!SWIG_IsOK(res1)) {
16042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
16043 }
16044 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
16045 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
16046 if (!SWIG_IsOK(ecode2)) {
16047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
16048 }
16049 arg2 = static_cast< double >(val2);
16050 if (arg1) (arg1)->value = arg2;
16051
16052 resultobj = SWIG_Py_Void();
16053 return resultobj;
16054 fail:
16055 return NULL;
16056 }
16057
16058
16059 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16060 PyObject *resultobj = 0;
16061 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
16062 double result;
16063 void *argp1 = 0 ;
16064 int res1 = 0 ;
16065 PyObject *swig_obj[1] ;
16066
16067 if (!args) SWIG_fail;
16068 swig_obj[0] = args;
16069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
16070 if (!SWIG_IsOK(res1)) {
16071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
16072 }
16073 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
16074 result = (double) ((arg1)->value);
16075 resultobj = SWIG_From_double(static_cast< double >(result));
16076 return resultobj;
16077 fail:
16078 return NULL;
16079 }
16080
16081
16082 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16083 PyObject *obj;
16084 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16085 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
16086 return SWIG_Py_Void();
16087 }
16088
16089 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16090 return SWIG_Python_InitShadowInstance(args);
16091 }
16092
16093 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16094 PyObject *resultobj = 0;
16095 wxString *arg1 = 0 ;
16096 long arg2 = (long) wxBITMAP_TYPE_ANY ;
16097 int arg3 = (int) -1 ;
16098 wxImage *result = 0 ;
16099 bool temp1 = false ;
16100 long val2 ;
16101 int ecode2 = 0 ;
16102 int val3 ;
16103 int ecode3 = 0 ;
16104 PyObject * obj0 = 0 ;
16105 PyObject * obj1 = 0 ;
16106 PyObject * obj2 = 0 ;
16107 char * kwnames[] = {
16108 (char *) "name",(char *) "type",(char *) "index", NULL
16109 };
16110
16111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16112 {
16113 arg1 = wxString_in_helper(obj0);
16114 if (arg1 == NULL) SWIG_fail;
16115 temp1 = true;
16116 }
16117 if (obj1) {
16118 ecode2 = SWIG_AsVal_long(obj1, &val2);
16119 if (!SWIG_IsOK(ecode2)) {
16120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
16121 }
16122 arg2 = static_cast< long >(val2);
16123 }
16124 if (obj2) {
16125 ecode3 = SWIG_AsVal_int(obj2, &val3);
16126 if (!SWIG_IsOK(ecode3)) {
16127 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
16128 }
16129 arg3 = static_cast< int >(val3);
16130 }
16131 {
16132 PyThreadState* __tstate = wxPyBeginAllowThreads();
16133 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
16134 wxPyEndAllowThreads(__tstate);
16135 if (PyErr_Occurred()) SWIG_fail;
16136 }
16137 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
16138 {
16139 if (temp1)
16140 delete arg1;
16141 }
16142 return resultobj;
16143 fail:
16144 {
16145 if (temp1)
16146 delete arg1;
16147 }
16148 return NULL;
16149 }
16150
16151
16152 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16153 PyObject *resultobj = 0;
16154 wxImage *arg1 = (wxImage *) 0 ;
16155 void *argp1 = 0 ;
16156 int res1 = 0 ;
16157 PyObject *swig_obj[1] ;
16158
16159 if (!args) SWIG_fail;
16160 swig_obj[0] = args;
16161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
16162 if (!SWIG_IsOK(res1)) {
16163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
16164 }
16165 arg1 = reinterpret_cast< wxImage * >(argp1);
16166 {
16167 PyThreadState* __tstate = wxPyBeginAllowThreads();
16168 delete arg1;
16169
16170 wxPyEndAllowThreads(__tstate);
16171 if (PyErr_Occurred()) SWIG_fail;
16172 }
16173 resultobj = SWIG_Py_Void();
16174 return resultobj;
16175 fail:
16176 return NULL;
16177 }
16178
16179
16180 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16181 PyObject *resultobj = 0;
16182 wxString *arg1 = 0 ;
16183 wxString *arg2 = 0 ;
16184 int arg3 = (int) -1 ;
16185 wxImage *result = 0 ;
16186 bool temp1 = false ;
16187 bool temp2 = false ;
16188 int val3 ;
16189 int ecode3 = 0 ;
16190 PyObject * obj0 = 0 ;
16191 PyObject * obj1 = 0 ;
16192 PyObject * obj2 = 0 ;
16193 char * kwnames[] = {
16194 (char *) "name",(char *) "mimetype",(char *) "index", NULL
16195 };
16196
16197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16198 {
16199 arg1 = wxString_in_helper(obj0);
16200 if (arg1 == NULL) SWIG_fail;
16201 temp1 = true;
16202 }
16203 {
16204 arg2 = wxString_in_helper(obj1);
16205 if (arg2 == NULL) SWIG_fail;
16206 temp2 = true;
16207 }
16208 if (obj2) {
16209 ecode3 = SWIG_AsVal_int(obj2, &val3);
16210 if (!SWIG_IsOK(ecode3)) {
16211 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
16212 }
16213 arg3 = static_cast< int >(val3);
16214 }
16215 {
16216 PyThreadState* __tstate = wxPyBeginAllowThreads();
16217 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
16218 wxPyEndAllowThreads(__tstate);
16219 if (PyErr_Occurred()) SWIG_fail;
16220 }
16221 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16222 {
16223 if (temp1)
16224 delete arg1;
16225 }
16226 {
16227 if (temp2)
16228 delete arg2;
16229 }
16230 return resultobj;
16231 fail:
16232 {
16233 if (temp1)
16234 delete arg1;
16235 }
16236 {
16237 if (temp2)
16238 delete arg2;
16239 }
16240 return NULL;
16241 }
16242
16243
16244 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16245 PyObject *resultobj = 0;
16246 wxInputStream *arg1 = 0 ;
16247 long arg2 = (long) wxBITMAP_TYPE_ANY ;
16248 int arg3 = (int) -1 ;
16249 wxImage *result = 0 ;
16250 wxPyInputStream *temp1 ;
16251 bool created1 ;
16252 long val2 ;
16253 int ecode2 = 0 ;
16254 int val3 ;
16255 int ecode3 = 0 ;
16256 PyObject * obj0 = 0 ;
16257 PyObject * obj1 = 0 ;
16258 PyObject * obj2 = 0 ;
16259 char * kwnames[] = {
16260 (char *) "stream",(char *) "type",(char *) "index", NULL
16261 };
16262
16263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16264 {
16265 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
16266 arg1 = temp1->m_wxis;
16267 created1 = false;
16268 } else {
16269 PyErr_Clear(); // clear the failure of the wxPyConvert above
16270 arg1 = wxPyCBInputStream_create(obj0, false);
16271 if (arg1 == NULL) {
16272 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
16273 SWIG_fail;
16274 }
16275 created1 = true;
16276 }
16277 }
16278 if (obj1) {
16279 ecode2 = SWIG_AsVal_long(obj1, &val2);
16280 if (!SWIG_IsOK(ecode2)) {
16281 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
16282 }
16283 arg2 = static_cast< long >(val2);
16284 }
16285 if (obj2) {
16286 ecode3 = SWIG_AsVal_int(obj2, &val3);
16287 if (!SWIG_IsOK(ecode3)) {
16288 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
16289 }
16290 arg3 = static_cast< int >(val3);
16291 }
16292 {
16293 PyThreadState* __tstate = wxPyBeginAllowThreads();
16294 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
16295 wxPyEndAllowThreads(__tstate);
16296 if (PyErr_Occurred()) SWIG_fail;
16297 }
16298 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16299 {
16300 if (created1) delete arg1;
16301 }
16302 return resultobj;
16303 fail:
16304 {
16305 if (created1) delete arg1;
16306 }
16307 return NULL;
16308 }
16309
16310
16311 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16312 PyObject *resultobj = 0;
16313 wxInputStream *arg1 = 0 ;
16314 wxString *arg2 = 0 ;
16315 int arg3 = (int) -1 ;
16316 wxImage *result = 0 ;
16317 wxPyInputStream *temp1 ;
16318 bool created1 ;
16319 bool temp2 = false ;
16320 int val3 ;
16321 int ecode3 = 0 ;
16322 PyObject * obj0 = 0 ;
16323 PyObject * obj1 = 0 ;
16324 PyObject * obj2 = 0 ;
16325 char * kwnames[] = {
16326 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
16327 };
16328
16329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16330 {
16331 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
16332 arg1 = temp1->m_wxis;
16333 created1 = false;
16334 } else {
16335 PyErr_Clear(); // clear the failure of the wxPyConvert above
16336 arg1 = wxPyCBInputStream_create(obj0, false);
16337 if (arg1 == NULL) {
16338 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
16339 SWIG_fail;
16340 }
16341 created1 = true;
16342 }
16343 }
16344 {
16345 arg2 = wxString_in_helper(obj1);
16346 if (arg2 == NULL) SWIG_fail;
16347 temp2 = true;
16348 }
16349 if (obj2) {
16350 ecode3 = SWIG_AsVal_int(obj2, &val3);
16351 if (!SWIG_IsOK(ecode3)) {
16352 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
16353 }
16354 arg3 = static_cast< int >(val3);
16355 }
16356 {
16357 PyThreadState* __tstate = wxPyBeginAllowThreads();
16358 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
16359 wxPyEndAllowThreads(__tstate);
16360 if (PyErr_Occurred()) SWIG_fail;
16361 }
16362 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16363 {
16364 if (created1) delete arg1;
16365 }
16366 {
16367 if (temp2)
16368 delete arg2;
16369 }
16370 return resultobj;
16371 fail:
16372 {
16373 if (created1) delete arg1;
16374 }
16375 {
16376 if (temp2)
16377 delete arg2;
16378 }
16379 return NULL;
16380 }
16381
16382
16383 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16384 PyObject *resultobj = 0;
16385 int arg1 = (int) 0 ;
16386 int arg2 = (int) 0 ;
16387 bool arg3 = (bool) true ;
16388 wxImage *result = 0 ;
16389 int val1 ;
16390 int ecode1 = 0 ;
16391 int val2 ;
16392 int ecode2 = 0 ;
16393 bool val3 ;
16394 int ecode3 = 0 ;
16395 PyObject * obj0 = 0 ;
16396 PyObject * obj1 = 0 ;
16397 PyObject * obj2 = 0 ;
16398 char * kwnames[] = {
16399 (char *) "width",(char *) "height",(char *) "clear", NULL
16400 };
16401
16402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16403 if (obj0) {
16404 ecode1 = SWIG_AsVal_int(obj0, &val1);
16405 if (!SWIG_IsOK(ecode1)) {
16406 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
16407 }
16408 arg1 = static_cast< int >(val1);
16409 }
16410 if (obj1) {
16411 ecode2 = SWIG_AsVal_int(obj1, &val2);
16412 if (!SWIG_IsOK(ecode2)) {
16413 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
16414 }
16415 arg2 = static_cast< int >(val2);
16416 }
16417 if (obj2) {
16418 ecode3 = SWIG_AsVal_bool(obj2, &val3);
16419 if (!SWIG_IsOK(ecode3)) {
16420 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
16421 }
16422 arg3 = static_cast< bool >(val3);
16423 }
16424 {
16425 PyThreadState* __tstate = wxPyBeginAllowThreads();
16426 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
16427 wxPyEndAllowThreads(__tstate);
16428 if (PyErr_Occurred()) SWIG_fail;
16429 }
16430 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16431 return resultobj;
16432 fail:
16433 return NULL;
16434 }
16435
16436
16437 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16438 PyObject *resultobj = 0;
16439 wxBitmap *arg1 = 0 ;
16440 wxImage *result = 0 ;
16441 void *argp1 = 0 ;
16442 int res1 = 0 ;
16443 PyObject * obj0 = 0 ;
16444 char * kwnames[] = {
16445 (char *) "bitmap", NULL
16446 };
16447
16448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
16449 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
16450 if (!SWIG_IsOK(res1)) {
16451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
16452 }
16453 if (!argp1) {
16454 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
16455 }
16456 arg1 = reinterpret_cast< wxBitmap * >(argp1);
16457 {
16458 if (!wxPyCheckForApp()) SWIG_fail;
16459 PyThreadState* __tstate = wxPyBeginAllowThreads();
16460 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
16461 wxPyEndAllowThreads(__tstate);
16462 if (PyErr_Occurred()) SWIG_fail;
16463 }
16464 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16465 return resultobj;
16466 fail:
16467 return NULL;
16468 }
16469
16470
16471 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16472 PyObject *resultobj = 0;
16473 int arg1 ;
16474 int arg2 ;
16475 buffer arg3 ;
16476 int arg4 ;
16477 wxImage *result = 0 ;
16478 int val1 ;
16479 int ecode1 = 0 ;
16480 int val2 ;
16481 int ecode2 = 0 ;
16482 Py_ssize_t temp3 ;
16483 PyObject * obj0 = 0 ;
16484 PyObject * obj1 = 0 ;
16485 PyObject * obj2 = 0 ;
16486 char * kwnames[] = {
16487 (char *) "width",(char *) "height",(char *) "data", NULL
16488 };
16489
16490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16491 ecode1 = SWIG_AsVal_int(obj0, &val1);
16492 if (!SWIG_IsOK(ecode1)) {
16493 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
16494 }
16495 arg1 = static_cast< int >(val1);
16496 ecode2 = SWIG_AsVal_int(obj1, &val2);
16497 if (!SWIG_IsOK(ecode2)) {
16498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
16499 }
16500 arg2 = static_cast< int >(val2);
16501 {
16502 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
16503 arg4 = (int)temp3;
16504 }
16505 {
16506 PyThreadState* __tstate = wxPyBeginAllowThreads();
16507 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
16508 wxPyEndAllowThreads(__tstate);
16509 if (PyErr_Occurred()) SWIG_fail;
16510 }
16511 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16512 return resultobj;
16513 fail:
16514 return NULL;
16515 }
16516
16517
16518 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16519 PyObject *resultobj = 0;
16520 int arg1 ;
16521 int arg2 ;
16522 buffer arg3 ;
16523 int arg4 ;
16524 buffer arg5 ;
16525 int arg6 ;
16526 wxImage *result = 0 ;
16527 int val1 ;
16528 int ecode1 = 0 ;
16529 int val2 ;
16530 int ecode2 = 0 ;
16531 Py_ssize_t temp3 ;
16532 Py_ssize_t temp5 ;
16533 PyObject * obj0 = 0 ;
16534 PyObject * obj1 = 0 ;
16535 PyObject * obj2 = 0 ;
16536 PyObject * obj3 = 0 ;
16537 char * kwnames[] = {
16538 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
16539 };
16540
16541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16542 ecode1 = SWIG_AsVal_int(obj0, &val1);
16543 if (!SWIG_IsOK(ecode1)) {
16544 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
16545 }
16546 arg1 = static_cast< int >(val1);
16547 ecode2 = SWIG_AsVal_int(obj1, &val2);
16548 if (!SWIG_IsOK(ecode2)) {
16549 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
16550 }
16551 arg2 = static_cast< int >(val2);
16552 {
16553 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
16554 arg4 = (int)temp3;
16555 }
16556 {
16557 if (obj3 != Py_None) {
16558 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
16559 arg6 = (int)temp5;
16560 }
16561 }
16562 {
16563 PyThreadState* __tstate = wxPyBeginAllowThreads();
16564 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
16565 wxPyEndAllowThreads(__tstate);
16566 if (PyErr_Occurred()) SWIG_fail;
16567 }
16568 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16569 return resultobj;
16570 fail:
16571 return NULL;
16572 }
16573
16574
16575 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16576 PyObject *resultobj = 0;
16577 wxImage *arg1 = (wxImage *) 0 ;
16578 int arg2 ;
16579 int arg3 ;
16580 bool arg4 = (bool) true ;
16581 void *argp1 = 0 ;
16582 int res1 = 0 ;
16583 int val2 ;
16584 int ecode2 = 0 ;
16585 int val3 ;
16586 int ecode3 = 0 ;
16587 bool val4 ;
16588 int ecode4 = 0 ;
16589 PyObject * obj0 = 0 ;
16590 PyObject * obj1 = 0 ;
16591 PyObject * obj2 = 0 ;
16592 PyObject * obj3 = 0 ;
16593 char * kwnames[] = {
16594 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
16595 };
16596
16597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16599 if (!SWIG_IsOK(res1)) {
16600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
16601 }
16602 arg1 = reinterpret_cast< wxImage * >(argp1);
16603 ecode2 = SWIG_AsVal_int(obj1, &val2);
16604 if (!SWIG_IsOK(ecode2)) {
16605 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
16606 }
16607 arg2 = static_cast< int >(val2);
16608 ecode3 = SWIG_AsVal_int(obj2, &val3);
16609 if (!SWIG_IsOK(ecode3)) {
16610 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
16611 }
16612 arg3 = static_cast< int >(val3);
16613 if (obj3) {
16614 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16615 if (!SWIG_IsOK(ecode4)) {
16616 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
16617 }
16618 arg4 = static_cast< bool >(val4);
16619 }
16620 {
16621 PyThreadState* __tstate = wxPyBeginAllowThreads();
16622 (arg1)->Create(arg2,arg3,arg4);
16623 wxPyEndAllowThreads(__tstate);
16624 if (PyErr_Occurred()) SWIG_fail;
16625 }
16626 resultobj = SWIG_Py_Void();
16627 return resultobj;
16628 fail:
16629 return NULL;
16630 }
16631
16632
16633 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16634 PyObject *resultobj = 0;
16635 wxImage *arg1 = (wxImage *) 0 ;
16636 void *argp1 = 0 ;
16637 int res1 = 0 ;
16638 PyObject *swig_obj[1] ;
16639
16640 if (!args) SWIG_fail;
16641 swig_obj[0] = args;
16642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16643 if (!SWIG_IsOK(res1)) {
16644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
16645 }
16646 arg1 = reinterpret_cast< wxImage * >(argp1);
16647 {
16648 PyThreadState* __tstate = wxPyBeginAllowThreads();
16649 (arg1)->Destroy();
16650 wxPyEndAllowThreads(__tstate);
16651 if (PyErr_Occurred()) SWIG_fail;
16652 }
16653 resultobj = SWIG_Py_Void();
16654 return resultobj;
16655 fail:
16656 return NULL;
16657 }
16658
16659
16660 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16661 PyObject *resultobj = 0;
16662 wxImage *arg1 = (wxImage *) 0 ;
16663 int arg2 ;
16664 int arg3 ;
16665 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16666 SwigValueWrapper<wxImage > result;
16667 void *argp1 = 0 ;
16668 int res1 = 0 ;
16669 int val2 ;
16670 int ecode2 = 0 ;
16671 int val3 ;
16672 int ecode3 = 0 ;
16673 int val4 ;
16674 int ecode4 = 0 ;
16675 PyObject * obj0 = 0 ;
16676 PyObject * obj1 = 0 ;
16677 PyObject * obj2 = 0 ;
16678 PyObject * obj3 = 0 ;
16679 char * kwnames[] = {
16680 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16681 };
16682
16683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Scale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16685 if (!SWIG_IsOK(res1)) {
16686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
16687 }
16688 arg1 = reinterpret_cast< wxImage * >(argp1);
16689 ecode2 = SWIG_AsVal_int(obj1, &val2);
16690 if (!SWIG_IsOK(ecode2)) {
16691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
16692 }
16693 arg2 = static_cast< int >(val2);
16694 ecode3 = SWIG_AsVal_int(obj2, &val3);
16695 if (!SWIG_IsOK(ecode3)) {
16696 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
16697 }
16698 arg3 = static_cast< int >(val3);
16699 if (obj3) {
16700 ecode4 = SWIG_AsVal_int(obj3, &val4);
16701 if (!SWIG_IsOK(ecode4)) {
16702 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Scale" "', expected argument " "4"" of type '" "int""'");
16703 }
16704 arg4 = static_cast< int >(val4);
16705 }
16706 {
16707 PyThreadState* __tstate = wxPyBeginAllowThreads();
16708 result = (arg1)->Scale(arg2,arg3,arg4);
16709 wxPyEndAllowThreads(__tstate);
16710 if (PyErr_Occurred()) SWIG_fail;
16711 }
16712 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16713 return resultobj;
16714 fail:
16715 return NULL;
16716 }
16717
16718
16719 SWIGINTERN PyObject *_wrap_Image_ResampleBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16720 PyObject *resultobj = 0;
16721 wxImage *arg1 = (wxImage *) 0 ;
16722 int arg2 ;
16723 int arg3 ;
16724 SwigValueWrapper<wxImage > result;
16725 void *argp1 = 0 ;
16726 int res1 = 0 ;
16727 int val2 ;
16728 int ecode2 = 0 ;
16729 int val3 ;
16730 int ecode3 = 0 ;
16731 PyObject * obj0 = 0 ;
16732 PyObject * obj1 = 0 ;
16733 PyObject * obj2 = 0 ;
16734 char * kwnames[] = {
16735 (char *) "self",(char *) "width",(char *) "height", NULL
16736 };
16737
16738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16740 if (!SWIG_IsOK(res1)) {
16741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBox" "', expected argument " "1"" of type '" "wxImage const *""'");
16742 }
16743 arg1 = reinterpret_cast< wxImage * >(argp1);
16744 ecode2 = SWIG_AsVal_int(obj1, &val2);
16745 if (!SWIG_IsOK(ecode2)) {
16746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBox" "', expected argument " "2"" of type '" "int""'");
16747 }
16748 arg2 = static_cast< int >(val2);
16749 ecode3 = SWIG_AsVal_int(obj2, &val3);
16750 if (!SWIG_IsOK(ecode3)) {
16751 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBox" "', expected argument " "3"" of type '" "int""'");
16752 }
16753 arg3 = static_cast< int >(val3);
16754 {
16755 PyThreadState* __tstate = wxPyBeginAllowThreads();
16756 result = ((wxImage const *)arg1)->ResampleBox(arg2,arg3);
16757 wxPyEndAllowThreads(__tstate);
16758 if (PyErr_Occurred()) SWIG_fail;
16759 }
16760 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16761 return resultobj;
16762 fail:
16763 return NULL;
16764 }
16765
16766
16767 SWIGINTERN PyObject *_wrap_Image_ResampleBicubic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16768 PyObject *resultobj = 0;
16769 wxImage *arg1 = (wxImage *) 0 ;
16770 int arg2 ;
16771 int arg3 ;
16772 SwigValueWrapper<wxImage > result;
16773 void *argp1 = 0 ;
16774 int res1 = 0 ;
16775 int val2 ;
16776 int ecode2 = 0 ;
16777 int val3 ;
16778 int ecode3 = 0 ;
16779 PyObject * obj0 = 0 ;
16780 PyObject * obj1 = 0 ;
16781 PyObject * obj2 = 0 ;
16782 char * kwnames[] = {
16783 (char *) "self",(char *) "width",(char *) "height", NULL
16784 };
16785
16786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBicubic",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16788 if (!SWIG_IsOK(res1)) {
16789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBicubic" "', expected argument " "1"" of type '" "wxImage const *""'");
16790 }
16791 arg1 = reinterpret_cast< wxImage * >(argp1);
16792 ecode2 = SWIG_AsVal_int(obj1, &val2);
16793 if (!SWIG_IsOK(ecode2)) {
16794 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBicubic" "', expected argument " "2"" of type '" "int""'");
16795 }
16796 arg2 = static_cast< int >(val2);
16797 ecode3 = SWIG_AsVal_int(obj2, &val3);
16798 if (!SWIG_IsOK(ecode3)) {
16799 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBicubic" "', expected argument " "3"" of type '" "int""'");
16800 }
16801 arg3 = static_cast< int >(val3);
16802 {
16803 PyThreadState* __tstate = wxPyBeginAllowThreads();
16804 result = ((wxImage const *)arg1)->ResampleBicubic(arg2,arg3);
16805 wxPyEndAllowThreads(__tstate);
16806 if (PyErr_Occurred()) SWIG_fail;
16807 }
16808 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16809 return resultobj;
16810 fail:
16811 return NULL;
16812 }
16813
16814
16815 SWIGINTERN PyObject *_wrap_Image_Blur(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16816 PyObject *resultobj = 0;
16817 wxImage *arg1 = (wxImage *) 0 ;
16818 int arg2 ;
16819 SwigValueWrapper<wxImage > result;
16820 void *argp1 = 0 ;
16821 int res1 = 0 ;
16822 int val2 ;
16823 int ecode2 = 0 ;
16824 PyObject * obj0 = 0 ;
16825 PyObject * obj1 = 0 ;
16826 char * kwnames[] = {
16827 (char *) "self",(char *) "radius", NULL
16828 };
16829
16830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_Blur",kwnames,&obj0,&obj1)) SWIG_fail;
16831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16832 if (!SWIG_IsOK(res1)) {
16833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Blur" "', expected argument " "1"" of type '" "wxImage *""'");
16834 }
16835 arg1 = reinterpret_cast< wxImage * >(argp1);
16836 ecode2 = SWIG_AsVal_int(obj1, &val2);
16837 if (!SWIG_IsOK(ecode2)) {
16838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Blur" "', expected argument " "2"" of type '" "int""'");
16839 }
16840 arg2 = static_cast< int >(val2);
16841 {
16842 PyThreadState* __tstate = wxPyBeginAllowThreads();
16843 result = (arg1)->Blur(arg2);
16844 wxPyEndAllowThreads(__tstate);
16845 if (PyErr_Occurred()) SWIG_fail;
16846 }
16847 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16848 return resultobj;
16849 fail:
16850 return NULL;
16851 }
16852
16853
16854 SWIGINTERN PyObject *_wrap_Image_BlurHorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16855 PyObject *resultobj = 0;
16856 wxImage *arg1 = (wxImage *) 0 ;
16857 int arg2 ;
16858 SwigValueWrapper<wxImage > result;
16859 void *argp1 = 0 ;
16860 int res1 = 0 ;
16861 int val2 ;
16862 int ecode2 = 0 ;
16863 PyObject * obj0 = 0 ;
16864 PyObject * obj1 = 0 ;
16865 char * kwnames[] = {
16866 (char *) "self",(char *) "radius", NULL
16867 };
16868
16869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurHorizontal",kwnames,&obj0,&obj1)) SWIG_fail;
16870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16871 if (!SWIG_IsOK(res1)) {
16872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurHorizontal" "', expected argument " "1"" of type '" "wxImage *""'");
16873 }
16874 arg1 = reinterpret_cast< wxImage * >(argp1);
16875 ecode2 = SWIG_AsVal_int(obj1, &val2);
16876 if (!SWIG_IsOK(ecode2)) {
16877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurHorizontal" "', expected argument " "2"" of type '" "int""'");
16878 }
16879 arg2 = static_cast< int >(val2);
16880 {
16881 PyThreadState* __tstate = wxPyBeginAllowThreads();
16882 result = (arg1)->BlurHorizontal(arg2);
16883 wxPyEndAllowThreads(__tstate);
16884 if (PyErr_Occurred()) SWIG_fail;
16885 }
16886 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16887 return resultobj;
16888 fail:
16889 return NULL;
16890 }
16891
16892
16893 SWIGINTERN PyObject *_wrap_Image_BlurVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16894 PyObject *resultobj = 0;
16895 wxImage *arg1 = (wxImage *) 0 ;
16896 int arg2 ;
16897 SwigValueWrapper<wxImage > result;
16898 void *argp1 = 0 ;
16899 int res1 = 0 ;
16900 int val2 ;
16901 int ecode2 = 0 ;
16902 PyObject * obj0 = 0 ;
16903 PyObject * obj1 = 0 ;
16904 char * kwnames[] = {
16905 (char *) "self",(char *) "radius", NULL
16906 };
16907
16908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurVertical",kwnames,&obj0,&obj1)) SWIG_fail;
16909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16910 if (!SWIG_IsOK(res1)) {
16911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurVertical" "', expected argument " "1"" of type '" "wxImage *""'");
16912 }
16913 arg1 = reinterpret_cast< wxImage * >(argp1);
16914 ecode2 = SWIG_AsVal_int(obj1, &val2);
16915 if (!SWIG_IsOK(ecode2)) {
16916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurVertical" "', expected argument " "2"" of type '" "int""'");
16917 }
16918 arg2 = static_cast< int >(val2);
16919 {
16920 PyThreadState* __tstate = wxPyBeginAllowThreads();
16921 result = (arg1)->BlurVertical(arg2);
16922 wxPyEndAllowThreads(__tstate);
16923 if (PyErr_Occurred()) SWIG_fail;
16924 }
16925 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16926 return resultobj;
16927 fail:
16928 return NULL;
16929 }
16930
16931
16932 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16933 PyObject *resultobj = 0;
16934 wxImage *arg1 = (wxImage *) 0 ;
16935 int arg2 ;
16936 int arg3 ;
16937 SwigValueWrapper<wxImage > result;
16938 void *argp1 = 0 ;
16939 int res1 = 0 ;
16940 int val2 ;
16941 int ecode2 = 0 ;
16942 int val3 ;
16943 int ecode3 = 0 ;
16944 PyObject * obj0 = 0 ;
16945 PyObject * obj1 = 0 ;
16946 PyObject * obj2 = 0 ;
16947 char * kwnames[] = {
16948 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
16949 };
16950
16951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16953 if (!SWIG_IsOK(res1)) {
16954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
16955 }
16956 arg1 = reinterpret_cast< wxImage * >(argp1);
16957 ecode2 = SWIG_AsVal_int(obj1, &val2);
16958 if (!SWIG_IsOK(ecode2)) {
16959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
16960 }
16961 arg2 = static_cast< int >(val2);
16962 ecode3 = SWIG_AsVal_int(obj2, &val3);
16963 if (!SWIG_IsOK(ecode3)) {
16964 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
16965 }
16966 arg3 = static_cast< int >(val3);
16967 {
16968 PyThreadState* __tstate = wxPyBeginAllowThreads();
16969 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
16970 wxPyEndAllowThreads(__tstate);
16971 if (PyErr_Occurred()) SWIG_fail;
16972 }
16973 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16974 return resultobj;
16975 fail:
16976 return NULL;
16977 }
16978
16979
16980 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16981 PyObject *resultobj = 0;
16982 wxImage *arg1 = (wxImage *) 0 ;
16983 int arg2 ;
16984 int arg3 ;
16985 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16986 wxImage *result = 0 ;
16987 void *argp1 = 0 ;
16988 int res1 = 0 ;
16989 int val2 ;
16990 int ecode2 = 0 ;
16991 int val3 ;
16992 int ecode3 = 0 ;
16993 int val4 ;
16994 int ecode4 = 0 ;
16995 PyObject * obj0 = 0 ;
16996 PyObject * obj1 = 0 ;
16997 PyObject * obj2 = 0 ;
16998 PyObject * obj3 = 0 ;
16999 char * kwnames[] = {
17000 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
17001 };
17002
17003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Rescale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17005 if (!SWIG_IsOK(res1)) {
17006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
17007 }
17008 arg1 = reinterpret_cast< wxImage * >(argp1);
17009 ecode2 = SWIG_AsVal_int(obj1, &val2);
17010 if (!SWIG_IsOK(ecode2)) {
17011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
17012 }
17013 arg2 = static_cast< int >(val2);
17014 ecode3 = SWIG_AsVal_int(obj2, &val3);
17015 if (!SWIG_IsOK(ecode3)) {
17016 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
17017 }
17018 arg3 = static_cast< int >(val3);
17019 if (obj3) {
17020 ecode4 = SWIG_AsVal_int(obj3, &val4);
17021 if (!SWIG_IsOK(ecode4)) {
17022 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rescale" "', expected argument " "4"" of type '" "int""'");
17023 }
17024 arg4 = static_cast< int >(val4);
17025 }
17026 {
17027 PyThreadState* __tstate = wxPyBeginAllowThreads();
17028 {
17029 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3,arg4);
17030 result = (wxImage *) &_result_ref;
17031 }
17032 wxPyEndAllowThreads(__tstate);
17033 if (PyErr_Occurred()) SWIG_fail;
17034 }
17035 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
17036 return resultobj;
17037 fail:
17038 return NULL;
17039 }
17040
17041
17042 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17043 PyObject *resultobj = 0;
17044 wxImage *arg1 = (wxImage *) 0 ;
17045 wxSize *arg2 = 0 ;
17046 wxPoint *arg3 = 0 ;
17047 int arg4 = (int) -1 ;
17048 int arg5 = (int) -1 ;
17049 int arg6 = (int) -1 ;
17050 wxImage *result = 0 ;
17051 void *argp1 = 0 ;
17052 int res1 = 0 ;
17053 wxSize temp2 ;
17054 wxPoint temp3 ;
17055 int val4 ;
17056 int ecode4 = 0 ;
17057 int val5 ;
17058 int ecode5 = 0 ;
17059 int val6 ;
17060 int ecode6 = 0 ;
17061 PyObject * obj0 = 0 ;
17062 PyObject * obj1 = 0 ;
17063 PyObject * obj2 = 0 ;
17064 PyObject * obj3 = 0 ;
17065 PyObject * obj4 = 0 ;
17066 PyObject * obj5 = 0 ;
17067 char * kwnames[] = {
17068 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
17069 };
17070
17071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
17072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17073 if (!SWIG_IsOK(res1)) {
17074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
17075 }
17076 arg1 = reinterpret_cast< wxImage * >(argp1);
17077 {
17078 arg2 = &temp2;
17079 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
17080 }
17081 {
17082 arg3 = &temp3;
17083 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
17084 }
17085 if (obj3) {
17086 ecode4 = SWIG_AsVal_int(obj3, &val4);
17087 if (!SWIG_IsOK(ecode4)) {
17088 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
17089 }
17090 arg4 = static_cast< int >(val4);
17091 }
17092 if (obj4) {
17093 ecode5 = SWIG_AsVal_int(obj4, &val5);
17094 if (!SWIG_IsOK(ecode5)) {
17095 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
17096 }
17097 arg5 = static_cast< int >(val5);
17098 }
17099 if (obj5) {
17100 ecode6 = SWIG_AsVal_int(obj5, &val6);
17101 if (!SWIG_IsOK(ecode6)) {
17102 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
17103 }
17104 arg6 = static_cast< int >(val6);
17105 }
17106 {
17107 PyThreadState* __tstate = wxPyBeginAllowThreads();
17108 {
17109 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
17110 result = (wxImage *) &_result_ref;
17111 }
17112 wxPyEndAllowThreads(__tstate);
17113 if (PyErr_Occurred()) SWIG_fail;
17114 }
17115 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
17116 return resultobj;
17117 fail:
17118 return NULL;
17119 }
17120
17121
17122 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17123 PyObject *resultobj = 0;
17124 wxImage *arg1 = (wxImage *) 0 ;
17125 int arg2 ;
17126 int arg3 ;
17127 byte arg4 ;
17128 byte arg5 ;
17129 byte arg6 ;
17130 void *argp1 = 0 ;
17131 int res1 = 0 ;
17132 int val2 ;
17133 int ecode2 = 0 ;
17134 int val3 ;
17135 int ecode3 = 0 ;
17136 unsigned char val4 ;
17137 int ecode4 = 0 ;
17138 unsigned char val5 ;
17139 int ecode5 = 0 ;
17140 unsigned char val6 ;
17141 int ecode6 = 0 ;
17142 PyObject * obj0 = 0 ;
17143 PyObject * obj1 = 0 ;
17144 PyObject * obj2 = 0 ;
17145 PyObject * obj3 = 0 ;
17146 PyObject * obj4 = 0 ;
17147 PyObject * obj5 = 0 ;
17148 char * kwnames[] = {
17149 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
17150 };
17151
17152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
17153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17154 if (!SWIG_IsOK(res1)) {
17155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
17156 }
17157 arg1 = reinterpret_cast< wxImage * >(argp1);
17158 ecode2 = SWIG_AsVal_int(obj1, &val2);
17159 if (!SWIG_IsOK(ecode2)) {
17160 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
17161 }
17162 arg2 = static_cast< int >(val2);
17163 ecode3 = SWIG_AsVal_int(obj2, &val3);
17164 if (!SWIG_IsOK(ecode3)) {
17165 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
17166 }
17167 arg3 = static_cast< int >(val3);
17168 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17169 if (!SWIG_IsOK(ecode4)) {
17170 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
17171 }
17172 arg4 = static_cast< byte >(val4);
17173 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
17174 if (!SWIG_IsOK(ecode5)) {
17175 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
17176 }
17177 arg5 = static_cast< byte >(val5);
17178 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
17179 if (!SWIG_IsOK(ecode6)) {
17180 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
17181 }
17182 arg6 = static_cast< byte >(val6);
17183 {
17184 PyThreadState* __tstate = wxPyBeginAllowThreads();
17185 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
17186 wxPyEndAllowThreads(__tstate);
17187 if (PyErr_Occurred()) SWIG_fail;
17188 }
17189 resultobj = SWIG_Py_Void();
17190 return resultobj;
17191 fail:
17192 return NULL;
17193 }
17194
17195
17196 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17197 PyObject *resultobj = 0;
17198 wxImage *arg1 = (wxImage *) 0 ;
17199 wxRect *arg2 = 0 ;
17200 byte arg3 ;
17201 byte arg4 ;
17202 byte arg5 ;
17203 void *argp1 = 0 ;
17204 int res1 = 0 ;
17205 wxRect temp2 ;
17206 unsigned char val3 ;
17207 int ecode3 = 0 ;
17208 unsigned char val4 ;
17209 int ecode4 = 0 ;
17210 unsigned char val5 ;
17211 int ecode5 = 0 ;
17212 PyObject * obj0 = 0 ;
17213 PyObject * obj1 = 0 ;
17214 PyObject * obj2 = 0 ;
17215 PyObject * obj3 = 0 ;
17216 PyObject * obj4 = 0 ;
17217 char * kwnames[] = {
17218 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
17219 };
17220
17221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17223 if (!SWIG_IsOK(res1)) {
17224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
17225 }
17226 arg1 = reinterpret_cast< wxImage * >(argp1);
17227 {
17228 arg2 = &temp2;
17229 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
17230 }
17231 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17232 if (!SWIG_IsOK(ecode3)) {
17233 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
17234 }
17235 arg3 = static_cast< byte >(val3);
17236 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17237 if (!SWIG_IsOK(ecode4)) {
17238 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
17239 }
17240 arg4 = static_cast< byte >(val4);
17241 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
17242 if (!SWIG_IsOK(ecode5)) {
17243 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
17244 }
17245 arg5 = static_cast< byte >(val5);
17246 {
17247 PyThreadState* __tstate = wxPyBeginAllowThreads();
17248 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
17249 wxPyEndAllowThreads(__tstate);
17250 if (PyErr_Occurred()) SWIG_fail;
17251 }
17252 resultobj = SWIG_Py_Void();
17253 return resultobj;
17254 fail:
17255 return NULL;
17256 }
17257
17258
17259 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17260 PyObject *resultobj = 0;
17261 wxImage *arg1 = (wxImage *) 0 ;
17262 int arg2 ;
17263 int arg3 ;
17264 byte result;
17265 void *argp1 = 0 ;
17266 int res1 = 0 ;
17267 int val2 ;
17268 int ecode2 = 0 ;
17269 int val3 ;
17270 int ecode3 = 0 ;
17271 PyObject * obj0 = 0 ;
17272 PyObject * obj1 = 0 ;
17273 PyObject * obj2 = 0 ;
17274 char * kwnames[] = {
17275 (char *) "self",(char *) "x",(char *) "y", NULL
17276 };
17277
17278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17280 if (!SWIG_IsOK(res1)) {
17281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
17282 }
17283 arg1 = reinterpret_cast< wxImage * >(argp1);
17284 ecode2 = SWIG_AsVal_int(obj1, &val2);
17285 if (!SWIG_IsOK(ecode2)) {
17286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
17287 }
17288 arg2 = static_cast< int >(val2);
17289 ecode3 = SWIG_AsVal_int(obj2, &val3);
17290 if (!SWIG_IsOK(ecode3)) {
17291 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
17292 }
17293 arg3 = static_cast< int >(val3);
17294 {
17295 PyThreadState* __tstate = wxPyBeginAllowThreads();
17296 result = (byte)(arg1)->GetRed(arg2,arg3);
17297 wxPyEndAllowThreads(__tstate);
17298 if (PyErr_Occurred()) SWIG_fail;
17299 }
17300 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
17301 return resultobj;
17302 fail:
17303 return NULL;
17304 }
17305
17306
17307 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17308 PyObject *resultobj = 0;
17309 wxImage *arg1 = (wxImage *) 0 ;
17310 int arg2 ;
17311 int arg3 ;
17312 byte result;
17313 void *argp1 = 0 ;
17314 int res1 = 0 ;
17315 int val2 ;
17316 int ecode2 = 0 ;
17317 int val3 ;
17318 int ecode3 = 0 ;
17319 PyObject * obj0 = 0 ;
17320 PyObject * obj1 = 0 ;
17321 PyObject * obj2 = 0 ;
17322 char * kwnames[] = {
17323 (char *) "self",(char *) "x",(char *) "y", NULL
17324 };
17325
17326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17328 if (!SWIG_IsOK(res1)) {
17329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
17330 }
17331 arg1 = reinterpret_cast< wxImage * >(argp1);
17332 ecode2 = SWIG_AsVal_int(obj1, &val2);
17333 if (!SWIG_IsOK(ecode2)) {
17334 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
17335 }
17336 arg2 = static_cast< int >(val2);
17337 ecode3 = SWIG_AsVal_int(obj2, &val3);
17338 if (!SWIG_IsOK(ecode3)) {
17339 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
17340 }
17341 arg3 = static_cast< int >(val3);
17342 {
17343 PyThreadState* __tstate = wxPyBeginAllowThreads();
17344 result = (byte)(arg1)->GetGreen(arg2,arg3);
17345 wxPyEndAllowThreads(__tstate);
17346 if (PyErr_Occurred()) SWIG_fail;
17347 }
17348 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
17349 return resultobj;
17350 fail:
17351 return NULL;
17352 }
17353
17354
17355 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17356 PyObject *resultobj = 0;
17357 wxImage *arg1 = (wxImage *) 0 ;
17358 int arg2 ;
17359 int arg3 ;
17360 byte result;
17361 void *argp1 = 0 ;
17362 int res1 = 0 ;
17363 int val2 ;
17364 int ecode2 = 0 ;
17365 int val3 ;
17366 int ecode3 = 0 ;
17367 PyObject * obj0 = 0 ;
17368 PyObject * obj1 = 0 ;
17369 PyObject * obj2 = 0 ;
17370 char * kwnames[] = {
17371 (char *) "self",(char *) "x",(char *) "y", NULL
17372 };
17373
17374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17376 if (!SWIG_IsOK(res1)) {
17377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
17378 }
17379 arg1 = reinterpret_cast< wxImage * >(argp1);
17380 ecode2 = SWIG_AsVal_int(obj1, &val2);
17381 if (!SWIG_IsOK(ecode2)) {
17382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
17383 }
17384 arg2 = static_cast< int >(val2);
17385 ecode3 = SWIG_AsVal_int(obj2, &val3);
17386 if (!SWIG_IsOK(ecode3)) {
17387 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
17388 }
17389 arg3 = static_cast< int >(val3);
17390 {
17391 PyThreadState* __tstate = wxPyBeginAllowThreads();
17392 result = (byte)(arg1)->GetBlue(arg2,arg3);
17393 wxPyEndAllowThreads(__tstate);
17394 if (PyErr_Occurred()) SWIG_fail;
17395 }
17396 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
17397 return resultobj;
17398 fail:
17399 return NULL;
17400 }
17401
17402
17403 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17404 PyObject *resultobj = 0;
17405 wxImage *arg1 = (wxImage *) 0 ;
17406 int arg2 ;
17407 int arg3 ;
17408 byte arg4 ;
17409 void *argp1 = 0 ;
17410 int res1 = 0 ;
17411 int val2 ;
17412 int ecode2 = 0 ;
17413 int val3 ;
17414 int ecode3 = 0 ;
17415 unsigned char val4 ;
17416 int ecode4 = 0 ;
17417 PyObject * obj0 = 0 ;
17418 PyObject * obj1 = 0 ;
17419 PyObject * obj2 = 0 ;
17420 PyObject * obj3 = 0 ;
17421 char * kwnames[] = {
17422 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
17423 };
17424
17425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17427 if (!SWIG_IsOK(res1)) {
17428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17429 }
17430 arg1 = reinterpret_cast< wxImage * >(argp1);
17431 ecode2 = SWIG_AsVal_int(obj1, &val2);
17432 if (!SWIG_IsOK(ecode2)) {
17433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
17434 }
17435 arg2 = static_cast< int >(val2);
17436 ecode3 = SWIG_AsVal_int(obj2, &val3);
17437 if (!SWIG_IsOK(ecode3)) {
17438 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
17439 }
17440 arg3 = static_cast< int >(val3);
17441 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17442 if (!SWIG_IsOK(ecode4)) {
17443 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
17444 }
17445 arg4 = static_cast< byte >(val4);
17446 {
17447 PyThreadState* __tstate = wxPyBeginAllowThreads();
17448 (arg1)->SetAlpha(arg2,arg3,arg4);
17449 wxPyEndAllowThreads(__tstate);
17450 if (PyErr_Occurred()) SWIG_fail;
17451 }
17452 resultobj = SWIG_Py_Void();
17453 return resultobj;
17454 fail:
17455 return NULL;
17456 }
17457
17458
17459 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17460 PyObject *resultobj = 0;
17461 wxImage *arg1 = (wxImage *) 0 ;
17462 int arg2 ;
17463 int arg3 ;
17464 byte result;
17465 void *argp1 = 0 ;
17466 int res1 = 0 ;
17467 int val2 ;
17468 int ecode2 = 0 ;
17469 int val3 ;
17470 int ecode3 = 0 ;
17471 PyObject * obj0 = 0 ;
17472 PyObject * obj1 = 0 ;
17473 PyObject * obj2 = 0 ;
17474 char * kwnames[] = {
17475 (char *) "self",(char *) "x",(char *) "y", NULL
17476 };
17477
17478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17480 if (!SWIG_IsOK(res1)) {
17481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17482 }
17483 arg1 = reinterpret_cast< wxImage * >(argp1);
17484 ecode2 = SWIG_AsVal_int(obj1, &val2);
17485 if (!SWIG_IsOK(ecode2)) {
17486 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
17487 }
17488 arg2 = static_cast< int >(val2);
17489 ecode3 = SWIG_AsVal_int(obj2, &val3);
17490 if (!SWIG_IsOK(ecode3)) {
17491 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
17492 }
17493 arg3 = static_cast< int >(val3);
17494 {
17495 PyThreadState* __tstate = wxPyBeginAllowThreads();
17496 result = (byte)(arg1)->GetAlpha(arg2,arg3);
17497 wxPyEndAllowThreads(__tstate);
17498 if (PyErr_Occurred()) SWIG_fail;
17499 }
17500 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
17501 return resultobj;
17502 fail:
17503 return NULL;
17504 }
17505
17506
17507 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17508 PyObject *resultobj = 0;
17509 wxImage *arg1 = (wxImage *) 0 ;
17510 bool result;
17511 void *argp1 = 0 ;
17512 int res1 = 0 ;
17513 PyObject *swig_obj[1] ;
17514
17515 if (!args) SWIG_fail;
17516 swig_obj[0] = args;
17517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17518 if (!SWIG_IsOK(res1)) {
17519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17520 }
17521 arg1 = reinterpret_cast< wxImage * >(argp1);
17522 {
17523 PyThreadState* __tstate = wxPyBeginAllowThreads();
17524 result = (bool)(arg1)->HasAlpha();
17525 wxPyEndAllowThreads(__tstate);
17526 if (PyErr_Occurred()) SWIG_fail;
17527 }
17528 {
17529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17530 }
17531 return resultobj;
17532 fail:
17533 return NULL;
17534 }
17535
17536
17537 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17538 PyObject *resultobj = 0;
17539 wxImage *arg1 = (wxImage *) 0 ;
17540 void *argp1 = 0 ;
17541 int res1 = 0 ;
17542 PyObject *swig_obj[1] ;
17543
17544 if (!args) SWIG_fail;
17545 swig_obj[0] = args;
17546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17547 if (!SWIG_IsOK(res1)) {
17548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17549 }
17550 arg1 = reinterpret_cast< wxImage * >(argp1);
17551 {
17552 PyThreadState* __tstate = wxPyBeginAllowThreads();
17553 (arg1)->InitAlpha();
17554 wxPyEndAllowThreads(__tstate);
17555 if (PyErr_Occurred()) SWIG_fail;
17556 }
17557 resultobj = SWIG_Py_Void();
17558 return resultobj;
17559 fail:
17560 return NULL;
17561 }
17562
17563
17564 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17565 PyObject *resultobj = 0;
17566 wxImage *arg1 = (wxImage *) 0 ;
17567 int arg2 ;
17568 int arg3 ;
17569 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
17570 bool result;
17571 void *argp1 = 0 ;
17572 int res1 = 0 ;
17573 int val2 ;
17574 int ecode2 = 0 ;
17575 int val3 ;
17576 int ecode3 = 0 ;
17577 unsigned char val4 ;
17578 int ecode4 = 0 ;
17579 PyObject * obj0 = 0 ;
17580 PyObject * obj1 = 0 ;
17581 PyObject * obj2 = 0 ;
17582 PyObject * obj3 = 0 ;
17583 char * kwnames[] = {
17584 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
17585 };
17586
17587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17589 if (!SWIG_IsOK(res1)) {
17590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
17591 }
17592 arg1 = reinterpret_cast< wxImage * >(argp1);
17593 ecode2 = SWIG_AsVal_int(obj1, &val2);
17594 if (!SWIG_IsOK(ecode2)) {
17595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
17596 }
17597 arg2 = static_cast< int >(val2);
17598 ecode3 = SWIG_AsVal_int(obj2, &val3);
17599 if (!SWIG_IsOK(ecode3)) {
17600 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
17601 }
17602 arg3 = static_cast< int >(val3);
17603 if (obj3) {
17604 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17605 if (!SWIG_IsOK(ecode4)) {
17606 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
17607 }
17608 arg4 = static_cast< byte >(val4);
17609 }
17610 {
17611 PyThreadState* __tstate = wxPyBeginAllowThreads();
17612 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
17613 wxPyEndAllowThreads(__tstate);
17614 if (PyErr_Occurred()) SWIG_fail;
17615 }
17616 {
17617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17618 }
17619 return resultobj;
17620 fail:
17621 return NULL;
17622 }
17623
17624
17625 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17626 PyObject *resultobj = 0;
17627 wxImage *arg1 = (wxImage *) 0 ;
17628 byte *arg2 = (byte *) 0 ;
17629 byte *arg3 = (byte *) 0 ;
17630 byte *arg4 = (byte *) 0 ;
17631 byte arg5 = (byte) 0 ;
17632 byte arg6 = (byte) 0 ;
17633 byte arg7 = (byte) 0 ;
17634 bool result;
17635 void *argp1 = 0 ;
17636 int res1 = 0 ;
17637 byte temp2 ;
17638 int res2 = SWIG_TMPOBJ ;
17639 byte temp3 ;
17640 int res3 = SWIG_TMPOBJ ;
17641 byte temp4 ;
17642 int res4 = SWIG_TMPOBJ ;
17643 unsigned char val5 ;
17644 int ecode5 = 0 ;
17645 unsigned char val6 ;
17646 int ecode6 = 0 ;
17647 unsigned char val7 ;
17648 int ecode7 = 0 ;
17649 PyObject * obj0 = 0 ;
17650 PyObject * obj1 = 0 ;
17651 PyObject * obj2 = 0 ;
17652 PyObject * obj3 = 0 ;
17653 char * kwnames[] = {
17654 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
17655 };
17656
17657 arg2 = &temp2;
17658 arg3 = &temp3;
17659 arg4 = &temp4;
17660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17662 if (!SWIG_IsOK(res1)) {
17663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
17664 }
17665 arg1 = reinterpret_cast< wxImage * >(argp1);
17666 if (obj1) {
17667 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
17668 if (!SWIG_IsOK(ecode5)) {
17669 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
17670 }
17671 arg5 = static_cast< byte >(val5);
17672 }
17673 if (obj2) {
17674 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
17675 if (!SWIG_IsOK(ecode6)) {
17676 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
17677 }
17678 arg6 = static_cast< byte >(val6);
17679 }
17680 if (obj3) {
17681 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
17682 if (!SWIG_IsOK(ecode7)) {
17683 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
17684 }
17685 arg7 = static_cast< byte >(val7);
17686 }
17687 {
17688 PyThreadState* __tstate = wxPyBeginAllowThreads();
17689 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
17690 wxPyEndAllowThreads(__tstate);
17691 if (PyErr_Occurred()) SWIG_fail;
17692 }
17693 {
17694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17695 }
17696 if (SWIG_IsTmpObj(res2)) {
17697 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
17698 } else {
17699 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17700 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
17701 }
17702 if (SWIG_IsTmpObj(res3)) {
17703 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
17704 } else {
17705 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17706 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
17707 }
17708 if (SWIG_IsTmpObj(res4)) {
17709 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
17710 } else {
17711 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17712 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
17713 }
17714 return resultobj;
17715 fail:
17716 return NULL;
17717 }
17718
17719
17720 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17721 PyObject *resultobj = 0;
17722 wxImage *arg1 = (wxImage *) 0 ;
17723 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
17724 bool result;
17725 void *argp1 = 0 ;
17726 int res1 = 0 ;
17727 unsigned char val2 ;
17728 int ecode2 = 0 ;
17729 PyObject * obj0 = 0 ;
17730 PyObject * obj1 = 0 ;
17731 char * kwnames[] = {
17732 (char *) "self",(char *) "threshold", NULL
17733 };
17734
17735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
17736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17737 if (!SWIG_IsOK(res1)) {
17738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
17739 }
17740 arg1 = reinterpret_cast< wxImage * >(argp1);
17741 if (obj1) {
17742 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17743 if (!SWIG_IsOK(ecode2)) {
17744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
17745 }
17746 arg2 = static_cast< byte >(val2);
17747 }
17748 {
17749 PyThreadState* __tstate = wxPyBeginAllowThreads();
17750 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
17751 wxPyEndAllowThreads(__tstate);
17752 if (PyErr_Occurred()) SWIG_fail;
17753 }
17754 {
17755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17756 }
17757 return resultobj;
17758 fail:
17759 return NULL;
17760 }
17761
17762
17763 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17764 PyObject *resultobj = 0;
17765 wxImage *arg1 = (wxImage *) 0 ;
17766 byte arg2 ;
17767 byte arg3 ;
17768 byte arg4 ;
17769 bool result;
17770 void *argp1 = 0 ;
17771 int res1 = 0 ;
17772 unsigned char val2 ;
17773 int ecode2 = 0 ;
17774 unsigned char val3 ;
17775 int ecode3 = 0 ;
17776 unsigned char 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 *) "r",(char *) "g",(char *) "b", NULL
17784 };
17785
17786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",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_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17790 }
17791 arg1 = reinterpret_cast< wxImage * >(argp1);
17792 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17793 if (!SWIG_IsOK(ecode2)) {
17794 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
17795 }
17796 arg2 = static_cast< byte >(val2);
17797 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17798 if (!SWIG_IsOK(ecode3)) {
17799 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
17800 }
17801 arg3 = static_cast< byte >(val3);
17802 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17803 if (!SWIG_IsOK(ecode4)) {
17804 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
17805 }
17806 arg4 = static_cast< byte >(val4);
17807 {
17808 PyThreadState* __tstate = wxPyBeginAllowThreads();
17809 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
17810 wxPyEndAllowThreads(__tstate);
17811 if (PyErr_Occurred()) SWIG_fail;
17812 }
17813 {
17814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17815 }
17816 return resultobj;
17817 fail:
17818 return NULL;
17819 }
17820
17821
17822 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17823 PyObject *resultobj = 0;
17824 wxImage *arg1 = (wxImage *) 0 ;
17825 wxImage *arg2 = 0 ;
17826 byte arg3 ;
17827 byte arg4 ;
17828 byte arg5 ;
17829 bool result;
17830 void *argp1 = 0 ;
17831 int res1 = 0 ;
17832 void *argp2 = 0 ;
17833 int res2 = 0 ;
17834 unsigned char val3 ;
17835 int ecode3 = 0 ;
17836 unsigned char val4 ;
17837 int ecode4 = 0 ;
17838 unsigned char val5 ;
17839 int ecode5 = 0 ;
17840 PyObject * obj0 = 0 ;
17841 PyObject * obj1 = 0 ;
17842 PyObject * obj2 = 0 ;
17843 PyObject * obj3 = 0 ;
17844 PyObject * obj4 = 0 ;
17845 char * kwnames[] = {
17846 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
17847 };
17848
17849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17851 if (!SWIG_IsOK(res1)) {
17852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
17853 }
17854 arg1 = reinterpret_cast< wxImage * >(argp1);
17855 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
17856 if (!SWIG_IsOK(res2)) {
17857 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17858 }
17859 if (!argp2) {
17860 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17861 }
17862 arg2 = reinterpret_cast< wxImage * >(argp2);
17863 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17864 if (!SWIG_IsOK(ecode3)) {
17865 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
17866 }
17867 arg3 = static_cast< byte >(val3);
17868 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17869 if (!SWIG_IsOK(ecode4)) {
17870 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
17871 }
17872 arg4 = static_cast< byte >(val4);
17873 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
17874 if (!SWIG_IsOK(ecode5)) {
17875 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
17876 }
17877 arg5 = static_cast< byte >(val5);
17878 {
17879 PyThreadState* __tstate = wxPyBeginAllowThreads();
17880 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
17881 wxPyEndAllowThreads(__tstate);
17882 if (PyErr_Occurred()) SWIG_fail;
17883 }
17884 {
17885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17886 }
17887 return resultobj;
17888 fail:
17889 return NULL;
17890 }
17891
17892
17893 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17894 PyObject *resultobj = 0;
17895 wxString *arg1 = 0 ;
17896 bool result;
17897 bool temp1 = false ;
17898 PyObject * obj0 = 0 ;
17899 char * kwnames[] = {
17900 (char *) "filename", NULL
17901 };
17902
17903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
17904 {
17905 arg1 = wxString_in_helper(obj0);
17906 if (arg1 == NULL) SWIG_fail;
17907 temp1 = true;
17908 }
17909 {
17910 PyThreadState* __tstate = wxPyBeginAllowThreads();
17911 result = (bool)wxImage::CanRead((wxString const &)*arg1);
17912 wxPyEndAllowThreads(__tstate);
17913 if (PyErr_Occurred()) SWIG_fail;
17914 }
17915 {
17916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17917 }
17918 {
17919 if (temp1)
17920 delete arg1;
17921 }
17922 return resultobj;
17923 fail:
17924 {
17925 if (temp1)
17926 delete arg1;
17927 }
17928 return NULL;
17929 }
17930
17931
17932 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17933 PyObject *resultobj = 0;
17934 wxString *arg1 = 0 ;
17935 long arg2 = (long) wxBITMAP_TYPE_ANY ;
17936 int result;
17937 bool temp1 = false ;
17938 long val2 ;
17939 int ecode2 = 0 ;
17940 PyObject * obj0 = 0 ;
17941 PyObject * obj1 = 0 ;
17942 char * kwnames[] = {
17943 (char *) "filename",(char *) "type", NULL
17944 };
17945
17946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
17947 {
17948 arg1 = wxString_in_helper(obj0);
17949 if (arg1 == NULL) SWIG_fail;
17950 temp1 = true;
17951 }
17952 if (obj1) {
17953 ecode2 = SWIG_AsVal_long(obj1, &val2);
17954 if (!SWIG_IsOK(ecode2)) {
17955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
17956 }
17957 arg2 = static_cast< long >(val2);
17958 }
17959 {
17960 PyThreadState* __tstate = wxPyBeginAllowThreads();
17961 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
17962 wxPyEndAllowThreads(__tstate);
17963 if (PyErr_Occurred()) SWIG_fail;
17964 }
17965 resultobj = SWIG_From_int(static_cast< int >(result));
17966 {
17967 if (temp1)
17968 delete arg1;
17969 }
17970 return resultobj;
17971 fail:
17972 {
17973 if (temp1)
17974 delete arg1;
17975 }
17976 return NULL;
17977 }
17978
17979
17980 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17981 PyObject *resultobj = 0;
17982 wxImage *arg1 = (wxImage *) 0 ;
17983 wxString *arg2 = 0 ;
17984 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17985 int arg4 = (int) -1 ;
17986 bool result;
17987 void *argp1 = 0 ;
17988 int res1 = 0 ;
17989 bool temp2 = false ;
17990 long val3 ;
17991 int ecode3 = 0 ;
17992 int val4 ;
17993 int ecode4 = 0 ;
17994 PyObject * obj0 = 0 ;
17995 PyObject * obj1 = 0 ;
17996 PyObject * obj2 = 0 ;
17997 PyObject * obj3 = 0 ;
17998 char * kwnames[] = {
17999 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
18000 };
18001
18002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18004 if (!SWIG_IsOK(res1)) {
18005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
18006 }
18007 arg1 = reinterpret_cast< wxImage * >(argp1);
18008 {
18009 arg2 = wxString_in_helper(obj1);
18010 if (arg2 == NULL) SWIG_fail;
18011 temp2 = true;
18012 }
18013 if (obj2) {
18014 ecode3 = SWIG_AsVal_long(obj2, &val3);
18015 if (!SWIG_IsOK(ecode3)) {
18016 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
18017 }
18018 arg3 = static_cast< long >(val3);
18019 }
18020 if (obj3) {
18021 ecode4 = SWIG_AsVal_int(obj3, &val4);
18022 if (!SWIG_IsOK(ecode4)) {
18023 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
18024 }
18025 arg4 = static_cast< int >(val4);
18026 }
18027 {
18028 PyThreadState* __tstate = wxPyBeginAllowThreads();
18029 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
18030 wxPyEndAllowThreads(__tstate);
18031 if (PyErr_Occurred()) SWIG_fail;
18032 }
18033 {
18034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18035 }
18036 {
18037 if (temp2)
18038 delete arg2;
18039 }
18040 return resultobj;
18041 fail:
18042 {
18043 if (temp2)
18044 delete arg2;
18045 }
18046 return NULL;
18047 }
18048
18049
18050 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18051 PyObject *resultobj = 0;
18052 wxImage *arg1 = (wxImage *) 0 ;
18053 wxString *arg2 = 0 ;
18054 wxString *arg3 = 0 ;
18055 int arg4 = (int) -1 ;
18056 bool result;
18057 void *argp1 = 0 ;
18058 int res1 = 0 ;
18059 bool temp2 = false ;
18060 bool temp3 = false ;
18061 int val4 ;
18062 int ecode4 = 0 ;
18063 PyObject * obj0 = 0 ;
18064 PyObject * obj1 = 0 ;
18065 PyObject * obj2 = 0 ;
18066 PyObject * obj3 = 0 ;
18067 char * kwnames[] = {
18068 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
18069 };
18070
18071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18073 if (!SWIG_IsOK(res1)) {
18074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
18075 }
18076 arg1 = reinterpret_cast< wxImage * >(argp1);
18077 {
18078 arg2 = wxString_in_helper(obj1);
18079 if (arg2 == NULL) SWIG_fail;
18080 temp2 = true;
18081 }
18082 {
18083 arg3 = wxString_in_helper(obj2);
18084 if (arg3 == NULL) SWIG_fail;
18085 temp3 = true;
18086 }
18087 if (obj3) {
18088 ecode4 = SWIG_AsVal_int(obj3, &val4);
18089 if (!SWIG_IsOK(ecode4)) {
18090 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
18091 }
18092 arg4 = static_cast< int >(val4);
18093 }
18094 {
18095 PyThreadState* __tstate = wxPyBeginAllowThreads();
18096 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
18097 wxPyEndAllowThreads(__tstate);
18098 if (PyErr_Occurred()) SWIG_fail;
18099 }
18100 {
18101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18102 }
18103 {
18104 if (temp2)
18105 delete arg2;
18106 }
18107 {
18108 if (temp3)
18109 delete arg3;
18110 }
18111 return resultobj;
18112 fail:
18113 {
18114 if (temp2)
18115 delete arg2;
18116 }
18117 {
18118 if (temp3)
18119 delete arg3;
18120 }
18121 return NULL;
18122 }
18123
18124
18125 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18126 PyObject *resultobj = 0;
18127 wxImage *arg1 = (wxImage *) 0 ;
18128 wxString *arg2 = 0 ;
18129 int arg3 ;
18130 bool result;
18131 void *argp1 = 0 ;
18132 int res1 = 0 ;
18133 bool temp2 = false ;
18134 int val3 ;
18135 int ecode3 = 0 ;
18136 PyObject * obj0 = 0 ;
18137 PyObject * obj1 = 0 ;
18138 PyObject * obj2 = 0 ;
18139 char * kwnames[] = {
18140 (char *) "self",(char *) "name",(char *) "type", NULL
18141 };
18142
18143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18145 if (!SWIG_IsOK(res1)) {
18146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
18147 }
18148 arg1 = reinterpret_cast< wxImage * >(argp1);
18149 {
18150 arg2 = wxString_in_helper(obj1);
18151 if (arg2 == NULL) SWIG_fail;
18152 temp2 = true;
18153 }
18154 ecode3 = SWIG_AsVal_int(obj2, &val3);
18155 if (!SWIG_IsOK(ecode3)) {
18156 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
18157 }
18158 arg3 = static_cast< int >(val3);
18159 {
18160 PyThreadState* __tstate = wxPyBeginAllowThreads();
18161 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
18162 wxPyEndAllowThreads(__tstate);
18163 if (PyErr_Occurred()) SWIG_fail;
18164 }
18165 {
18166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18167 }
18168 {
18169 if (temp2)
18170 delete arg2;
18171 }
18172 return resultobj;
18173 fail:
18174 {
18175 if (temp2)
18176 delete arg2;
18177 }
18178 return NULL;
18179 }
18180
18181
18182 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18183 PyObject *resultobj = 0;
18184 wxImage *arg1 = (wxImage *) 0 ;
18185 wxString *arg2 = 0 ;
18186 wxString *arg3 = 0 ;
18187 bool result;
18188 void *argp1 = 0 ;
18189 int res1 = 0 ;
18190 bool temp2 = false ;
18191 bool temp3 = false ;
18192 PyObject * obj0 = 0 ;
18193 PyObject * obj1 = 0 ;
18194 PyObject * obj2 = 0 ;
18195 char * kwnames[] = {
18196 (char *) "self",(char *) "name",(char *) "mimetype", NULL
18197 };
18198
18199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18201 if (!SWIG_IsOK(res1)) {
18202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
18203 }
18204 arg1 = reinterpret_cast< wxImage * >(argp1);
18205 {
18206 arg2 = wxString_in_helper(obj1);
18207 if (arg2 == NULL) SWIG_fail;
18208 temp2 = true;
18209 }
18210 {
18211 arg3 = wxString_in_helper(obj2);
18212 if (arg3 == NULL) SWIG_fail;
18213 temp3 = true;
18214 }
18215 {
18216 PyThreadState* __tstate = wxPyBeginAllowThreads();
18217 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
18218 wxPyEndAllowThreads(__tstate);
18219 if (PyErr_Occurred()) SWIG_fail;
18220 }
18221 {
18222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18223 }
18224 {
18225 if (temp2)
18226 delete arg2;
18227 }
18228 {
18229 if (temp3)
18230 delete arg3;
18231 }
18232 return resultobj;
18233 fail:
18234 {
18235 if (temp2)
18236 delete arg2;
18237 }
18238 {
18239 if (temp3)
18240 delete arg3;
18241 }
18242 return NULL;
18243 }
18244
18245
18246 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18247 PyObject *resultobj = 0;
18248 wxInputStream *arg1 = 0 ;
18249 bool result;
18250 wxPyInputStream *temp1 ;
18251 bool created1 ;
18252 PyObject * obj0 = 0 ;
18253 char * kwnames[] = {
18254 (char *) "stream", NULL
18255 };
18256
18257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
18258 {
18259 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
18260 arg1 = temp1->m_wxis;
18261 created1 = false;
18262 } else {
18263 PyErr_Clear(); // clear the failure of the wxPyConvert above
18264 arg1 = wxPyCBInputStream_create(obj0, false);
18265 if (arg1 == NULL) {
18266 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
18267 SWIG_fail;
18268 }
18269 created1 = true;
18270 }
18271 }
18272 {
18273 PyThreadState* __tstate = wxPyBeginAllowThreads();
18274 result = (bool)wxImage::CanRead(*arg1);
18275 wxPyEndAllowThreads(__tstate);
18276 if (PyErr_Occurred()) SWIG_fail;
18277 }
18278 {
18279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18280 }
18281 {
18282 if (created1) delete arg1;
18283 }
18284 return resultobj;
18285 fail:
18286 {
18287 if (created1) delete arg1;
18288 }
18289 return NULL;
18290 }
18291
18292
18293 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18294 PyObject *resultobj = 0;
18295 wxImage *arg1 = (wxImage *) 0 ;
18296 wxInputStream *arg2 = 0 ;
18297 long arg3 = (long) wxBITMAP_TYPE_ANY ;
18298 int arg4 = (int) -1 ;
18299 bool result;
18300 void *argp1 = 0 ;
18301 int res1 = 0 ;
18302 wxPyInputStream *temp2 ;
18303 bool created2 ;
18304 long val3 ;
18305 int ecode3 = 0 ;
18306 int val4 ;
18307 int ecode4 = 0 ;
18308 PyObject * obj0 = 0 ;
18309 PyObject * obj1 = 0 ;
18310 PyObject * obj2 = 0 ;
18311 PyObject * obj3 = 0 ;
18312 char * kwnames[] = {
18313 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
18314 };
18315
18316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18318 if (!SWIG_IsOK(res1)) {
18319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
18320 }
18321 arg1 = reinterpret_cast< wxImage * >(argp1);
18322 {
18323 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
18324 arg2 = temp2->m_wxis;
18325 created2 = false;
18326 } else {
18327 PyErr_Clear(); // clear the failure of the wxPyConvert above
18328 arg2 = wxPyCBInputStream_create(obj1, false);
18329 if (arg2 == NULL) {
18330 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
18331 SWIG_fail;
18332 }
18333 created2 = true;
18334 }
18335 }
18336 if (obj2) {
18337 ecode3 = SWIG_AsVal_long(obj2, &val3);
18338 if (!SWIG_IsOK(ecode3)) {
18339 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
18340 }
18341 arg3 = static_cast< long >(val3);
18342 }
18343 if (obj3) {
18344 ecode4 = SWIG_AsVal_int(obj3, &val4);
18345 if (!SWIG_IsOK(ecode4)) {
18346 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
18347 }
18348 arg4 = static_cast< int >(val4);
18349 }
18350 {
18351 PyThreadState* __tstate = wxPyBeginAllowThreads();
18352 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
18353 wxPyEndAllowThreads(__tstate);
18354 if (PyErr_Occurred()) SWIG_fail;
18355 }
18356 {
18357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18358 }
18359 {
18360 if (created2) delete arg2;
18361 }
18362 return resultobj;
18363 fail:
18364 {
18365 if (created2) delete arg2;
18366 }
18367 return NULL;
18368 }
18369
18370
18371 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18372 PyObject *resultobj = 0;
18373 wxImage *arg1 = (wxImage *) 0 ;
18374 wxInputStream *arg2 = 0 ;
18375 wxString *arg3 = 0 ;
18376 int arg4 = (int) -1 ;
18377 bool result;
18378 void *argp1 = 0 ;
18379 int res1 = 0 ;
18380 wxPyInputStream *temp2 ;
18381 bool created2 ;
18382 bool temp3 = false ;
18383 int val4 ;
18384 int ecode4 = 0 ;
18385 PyObject * obj0 = 0 ;
18386 PyObject * obj1 = 0 ;
18387 PyObject * obj2 = 0 ;
18388 PyObject * obj3 = 0 ;
18389 char * kwnames[] = {
18390 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
18391 };
18392
18393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18395 if (!SWIG_IsOK(res1)) {
18396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
18397 }
18398 arg1 = reinterpret_cast< wxImage * >(argp1);
18399 {
18400 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
18401 arg2 = temp2->m_wxis;
18402 created2 = false;
18403 } else {
18404 PyErr_Clear(); // clear the failure of the wxPyConvert above
18405 arg2 = wxPyCBInputStream_create(obj1, false);
18406 if (arg2 == NULL) {
18407 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
18408 SWIG_fail;
18409 }
18410 created2 = true;
18411 }
18412 }
18413 {
18414 arg3 = wxString_in_helper(obj2);
18415 if (arg3 == NULL) SWIG_fail;
18416 temp3 = true;
18417 }
18418 if (obj3) {
18419 ecode4 = SWIG_AsVal_int(obj3, &val4);
18420 if (!SWIG_IsOK(ecode4)) {
18421 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
18422 }
18423 arg4 = static_cast< int >(val4);
18424 }
18425 {
18426 PyThreadState* __tstate = wxPyBeginAllowThreads();
18427 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
18428 wxPyEndAllowThreads(__tstate);
18429 if (PyErr_Occurred()) SWIG_fail;
18430 }
18431 {
18432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18433 }
18434 {
18435 if (created2) delete arg2;
18436 }
18437 {
18438 if (temp3)
18439 delete arg3;
18440 }
18441 return resultobj;
18442 fail:
18443 {
18444 if (created2) delete arg2;
18445 }
18446 {
18447 if (temp3)
18448 delete arg3;
18449 }
18450 return NULL;
18451 }
18452
18453
18454 SWIGINTERN PyObject *_wrap_Image_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18455 PyObject *resultobj = 0;
18456 wxImage *arg1 = (wxImage *) 0 ;
18457 bool result;
18458 void *argp1 = 0 ;
18459 int res1 = 0 ;
18460 PyObject *swig_obj[1] ;
18461
18462 if (!args) SWIG_fail;
18463 swig_obj[0] = args;
18464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18465 if (!SWIG_IsOK(res1)) {
18466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsOk" "', expected argument " "1"" of type '" "wxImage *""'");
18467 }
18468 arg1 = reinterpret_cast< wxImage * >(argp1);
18469 {
18470 PyThreadState* __tstate = wxPyBeginAllowThreads();
18471 result = (bool)(arg1)->IsOk();
18472 wxPyEndAllowThreads(__tstate);
18473 if (PyErr_Occurred()) SWIG_fail;
18474 }
18475 {
18476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18477 }
18478 return resultobj;
18479 fail:
18480 return NULL;
18481 }
18482
18483
18484 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18485 PyObject *resultobj = 0;
18486 wxImage *arg1 = (wxImage *) 0 ;
18487 int result;
18488 void *argp1 = 0 ;
18489 int res1 = 0 ;
18490 PyObject *swig_obj[1] ;
18491
18492 if (!args) SWIG_fail;
18493 swig_obj[0] = args;
18494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18495 if (!SWIG_IsOK(res1)) {
18496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
18497 }
18498 arg1 = reinterpret_cast< wxImage * >(argp1);
18499 {
18500 PyThreadState* __tstate = wxPyBeginAllowThreads();
18501 result = (int)(arg1)->GetWidth();
18502 wxPyEndAllowThreads(__tstate);
18503 if (PyErr_Occurred()) SWIG_fail;
18504 }
18505 resultobj = SWIG_From_int(static_cast< int >(result));
18506 return resultobj;
18507 fail:
18508 return NULL;
18509 }
18510
18511
18512 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18513 PyObject *resultobj = 0;
18514 wxImage *arg1 = (wxImage *) 0 ;
18515 int result;
18516 void *argp1 = 0 ;
18517 int res1 = 0 ;
18518 PyObject *swig_obj[1] ;
18519
18520 if (!args) SWIG_fail;
18521 swig_obj[0] = args;
18522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18523 if (!SWIG_IsOK(res1)) {
18524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
18525 }
18526 arg1 = reinterpret_cast< wxImage * >(argp1);
18527 {
18528 PyThreadState* __tstate = wxPyBeginAllowThreads();
18529 result = (int)(arg1)->GetHeight();
18530 wxPyEndAllowThreads(__tstate);
18531 if (PyErr_Occurred()) SWIG_fail;
18532 }
18533 resultobj = SWIG_From_int(static_cast< int >(result));
18534 return resultobj;
18535 fail:
18536 return NULL;
18537 }
18538
18539
18540 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18541 PyObject *resultobj = 0;
18542 wxImage *arg1 = (wxImage *) 0 ;
18543 wxSize result;
18544 void *argp1 = 0 ;
18545 int res1 = 0 ;
18546 PyObject *swig_obj[1] ;
18547
18548 if (!args) SWIG_fail;
18549 swig_obj[0] = args;
18550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18551 if (!SWIG_IsOK(res1)) {
18552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
18553 }
18554 arg1 = reinterpret_cast< wxImage * >(argp1);
18555 {
18556 PyThreadState* __tstate = wxPyBeginAllowThreads();
18557 result = wxImage_GetSize(arg1);
18558 wxPyEndAllowThreads(__tstate);
18559 if (PyErr_Occurred()) SWIG_fail;
18560 }
18561 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
18562 return resultobj;
18563 fail:
18564 return NULL;
18565 }
18566
18567
18568 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18569 PyObject *resultobj = 0;
18570 wxImage *arg1 = (wxImage *) 0 ;
18571 wxRect *arg2 = 0 ;
18572 SwigValueWrapper<wxImage > result;
18573 void *argp1 = 0 ;
18574 int res1 = 0 ;
18575 wxRect temp2 ;
18576 PyObject * obj0 = 0 ;
18577 PyObject * obj1 = 0 ;
18578 char * kwnames[] = {
18579 (char *) "self",(char *) "rect", NULL
18580 };
18581
18582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
18583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18584 if (!SWIG_IsOK(res1)) {
18585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
18586 }
18587 arg1 = reinterpret_cast< wxImage * >(argp1);
18588 {
18589 arg2 = &temp2;
18590 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
18591 }
18592 {
18593 PyThreadState* __tstate = wxPyBeginAllowThreads();
18594 result = (arg1)->GetSubImage((wxRect const &)*arg2);
18595 wxPyEndAllowThreads(__tstate);
18596 if (PyErr_Occurred()) SWIG_fail;
18597 }
18598 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18599 return resultobj;
18600 fail:
18601 return NULL;
18602 }
18603
18604
18605 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18606 PyObject *resultobj = 0;
18607 wxImage *arg1 = (wxImage *) 0 ;
18608 wxSize *arg2 = 0 ;
18609 wxPoint *arg3 = 0 ;
18610 int arg4 = (int) -1 ;
18611 int arg5 = (int) -1 ;
18612 int arg6 = (int) -1 ;
18613 SwigValueWrapper<wxImage > result;
18614 void *argp1 = 0 ;
18615 int res1 = 0 ;
18616 wxSize temp2 ;
18617 wxPoint temp3 ;
18618 int val4 ;
18619 int ecode4 = 0 ;
18620 int val5 ;
18621 int ecode5 = 0 ;
18622 int val6 ;
18623 int ecode6 = 0 ;
18624 PyObject * obj0 = 0 ;
18625 PyObject * obj1 = 0 ;
18626 PyObject * obj2 = 0 ;
18627 PyObject * obj3 = 0 ;
18628 PyObject * obj4 = 0 ;
18629 PyObject * obj5 = 0 ;
18630 char * kwnames[] = {
18631 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
18632 };
18633
18634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
18635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18636 if (!SWIG_IsOK(res1)) {
18637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
18638 }
18639 arg1 = reinterpret_cast< wxImage * >(argp1);
18640 {
18641 arg2 = &temp2;
18642 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
18643 }
18644 {
18645 arg3 = &temp3;
18646 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18647 }
18648 if (obj3) {
18649 ecode4 = SWIG_AsVal_int(obj3, &val4);
18650 if (!SWIG_IsOK(ecode4)) {
18651 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
18652 }
18653 arg4 = static_cast< int >(val4);
18654 }
18655 if (obj4) {
18656 ecode5 = SWIG_AsVal_int(obj4, &val5);
18657 if (!SWIG_IsOK(ecode5)) {
18658 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
18659 }
18660 arg5 = static_cast< int >(val5);
18661 }
18662 if (obj5) {
18663 ecode6 = SWIG_AsVal_int(obj5, &val6);
18664 if (!SWIG_IsOK(ecode6)) {
18665 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
18666 }
18667 arg6 = static_cast< int >(val6);
18668 }
18669 {
18670 PyThreadState* __tstate = wxPyBeginAllowThreads();
18671 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
18672 wxPyEndAllowThreads(__tstate);
18673 if (PyErr_Occurred()) SWIG_fail;
18674 }
18675 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18676 return resultobj;
18677 fail:
18678 return NULL;
18679 }
18680
18681
18682 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18683 PyObject *resultobj = 0;
18684 wxImage *arg1 = (wxImage *) 0 ;
18685 SwigValueWrapper<wxImage > result;
18686 void *argp1 = 0 ;
18687 int res1 = 0 ;
18688 PyObject *swig_obj[1] ;
18689
18690 if (!args) SWIG_fail;
18691 swig_obj[0] = args;
18692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18693 if (!SWIG_IsOK(res1)) {
18694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
18695 }
18696 arg1 = reinterpret_cast< wxImage * >(argp1);
18697 {
18698 PyThreadState* __tstate = wxPyBeginAllowThreads();
18699 result = (arg1)->Copy();
18700 wxPyEndAllowThreads(__tstate);
18701 if (PyErr_Occurred()) SWIG_fail;
18702 }
18703 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18704 return resultobj;
18705 fail:
18706 return NULL;
18707 }
18708
18709
18710 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18711 PyObject *resultobj = 0;
18712 wxImage *arg1 = (wxImage *) 0 ;
18713 wxImage *arg2 = 0 ;
18714 int arg3 ;
18715 int arg4 ;
18716 void *argp1 = 0 ;
18717 int res1 = 0 ;
18718 void *argp2 = 0 ;
18719 int res2 = 0 ;
18720 int val3 ;
18721 int ecode3 = 0 ;
18722 int val4 ;
18723 int ecode4 = 0 ;
18724 PyObject * obj0 = 0 ;
18725 PyObject * obj1 = 0 ;
18726 PyObject * obj2 = 0 ;
18727 PyObject * obj3 = 0 ;
18728 char * kwnames[] = {
18729 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
18730 };
18731
18732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18734 if (!SWIG_IsOK(res1)) {
18735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
18736 }
18737 arg1 = reinterpret_cast< wxImage * >(argp1);
18738 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
18739 if (!SWIG_IsOK(res2)) {
18740 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18741 }
18742 if (!argp2) {
18743 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18744 }
18745 arg2 = reinterpret_cast< wxImage * >(argp2);
18746 ecode3 = SWIG_AsVal_int(obj2, &val3);
18747 if (!SWIG_IsOK(ecode3)) {
18748 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
18749 }
18750 arg3 = static_cast< int >(val3);
18751 ecode4 = SWIG_AsVal_int(obj3, &val4);
18752 if (!SWIG_IsOK(ecode4)) {
18753 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
18754 }
18755 arg4 = static_cast< int >(val4);
18756 {
18757 PyThreadState* __tstate = wxPyBeginAllowThreads();
18758 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
18759 wxPyEndAllowThreads(__tstate);
18760 if (PyErr_Occurred()) SWIG_fail;
18761 }
18762 resultobj = SWIG_Py_Void();
18763 return resultobj;
18764 fail:
18765 return NULL;
18766 }
18767
18768
18769 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18770 PyObject *resultobj = 0;
18771 wxImage *arg1 = (wxImage *) 0 ;
18772 PyObject *result = 0 ;
18773 void *argp1 = 0 ;
18774 int res1 = 0 ;
18775 PyObject *swig_obj[1] ;
18776
18777 if (!args) SWIG_fail;
18778 swig_obj[0] = args;
18779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18780 if (!SWIG_IsOK(res1)) {
18781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
18782 }
18783 arg1 = reinterpret_cast< wxImage * >(argp1);
18784 {
18785 PyThreadState* __tstate = wxPyBeginAllowThreads();
18786 result = (PyObject *)wxImage_GetData(arg1);
18787 wxPyEndAllowThreads(__tstate);
18788 if (PyErr_Occurred()) SWIG_fail;
18789 }
18790 resultobj = result;
18791 return resultobj;
18792 fail:
18793 return NULL;
18794 }
18795
18796
18797 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18798 PyObject *resultobj = 0;
18799 wxImage *arg1 = (wxImage *) 0 ;
18800 buffer arg2 ;
18801 int arg3 ;
18802 void *argp1 = 0 ;
18803 int res1 = 0 ;
18804 Py_ssize_t temp2 ;
18805 PyObject * obj0 = 0 ;
18806 PyObject * obj1 = 0 ;
18807 char * kwnames[] = {
18808 (char *) "self",(char *) "data", NULL
18809 };
18810
18811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
18812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18813 if (!SWIG_IsOK(res1)) {
18814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
18815 }
18816 arg1 = reinterpret_cast< wxImage * >(argp1);
18817 {
18818 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18819 arg3 = (int)temp2;
18820 }
18821 {
18822 PyThreadState* __tstate = wxPyBeginAllowThreads();
18823 wxImage_SetData(arg1,arg2,arg3);
18824 wxPyEndAllowThreads(__tstate);
18825 if (PyErr_Occurred()) SWIG_fail;
18826 }
18827 resultobj = SWIG_Py_Void();
18828 return resultobj;
18829 fail:
18830 return NULL;
18831 }
18832
18833
18834 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18835 PyObject *resultobj = 0;
18836 wxImage *arg1 = (wxImage *) 0 ;
18837 PyObject *result = 0 ;
18838 void *argp1 = 0 ;
18839 int res1 = 0 ;
18840 PyObject *swig_obj[1] ;
18841
18842 if (!args) SWIG_fail;
18843 swig_obj[0] = args;
18844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18845 if (!SWIG_IsOK(res1)) {
18846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18847 }
18848 arg1 = reinterpret_cast< wxImage * >(argp1);
18849 {
18850 PyThreadState* __tstate = wxPyBeginAllowThreads();
18851 result = (PyObject *)wxImage_GetDataBuffer(arg1);
18852 wxPyEndAllowThreads(__tstate);
18853 if (PyErr_Occurred()) SWIG_fail;
18854 }
18855 resultobj = result;
18856 return resultobj;
18857 fail:
18858 return NULL;
18859 }
18860
18861
18862 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18863 PyObject *resultobj = 0;
18864 wxImage *arg1 = (wxImage *) 0 ;
18865 buffer arg2 ;
18866 int arg3 ;
18867 void *argp1 = 0 ;
18868 int res1 = 0 ;
18869 Py_ssize_t temp2 ;
18870 PyObject * obj0 = 0 ;
18871 PyObject * obj1 = 0 ;
18872 char * kwnames[] = {
18873 (char *) "self",(char *) "data", NULL
18874 };
18875
18876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18878 if (!SWIG_IsOK(res1)) {
18879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18880 }
18881 arg1 = reinterpret_cast< wxImage * >(argp1);
18882 {
18883 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18884 arg3 = (int)temp2;
18885 }
18886 {
18887 PyThreadState* __tstate = wxPyBeginAllowThreads();
18888 wxImage_SetDataBuffer(arg1,arg2,arg3);
18889 wxPyEndAllowThreads(__tstate);
18890 if (PyErr_Occurred()) SWIG_fail;
18891 }
18892 resultobj = SWIG_Py_Void();
18893 return resultobj;
18894 fail:
18895 return NULL;
18896 }
18897
18898
18899 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18900 PyObject *resultobj = 0;
18901 wxImage *arg1 = (wxImage *) 0 ;
18902 PyObject *result = 0 ;
18903 void *argp1 = 0 ;
18904 int res1 = 0 ;
18905 PyObject *swig_obj[1] ;
18906
18907 if (!args) SWIG_fail;
18908 swig_obj[0] = args;
18909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18910 if (!SWIG_IsOK(res1)) {
18911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18912 }
18913 arg1 = reinterpret_cast< wxImage * >(argp1);
18914 {
18915 PyThreadState* __tstate = wxPyBeginAllowThreads();
18916 result = (PyObject *)wxImage_GetAlphaData(arg1);
18917 wxPyEndAllowThreads(__tstate);
18918 if (PyErr_Occurred()) SWIG_fail;
18919 }
18920 resultobj = result;
18921 return resultobj;
18922 fail:
18923 return NULL;
18924 }
18925
18926
18927 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18928 PyObject *resultobj = 0;
18929 wxImage *arg1 = (wxImage *) 0 ;
18930 buffer arg2 ;
18931 int arg3 ;
18932 void *argp1 = 0 ;
18933 int res1 = 0 ;
18934 Py_ssize_t temp2 ;
18935 PyObject * obj0 = 0 ;
18936 PyObject * obj1 = 0 ;
18937 char * kwnames[] = {
18938 (char *) "self",(char *) "alpha", NULL
18939 };
18940
18941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
18942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18943 if (!SWIG_IsOK(res1)) {
18944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18945 }
18946 arg1 = reinterpret_cast< wxImage * >(argp1);
18947 {
18948 if (obj1 != Py_None) {
18949 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18950 arg3 = (int)temp2;
18951 }
18952 }
18953 {
18954 PyThreadState* __tstate = wxPyBeginAllowThreads();
18955 wxImage_SetAlphaData(arg1,arg2,arg3);
18956 wxPyEndAllowThreads(__tstate);
18957 if (PyErr_Occurred()) SWIG_fail;
18958 }
18959 resultobj = SWIG_Py_Void();
18960 return resultobj;
18961 fail:
18962 return NULL;
18963 }
18964
18965
18966 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18967 PyObject *resultobj = 0;
18968 wxImage *arg1 = (wxImage *) 0 ;
18969 PyObject *result = 0 ;
18970 void *argp1 = 0 ;
18971 int res1 = 0 ;
18972 PyObject *swig_obj[1] ;
18973
18974 if (!args) SWIG_fail;
18975 swig_obj[0] = args;
18976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18977 if (!SWIG_IsOK(res1)) {
18978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18979 }
18980 arg1 = reinterpret_cast< wxImage * >(argp1);
18981 {
18982 PyThreadState* __tstate = wxPyBeginAllowThreads();
18983 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
18984 wxPyEndAllowThreads(__tstate);
18985 if (PyErr_Occurred()) SWIG_fail;
18986 }
18987 resultobj = result;
18988 return resultobj;
18989 fail:
18990 return NULL;
18991 }
18992
18993
18994 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18995 PyObject *resultobj = 0;
18996 wxImage *arg1 = (wxImage *) 0 ;
18997 buffer arg2 ;
18998 int arg3 ;
18999 void *argp1 = 0 ;
19000 int res1 = 0 ;
19001 Py_ssize_t temp2 ;
19002 PyObject * obj0 = 0 ;
19003 PyObject * obj1 = 0 ;
19004 char * kwnames[] = {
19005 (char *) "self",(char *) "alpha", NULL
19006 };
19007
19008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
19009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19010 if (!SWIG_IsOK(res1)) {
19011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
19012 }
19013 arg1 = reinterpret_cast< wxImage * >(argp1);
19014 {
19015 if (obj1 != Py_None) {
19016 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
19017 arg3 = (int)temp2;
19018 }
19019 }
19020 {
19021 PyThreadState* __tstate = wxPyBeginAllowThreads();
19022 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
19023 wxPyEndAllowThreads(__tstate);
19024 if (PyErr_Occurred()) SWIG_fail;
19025 }
19026 resultobj = SWIG_Py_Void();
19027 return resultobj;
19028 fail:
19029 return NULL;
19030 }
19031
19032
19033 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19034 PyObject *resultobj = 0;
19035 wxImage *arg1 = (wxImage *) 0 ;
19036 byte arg2 ;
19037 byte arg3 ;
19038 byte arg4 ;
19039 void *argp1 = 0 ;
19040 int res1 = 0 ;
19041 unsigned char val2 ;
19042 int ecode2 = 0 ;
19043 unsigned char val3 ;
19044 int ecode3 = 0 ;
19045 unsigned char val4 ;
19046 int ecode4 = 0 ;
19047 PyObject * obj0 = 0 ;
19048 PyObject * obj1 = 0 ;
19049 PyObject * obj2 = 0 ;
19050 PyObject * obj3 = 0 ;
19051 char * kwnames[] = {
19052 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
19053 };
19054
19055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19057 if (!SWIG_IsOK(res1)) {
19058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
19059 }
19060 arg1 = reinterpret_cast< wxImage * >(argp1);
19061 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19062 if (!SWIG_IsOK(ecode2)) {
19063 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
19064 }
19065 arg2 = static_cast< byte >(val2);
19066 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19067 if (!SWIG_IsOK(ecode3)) {
19068 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
19069 }
19070 arg3 = static_cast< byte >(val3);
19071 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19072 if (!SWIG_IsOK(ecode4)) {
19073 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
19074 }
19075 arg4 = static_cast< byte >(val4);
19076 {
19077 PyThreadState* __tstate = wxPyBeginAllowThreads();
19078 (arg1)->SetMaskColour(arg2,arg3,arg4);
19079 wxPyEndAllowThreads(__tstate);
19080 if (PyErr_Occurred()) SWIG_fail;
19081 }
19082 resultobj = SWIG_Py_Void();
19083 return resultobj;
19084 fail:
19085 return NULL;
19086 }
19087
19088
19089 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19090 PyObject *resultobj = 0;
19091 wxImage *arg1 = (wxImage *) 0 ;
19092 byte *arg2 = (byte *) 0 ;
19093 byte *arg3 = (byte *) 0 ;
19094 byte *arg4 = (byte *) 0 ;
19095 void *argp1 = 0 ;
19096 int res1 = 0 ;
19097 byte temp2 ;
19098 int res2 = SWIG_TMPOBJ ;
19099 byte temp3 ;
19100 int res3 = SWIG_TMPOBJ ;
19101 byte temp4 ;
19102 int res4 = SWIG_TMPOBJ ;
19103 PyObject *swig_obj[1] ;
19104
19105 arg2 = &temp2;
19106 arg3 = &temp3;
19107 arg4 = &temp4;
19108 if (!args) SWIG_fail;
19109 swig_obj[0] = args;
19110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19111 if (!SWIG_IsOK(res1)) {
19112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
19113 }
19114 arg1 = reinterpret_cast< wxImage * >(argp1);
19115 {
19116 PyThreadState* __tstate = wxPyBeginAllowThreads();
19117 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
19118 wxPyEndAllowThreads(__tstate);
19119 if (PyErr_Occurred()) SWIG_fail;
19120 }
19121 resultobj = SWIG_Py_Void();
19122 if (SWIG_IsTmpObj(res2)) {
19123 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
19124 } else {
19125 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19126 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
19127 }
19128 if (SWIG_IsTmpObj(res3)) {
19129 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
19130 } else {
19131 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19132 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
19133 }
19134 if (SWIG_IsTmpObj(res4)) {
19135 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
19136 } else {
19137 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19138 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
19139 }
19140 return resultobj;
19141 fail:
19142 return NULL;
19143 }
19144
19145
19146 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19147 PyObject *resultobj = 0;
19148 wxImage *arg1 = (wxImage *) 0 ;
19149 byte result;
19150 void *argp1 = 0 ;
19151 int res1 = 0 ;
19152 PyObject *swig_obj[1] ;
19153
19154 if (!args) SWIG_fail;
19155 swig_obj[0] = args;
19156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19157 if (!SWIG_IsOK(res1)) {
19158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
19159 }
19160 arg1 = reinterpret_cast< wxImage * >(argp1);
19161 {
19162 PyThreadState* __tstate = wxPyBeginAllowThreads();
19163 result = (byte)(arg1)->GetMaskRed();
19164 wxPyEndAllowThreads(__tstate);
19165 if (PyErr_Occurred()) SWIG_fail;
19166 }
19167 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
19168 return resultobj;
19169 fail:
19170 return NULL;
19171 }
19172
19173
19174 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19175 PyObject *resultobj = 0;
19176 wxImage *arg1 = (wxImage *) 0 ;
19177 byte result;
19178 void *argp1 = 0 ;
19179 int res1 = 0 ;
19180 PyObject *swig_obj[1] ;
19181
19182 if (!args) SWIG_fail;
19183 swig_obj[0] = args;
19184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19185 if (!SWIG_IsOK(res1)) {
19186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
19187 }
19188 arg1 = reinterpret_cast< wxImage * >(argp1);
19189 {
19190 PyThreadState* __tstate = wxPyBeginAllowThreads();
19191 result = (byte)(arg1)->GetMaskGreen();
19192 wxPyEndAllowThreads(__tstate);
19193 if (PyErr_Occurred()) SWIG_fail;
19194 }
19195 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
19196 return resultobj;
19197 fail:
19198 return NULL;
19199 }
19200
19201
19202 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19203 PyObject *resultobj = 0;
19204 wxImage *arg1 = (wxImage *) 0 ;
19205 byte result;
19206 void *argp1 = 0 ;
19207 int res1 = 0 ;
19208 PyObject *swig_obj[1] ;
19209
19210 if (!args) SWIG_fail;
19211 swig_obj[0] = args;
19212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19213 if (!SWIG_IsOK(res1)) {
19214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
19215 }
19216 arg1 = reinterpret_cast< wxImage * >(argp1);
19217 {
19218 PyThreadState* __tstate = wxPyBeginAllowThreads();
19219 result = (byte)(arg1)->GetMaskBlue();
19220 wxPyEndAllowThreads(__tstate);
19221 if (PyErr_Occurred()) SWIG_fail;
19222 }
19223 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
19224 return resultobj;
19225 fail:
19226 return NULL;
19227 }
19228
19229
19230 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19231 PyObject *resultobj = 0;
19232 wxImage *arg1 = (wxImage *) 0 ;
19233 bool arg2 = (bool) true ;
19234 void *argp1 = 0 ;
19235 int res1 = 0 ;
19236 bool val2 ;
19237 int ecode2 = 0 ;
19238 PyObject * obj0 = 0 ;
19239 PyObject * obj1 = 0 ;
19240 char * kwnames[] = {
19241 (char *) "self",(char *) "mask", NULL
19242 };
19243
19244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
19245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19246 if (!SWIG_IsOK(res1)) {
19247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
19248 }
19249 arg1 = reinterpret_cast< wxImage * >(argp1);
19250 if (obj1) {
19251 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19252 if (!SWIG_IsOK(ecode2)) {
19253 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
19254 }
19255 arg2 = static_cast< bool >(val2);
19256 }
19257 {
19258 PyThreadState* __tstate = wxPyBeginAllowThreads();
19259 (arg1)->SetMask(arg2);
19260 wxPyEndAllowThreads(__tstate);
19261 if (PyErr_Occurred()) SWIG_fail;
19262 }
19263 resultobj = SWIG_Py_Void();
19264 return resultobj;
19265 fail:
19266 return NULL;
19267 }
19268
19269
19270 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19271 PyObject *resultobj = 0;
19272 wxImage *arg1 = (wxImage *) 0 ;
19273 bool result;
19274 void *argp1 = 0 ;
19275 int res1 = 0 ;
19276 PyObject *swig_obj[1] ;
19277
19278 if (!args) SWIG_fail;
19279 swig_obj[0] = args;
19280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19281 if (!SWIG_IsOK(res1)) {
19282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
19283 }
19284 arg1 = reinterpret_cast< wxImage * >(argp1);
19285 {
19286 PyThreadState* __tstate = wxPyBeginAllowThreads();
19287 result = (bool)(arg1)->HasMask();
19288 wxPyEndAllowThreads(__tstate);
19289 if (PyErr_Occurred()) SWIG_fail;
19290 }
19291 {
19292 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19293 }
19294 return resultobj;
19295 fail:
19296 return NULL;
19297 }
19298
19299
19300 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19301 PyObject *resultobj = 0;
19302 wxImage *arg1 = (wxImage *) 0 ;
19303 double arg2 ;
19304 wxPoint *arg3 = 0 ;
19305 bool arg4 = (bool) true ;
19306 wxPoint *arg5 = (wxPoint *) NULL ;
19307 SwigValueWrapper<wxImage > result;
19308 void *argp1 = 0 ;
19309 int res1 = 0 ;
19310 double val2 ;
19311 int ecode2 = 0 ;
19312 wxPoint temp3 ;
19313 bool val4 ;
19314 int ecode4 = 0 ;
19315 void *argp5 = 0 ;
19316 int res5 = 0 ;
19317 PyObject * obj0 = 0 ;
19318 PyObject * obj1 = 0 ;
19319 PyObject * obj2 = 0 ;
19320 PyObject * obj3 = 0 ;
19321 PyObject * obj4 = 0 ;
19322 char * kwnames[] = {
19323 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
19324 };
19325
19326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
19327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19328 if (!SWIG_IsOK(res1)) {
19329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
19330 }
19331 arg1 = reinterpret_cast< wxImage * >(argp1);
19332 ecode2 = SWIG_AsVal_double(obj1, &val2);
19333 if (!SWIG_IsOK(ecode2)) {
19334 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
19335 }
19336 arg2 = static_cast< double >(val2);
19337 {
19338 arg3 = &temp3;
19339 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
19340 }
19341 if (obj3) {
19342 ecode4 = SWIG_AsVal_bool(obj3, &val4);
19343 if (!SWIG_IsOK(ecode4)) {
19344 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
19345 }
19346 arg4 = static_cast< bool >(val4);
19347 }
19348 if (obj4) {
19349 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
19350 if (!SWIG_IsOK(res5)) {
19351 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
19352 }
19353 arg5 = reinterpret_cast< wxPoint * >(argp5);
19354 }
19355 {
19356 PyThreadState* __tstate = wxPyBeginAllowThreads();
19357 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
19358 wxPyEndAllowThreads(__tstate);
19359 if (PyErr_Occurred()) SWIG_fail;
19360 }
19361 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19362 return resultobj;
19363 fail:
19364 return NULL;
19365 }
19366
19367
19368 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19369 PyObject *resultobj = 0;
19370 wxImage *arg1 = (wxImage *) 0 ;
19371 bool arg2 = (bool) true ;
19372 SwigValueWrapper<wxImage > result;
19373 void *argp1 = 0 ;
19374 int res1 = 0 ;
19375 bool val2 ;
19376 int ecode2 = 0 ;
19377 PyObject * obj0 = 0 ;
19378 PyObject * obj1 = 0 ;
19379 char * kwnames[] = {
19380 (char *) "self",(char *) "clockwise", NULL
19381 };
19382
19383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
19384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19385 if (!SWIG_IsOK(res1)) {
19386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
19387 }
19388 arg1 = reinterpret_cast< wxImage * >(argp1);
19389 if (obj1) {
19390 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19391 if (!SWIG_IsOK(ecode2)) {
19392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
19393 }
19394 arg2 = static_cast< bool >(val2);
19395 }
19396 {
19397 PyThreadState* __tstate = wxPyBeginAllowThreads();
19398 result = (arg1)->Rotate90(arg2);
19399 wxPyEndAllowThreads(__tstate);
19400 if (PyErr_Occurred()) SWIG_fail;
19401 }
19402 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19403 return resultobj;
19404 fail:
19405 return NULL;
19406 }
19407
19408
19409 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19410 PyObject *resultobj = 0;
19411 wxImage *arg1 = (wxImage *) 0 ;
19412 bool arg2 = (bool) true ;
19413 SwigValueWrapper<wxImage > result;
19414 void *argp1 = 0 ;
19415 int res1 = 0 ;
19416 bool val2 ;
19417 int ecode2 = 0 ;
19418 PyObject * obj0 = 0 ;
19419 PyObject * obj1 = 0 ;
19420 char * kwnames[] = {
19421 (char *) "self",(char *) "horizontally", NULL
19422 };
19423
19424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
19425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19426 if (!SWIG_IsOK(res1)) {
19427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
19428 }
19429 arg1 = reinterpret_cast< wxImage * >(argp1);
19430 if (obj1) {
19431 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19432 if (!SWIG_IsOK(ecode2)) {
19433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
19434 }
19435 arg2 = static_cast< bool >(val2);
19436 }
19437 {
19438 PyThreadState* __tstate = wxPyBeginAllowThreads();
19439 result = (arg1)->Mirror(arg2);
19440 wxPyEndAllowThreads(__tstate);
19441 if (PyErr_Occurred()) SWIG_fail;
19442 }
19443 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19444 return resultobj;
19445 fail:
19446 return NULL;
19447 }
19448
19449
19450 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19451 PyObject *resultobj = 0;
19452 wxImage *arg1 = (wxImage *) 0 ;
19453 byte arg2 ;
19454 byte arg3 ;
19455 byte arg4 ;
19456 byte arg5 ;
19457 byte arg6 ;
19458 byte arg7 ;
19459 void *argp1 = 0 ;
19460 int res1 = 0 ;
19461 unsigned char val2 ;
19462 int ecode2 = 0 ;
19463 unsigned char val3 ;
19464 int ecode3 = 0 ;
19465 unsigned char val4 ;
19466 int ecode4 = 0 ;
19467 unsigned char val5 ;
19468 int ecode5 = 0 ;
19469 unsigned char val6 ;
19470 int ecode6 = 0 ;
19471 unsigned char val7 ;
19472 int ecode7 = 0 ;
19473 PyObject * obj0 = 0 ;
19474 PyObject * obj1 = 0 ;
19475 PyObject * obj2 = 0 ;
19476 PyObject * obj3 = 0 ;
19477 PyObject * obj4 = 0 ;
19478 PyObject * obj5 = 0 ;
19479 PyObject * obj6 = 0 ;
19480 char * kwnames[] = {
19481 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
19482 };
19483
19484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
19485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19486 if (!SWIG_IsOK(res1)) {
19487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
19488 }
19489 arg1 = reinterpret_cast< wxImage * >(argp1);
19490 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19491 if (!SWIG_IsOK(ecode2)) {
19492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
19493 }
19494 arg2 = static_cast< byte >(val2);
19495 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19496 if (!SWIG_IsOK(ecode3)) {
19497 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
19498 }
19499 arg3 = static_cast< byte >(val3);
19500 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19501 if (!SWIG_IsOK(ecode4)) {
19502 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
19503 }
19504 arg4 = static_cast< byte >(val4);
19505 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
19506 if (!SWIG_IsOK(ecode5)) {
19507 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
19508 }
19509 arg5 = static_cast< byte >(val5);
19510 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
19511 if (!SWIG_IsOK(ecode6)) {
19512 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
19513 }
19514 arg6 = static_cast< byte >(val6);
19515 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
19516 if (!SWIG_IsOK(ecode7)) {
19517 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
19518 }
19519 arg7 = static_cast< byte >(val7);
19520 {
19521 PyThreadState* __tstate = wxPyBeginAllowThreads();
19522 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
19523 wxPyEndAllowThreads(__tstate);
19524 if (PyErr_Occurred()) SWIG_fail;
19525 }
19526 resultobj = SWIG_Py_Void();
19527 return resultobj;
19528 fail:
19529 return NULL;
19530 }
19531
19532
19533 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19534 PyObject *resultobj = 0;
19535 wxImage *arg1 = (wxImage *) 0 ;
19536 double arg2 = (double) 0.299 ;
19537 double arg3 = (double) 0.587 ;
19538 double arg4 = (double) 0.114 ;
19539 SwigValueWrapper<wxImage > result;
19540 void *argp1 = 0 ;
19541 int res1 = 0 ;
19542 double val2 ;
19543 int ecode2 = 0 ;
19544 double val3 ;
19545 int ecode3 = 0 ;
19546 double val4 ;
19547 int ecode4 = 0 ;
19548 PyObject * obj0 = 0 ;
19549 PyObject * obj1 = 0 ;
19550 PyObject * obj2 = 0 ;
19551 PyObject * obj3 = 0 ;
19552 char * kwnames[] = {
19553 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
19554 };
19555
19556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19558 if (!SWIG_IsOK(res1)) {
19559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
19560 }
19561 arg1 = reinterpret_cast< wxImage * >(argp1);
19562 if (obj1) {
19563 ecode2 = SWIG_AsVal_double(obj1, &val2);
19564 if (!SWIG_IsOK(ecode2)) {
19565 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
19566 }
19567 arg2 = static_cast< double >(val2);
19568 }
19569 if (obj2) {
19570 ecode3 = SWIG_AsVal_double(obj2, &val3);
19571 if (!SWIG_IsOK(ecode3)) {
19572 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
19573 }
19574 arg3 = static_cast< double >(val3);
19575 }
19576 if (obj3) {
19577 ecode4 = SWIG_AsVal_double(obj3, &val4);
19578 if (!SWIG_IsOK(ecode4)) {
19579 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
19580 }
19581 arg4 = static_cast< double >(val4);
19582 }
19583 {
19584 PyThreadState* __tstate = wxPyBeginAllowThreads();
19585 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
19586 wxPyEndAllowThreads(__tstate);
19587 if (PyErr_Occurred()) SWIG_fail;
19588 }
19589 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19590 return resultobj;
19591 fail:
19592 return NULL;
19593 }
19594
19595
19596 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19597 PyObject *resultobj = 0;
19598 wxImage *arg1 = (wxImage *) 0 ;
19599 byte arg2 ;
19600 byte arg3 ;
19601 byte arg4 ;
19602 SwigValueWrapper<wxImage > result;
19603 void *argp1 = 0 ;
19604 int res1 = 0 ;
19605 unsigned char val2 ;
19606 int ecode2 = 0 ;
19607 unsigned char val3 ;
19608 int ecode3 = 0 ;
19609 unsigned char val4 ;
19610 int ecode4 = 0 ;
19611 PyObject * obj0 = 0 ;
19612 PyObject * obj1 = 0 ;
19613 PyObject * obj2 = 0 ;
19614 PyObject * obj3 = 0 ;
19615 char * kwnames[] = {
19616 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
19617 };
19618
19619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19621 if (!SWIG_IsOK(res1)) {
19622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
19623 }
19624 arg1 = reinterpret_cast< wxImage * >(argp1);
19625 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19626 if (!SWIG_IsOK(ecode2)) {
19627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
19628 }
19629 arg2 = static_cast< byte >(val2);
19630 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19631 if (!SWIG_IsOK(ecode3)) {
19632 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
19633 }
19634 arg3 = static_cast< byte >(val3);
19635 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19636 if (!SWIG_IsOK(ecode4)) {
19637 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
19638 }
19639 arg4 = static_cast< byte >(val4);
19640 {
19641 PyThreadState* __tstate = wxPyBeginAllowThreads();
19642 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
19643 wxPyEndAllowThreads(__tstate);
19644 if (PyErr_Occurred()) SWIG_fail;
19645 }
19646 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19647 return resultobj;
19648 fail:
19649 return NULL;
19650 }
19651
19652
19653 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19654 PyObject *resultobj = 0;
19655 wxImage *arg1 = (wxImage *) 0 ;
19656 wxString *arg2 = 0 ;
19657 wxString *arg3 = 0 ;
19658 void *argp1 = 0 ;
19659 int res1 = 0 ;
19660 bool temp2 = false ;
19661 bool temp3 = false ;
19662 PyObject * obj0 = 0 ;
19663 PyObject * obj1 = 0 ;
19664 PyObject * obj2 = 0 ;
19665 char * kwnames[] = {
19666 (char *) "self",(char *) "name",(char *) "value", NULL
19667 };
19668
19669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19671 if (!SWIG_IsOK(res1)) {
19672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
19673 }
19674 arg1 = reinterpret_cast< wxImage * >(argp1);
19675 {
19676 arg2 = wxString_in_helper(obj1);
19677 if (arg2 == NULL) SWIG_fail;
19678 temp2 = true;
19679 }
19680 {
19681 arg3 = wxString_in_helper(obj2);
19682 if (arg3 == NULL) SWIG_fail;
19683 temp3 = true;
19684 }
19685 {
19686 PyThreadState* __tstate = wxPyBeginAllowThreads();
19687 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
19688 wxPyEndAllowThreads(__tstate);
19689 if (PyErr_Occurred()) SWIG_fail;
19690 }
19691 resultobj = SWIG_Py_Void();
19692 {
19693 if (temp2)
19694 delete arg2;
19695 }
19696 {
19697 if (temp3)
19698 delete arg3;
19699 }
19700 return resultobj;
19701 fail:
19702 {
19703 if (temp2)
19704 delete arg2;
19705 }
19706 {
19707 if (temp3)
19708 delete arg3;
19709 }
19710 return NULL;
19711 }
19712
19713
19714 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19715 PyObject *resultobj = 0;
19716 wxImage *arg1 = (wxImage *) 0 ;
19717 wxString *arg2 = 0 ;
19718 int arg3 ;
19719 void *argp1 = 0 ;
19720 int res1 = 0 ;
19721 bool temp2 = false ;
19722 int val3 ;
19723 int ecode3 = 0 ;
19724 PyObject * obj0 = 0 ;
19725 PyObject * obj1 = 0 ;
19726 PyObject * obj2 = 0 ;
19727 char * kwnames[] = {
19728 (char *) "self",(char *) "name",(char *) "value", NULL
19729 };
19730
19731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19733 if (!SWIG_IsOK(res1)) {
19734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
19735 }
19736 arg1 = reinterpret_cast< wxImage * >(argp1);
19737 {
19738 arg2 = wxString_in_helper(obj1);
19739 if (arg2 == NULL) SWIG_fail;
19740 temp2 = true;
19741 }
19742 ecode3 = SWIG_AsVal_int(obj2, &val3);
19743 if (!SWIG_IsOK(ecode3)) {
19744 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
19745 }
19746 arg3 = static_cast< int >(val3);
19747 {
19748 PyThreadState* __tstate = wxPyBeginAllowThreads();
19749 (arg1)->SetOption((wxString const &)*arg2,arg3);
19750 wxPyEndAllowThreads(__tstate);
19751 if (PyErr_Occurred()) SWIG_fail;
19752 }
19753 resultobj = SWIG_Py_Void();
19754 {
19755 if (temp2)
19756 delete arg2;
19757 }
19758 return resultobj;
19759 fail:
19760 {
19761 if (temp2)
19762 delete arg2;
19763 }
19764 return NULL;
19765 }
19766
19767
19768 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19769 PyObject *resultobj = 0;
19770 wxImage *arg1 = (wxImage *) 0 ;
19771 wxString *arg2 = 0 ;
19772 wxString result;
19773 void *argp1 = 0 ;
19774 int res1 = 0 ;
19775 bool temp2 = false ;
19776 PyObject * obj0 = 0 ;
19777 PyObject * obj1 = 0 ;
19778 char * kwnames[] = {
19779 (char *) "self",(char *) "name", NULL
19780 };
19781
19782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
19783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19784 if (!SWIG_IsOK(res1)) {
19785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19786 }
19787 arg1 = reinterpret_cast< wxImage * >(argp1);
19788 {
19789 arg2 = wxString_in_helper(obj1);
19790 if (arg2 == NULL) SWIG_fail;
19791 temp2 = true;
19792 }
19793 {
19794 PyThreadState* __tstate = wxPyBeginAllowThreads();
19795 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
19796 wxPyEndAllowThreads(__tstate);
19797 if (PyErr_Occurred()) SWIG_fail;
19798 }
19799 {
19800 #if wxUSE_UNICODE
19801 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19802 #else
19803 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19804 #endif
19805 }
19806 {
19807 if (temp2)
19808 delete arg2;
19809 }
19810 return resultobj;
19811 fail:
19812 {
19813 if (temp2)
19814 delete arg2;
19815 }
19816 return NULL;
19817 }
19818
19819
19820 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19821 PyObject *resultobj = 0;
19822 wxImage *arg1 = (wxImage *) 0 ;
19823 wxString *arg2 = 0 ;
19824 int result;
19825 void *argp1 = 0 ;
19826 int res1 = 0 ;
19827 bool temp2 = false ;
19828 PyObject * obj0 = 0 ;
19829 PyObject * obj1 = 0 ;
19830 char * kwnames[] = {
19831 (char *) "self",(char *) "name", NULL
19832 };
19833
19834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
19835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19836 if (!SWIG_IsOK(res1)) {
19837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
19838 }
19839 arg1 = reinterpret_cast< wxImage * >(argp1);
19840 {
19841 arg2 = wxString_in_helper(obj1);
19842 if (arg2 == NULL) SWIG_fail;
19843 temp2 = true;
19844 }
19845 {
19846 PyThreadState* __tstate = wxPyBeginAllowThreads();
19847 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
19848 wxPyEndAllowThreads(__tstate);
19849 if (PyErr_Occurred()) SWIG_fail;
19850 }
19851 resultobj = SWIG_From_int(static_cast< int >(result));
19852 {
19853 if (temp2)
19854 delete arg2;
19855 }
19856 return resultobj;
19857 fail:
19858 {
19859 if (temp2)
19860 delete arg2;
19861 }
19862 return NULL;
19863 }
19864
19865
19866 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19867 PyObject *resultobj = 0;
19868 wxImage *arg1 = (wxImage *) 0 ;
19869 wxString *arg2 = 0 ;
19870 bool result;
19871 void *argp1 = 0 ;
19872 int res1 = 0 ;
19873 bool temp2 = false ;
19874 PyObject * obj0 = 0 ;
19875 PyObject * obj1 = 0 ;
19876 char * kwnames[] = {
19877 (char *) "self",(char *) "name", NULL
19878 };
19879
19880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
19881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19882 if (!SWIG_IsOK(res1)) {
19883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19884 }
19885 arg1 = reinterpret_cast< wxImage * >(argp1);
19886 {
19887 arg2 = wxString_in_helper(obj1);
19888 if (arg2 == NULL) SWIG_fail;
19889 temp2 = true;
19890 }
19891 {
19892 PyThreadState* __tstate = wxPyBeginAllowThreads();
19893 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
19894 wxPyEndAllowThreads(__tstate);
19895 if (PyErr_Occurred()) SWIG_fail;
19896 }
19897 {
19898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19899 }
19900 {
19901 if (temp2)
19902 delete arg2;
19903 }
19904 return resultobj;
19905 fail:
19906 {
19907 if (temp2)
19908 delete arg2;
19909 }
19910 return NULL;
19911 }
19912
19913
19914 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19915 PyObject *resultobj = 0;
19916 wxImage *arg1 = (wxImage *) 0 ;
19917 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
19918 unsigned long result;
19919 void *argp1 = 0 ;
19920 int res1 = 0 ;
19921 unsigned long val2 ;
19922 int ecode2 = 0 ;
19923 PyObject * obj0 = 0 ;
19924 PyObject * obj1 = 0 ;
19925 char * kwnames[] = {
19926 (char *) "self",(char *) "stopafter", NULL
19927 };
19928
19929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
19930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19931 if (!SWIG_IsOK(res1)) {
19932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
19933 }
19934 arg1 = reinterpret_cast< wxImage * >(argp1);
19935 if (obj1) {
19936 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
19937 if (!SWIG_IsOK(ecode2)) {
19938 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
19939 }
19940 arg2 = static_cast< unsigned long >(val2);
19941 }
19942 {
19943 PyThreadState* __tstate = wxPyBeginAllowThreads();
19944 result = (unsigned long)(arg1)->CountColours(arg2);
19945 wxPyEndAllowThreads(__tstate);
19946 if (PyErr_Occurred()) SWIG_fail;
19947 }
19948 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19949 return resultobj;
19950 fail:
19951 return NULL;
19952 }
19953
19954
19955 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19956 PyObject *resultobj = 0;
19957 wxImage *arg1 = (wxImage *) 0 ;
19958 wxImageHistogram *arg2 = 0 ;
19959 unsigned long result;
19960 void *argp1 = 0 ;
19961 int res1 = 0 ;
19962 void *argp2 = 0 ;
19963 int res2 = 0 ;
19964 PyObject * obj0 = 0 ;
19965 PyObject * obj1 = 0 ;
19966 char * kwnames[] = {
19967 (char *) "self",(char *) "h", NULL
19968 };
19969
19970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
19971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19972 if (!SWIG_IsOK(res1)) {
19973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
19974 }
19975 arg1 = reinterpret_cast< wxImage * >(argp1);
19976 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
19977 if (!SWIG_IsOK(res2)) {
19978 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19979 }
19980 if (!argp2) {
19981 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19982 }
19983 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
19984 {
19985 PyThreadState* __tstate = wxPyBeginAllowThreads();
19986 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
19987 wxPyEndAllowThreads(__tstate);
19988 if (PyErr_Occurred()) SWIG_fail;
19989 }
19990 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19991 return resultobj;
19992 fail:
19993 return NULL;
19994 }
19995
19996
19997 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19998 PyObject *resultobj = 0;
19999 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
20000 void *argp1 = 0 ;
20001 int res1 = 0 ;
20002 PyObject * obj0 = 0 ;
20003 char * kwnames[] = {
20004 (char *) "handler", NULL
20005 };
20006
20007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
20008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
20009 if (!SWIG_IsOK(res1)) {
20010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
20011 }
20012 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
20013 {
20014 PyThreadState* __tstate = wxPyBeginAllowThreads();
20015 wxImage::AddHandler(arg1);
20016 wxPyEndAllowThreads(__tstate);
20017 if (PyErr_Occurred()) SWIG_fail;
20018 }
20019 resultobj = SWIG_Py_Void();
20020 return resultobj;
20021 fail:
20022 return NULL;
20023 }
20024
20025
20026 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20027 PyObject *resultobj = 0;
20028 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
20029 void *argp1 = 0 ;
20030 int res1 = 0 ;
20031 PyObject * obj0 = 0 ;
20032 char * kwnames[] = {
20033 (char *) "handler", NULL
20034 };
20035
20036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
20037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
20038 if (!SWIG_IsOK(res1)) {
20039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
20040 }
20041 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
20042 {
20043 PyThreadState* __tstate = wxPyBeginAllowThreads();
20044 wxImage::InsertHandler(arg1);
20045 wxPyEndAllowThreads(__tstate);
20046 if (PyErr_Occurred()) SWIG_fail;
20047 }
20048 resultobj = SWIG_Py_Void();
20049 return resultobj;
20050 fail:
20051 return NULL;
20052 }
20053
20054
20055 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20056 PyObject *resultobj = 0;
20057 wxString *arg1 = 0 ;
20058 bool result;
20059 bool temp1 = false ;
20060 PyObject * obj0 = 0 ;
20061 char * kwnames[] = {
20062 (char *) "name", NULL
20063 };
20064
20065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
20066 {
20067 arg1 = wxString_in_helper(obj0);
20068 if (arg1 == NULL) SWIG_fail;
20069 temp1 = true;
20070 }
20071 {
20072 PyThreadState* __tstate = wxPyBeginAllowThreads();
20073 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
20074 wxPyEndAllowThreads(__tstate);
20075 if (PyErr_Occurred()) SWIG_fail;
20076 }
20077 {
20078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20079 }
20080 {
20081 if (temp1)
20082 delete arg1;
20083 }
20084 return resultobj;
20085 fail:
20086 {
20087 if (temp1)
20088 delete arg1;
20089 }
20090 return NULL;
20091 }
20092
20093
20094 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20095 PyObject *resultobj = 0;
20096 PyObject *result = 0 ;
20097
20098 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
20099 {
20100 PyThreadState* __tstate = wxPyBeginAllowThreads();
20101 result = (PyObject *)wxImage_GetHandlers();
20102 wxPyEndAllowThreads(__tstate);
20103 if (PyErr_Occurred()) SWIG_fail;
20104 }
20105 resultobj = result;
20106 return resultobj;
20107 fail:
20108 return NULL;
20109 }
20110
20111
20112 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20113 PyObject *resultobj = 0;
20114 wxString result;
20115
20116 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
20117 {
20118 PyThreadState* __tstate = wxPyBeginAllowThreads();
20119 result = wxImage::GetImageExtWildcard();
20120 wxPyEndAllowThreads(__tstate);
20121 if (PyErr_Occurred()) SWIG_fail;
20122 }
20123 {
20124 #if wxUSE_UNICODE
20125 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20126 #else
20127 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20128 #endif
20129 }
20130 return resultobj;
20131 fail:
20132 return NULL;
20133 }
20134
20135
20136 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20137 PyObject *resultobj = 0;
20138 wxImage *arg1 = (wxImage *) 0 ;
20139 int arg2 = (int) -1 ;
20140 wxBitmap result;
20141 void *argp1 = 0 ;
20142 int res1 = 0 ;
20143 int val2 ;
20144 int ecode2 = 0 ;
20145 PyObject * obj0 = 0 ;
20146 PyObject * obj1 = 0 ;
20147 char * kwnames[] = {
20148 (char *) "self",(char *) "depth", NULL
20149 };
20150
20151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
20152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
20153 if (!SWIG_IsOK(res1)) {
20154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
20155 }
20156 arg1 = reinterpret_cast< wxImage * >(argp1);
20157 if (obj1) {
20158 ecode2 = SWIG_AsVal_int(obj1, &val2);
20159 if (!SWIG_IsOK(ecode2)) {
20160 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
20161 }
20162 arg2 = static_cast< int >(val2);
20163 }
20164 {
20165 if (!wxPyCheckForApp()) SWIG_fail;
20166 PyThreadState* __tstate = wxPyBeginAllowThreads();
20167 result = wxImage_ConvertToBitmap(arg1,arg2);
20168 wxPyEndAllowThreads(__tstate);
20169 if (PyErr_Occurred()) SWIG_fail;
20170 }
20171 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
20172 return resultobj;
20173 fail:
20174 return NULL;
20175 }
20176
20177
20178 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20179 PyObject *resultobj = 0;
20180 wxImage *arg1 = (wxImage *) 0 ;
20181 byte arg2 ;
20182 byte arg3 ;
20183 byte arg4 ;
20184 wxBitmap result;
20185 void *argp1 = 0 ;
20186 int res1 = 0 ;
20187 unsigned char val2 ;
20188 int ecode2 = 0 ;
20189 unsigned char val3 ;
20190 int ecode3 = 0 ;
20191 unsigned char val4 ;
20192 int ecode4 = 0 ;
20193 PyObject * obj0 = 0 ;
20194 PyObject * obj1 = 0 ;
20195 PyObject * obj2 = 0 ;
20196 PyObject * obj3 = 0 ;
20197 char * kwnames[] = {
20198 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
20199 };
20200
20201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
20203 if (!SWIG_IsOK(res1)) {
20204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
20205 }
20206 arg1 = reinterpret_cast< wxImage * >(argp1);
20207 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
20208 if (!SWIG_IsOK(ecode2)) {
20209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
20210 }
20211 arg2 = static_cast< byte >(val2);
20212 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
20213 if (!SWIG_IsOK(ecode3)) {
20214 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
20215 }
20216 arg3 = static_cast< byte >(val3);
20217 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
20218 if (!SWIG_IsOK(ecode4)) {
20219 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
20220 }
20221 arg4 = static_cast< byte >(val4);
20222 {
20223 if (!wxPyCheckForApp()) SWIG_fail;
20224 PyThreadState* __tstate = wxPyBeginAllowThreads();
20225 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
20226 wxPyEndAllowThreads(__tstate);
20227 if (PyErr_Occurred()) SWIG_fail;
20228 }
20229 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
20230 return resultobj;
20231 fail:
20232 return NULL;
20233 }
20234
20235
20236 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20237 PyObject *resultobj = 0;
20238 wxImage *arg1 = (wxImage *) 0 ;
20239 double arg2 ;
20240 void *argp1 = 0 ;
20241 int res1 = 0 ;
20242 double val2 ;
20243 int ecode2 = 0 ;
20244 PyObject * obj0 = 0 ;
20245 PyObject * obj1 = 0 ;
20246 char * kwnames[] = {
20247 (char *) "self",(char *) "angle", NULL
20248 };
20249
20250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
20251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
20252 if (!SWIG_IsOK(res1)) {
20253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
20254 }
20255 arg1 = reinterpret_cast< wxImage * >(argp1);
20256 ecode2 = SWIG_AsVal_double(obj1, &val2);
20257 if (!SWIG_IsOK(ecode2)) {
20258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
20259 }
20260 arg2 = static_cast< double >(val2);
20261 {
20262 PyThreadState* __tstate = wxPyBeginAllowThreads();
20263 (arg1)->RotateHue(arg2);
20264 wxPyEndAllowThreads(__tstate);
20265 if (PyErr_Occurred()) SWIG_fail;
20266 }
20267 resultobj = SWIG_Py_Void();
20268 return resultobj;
20269 fail:
20270 return NULL;
20271 }
20272
20273
20274 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20275 PyObject *resultobj = 0;
20276 wxImage_RGBValue arg1 ;
20277 wxImage_HSVValue result;
20278 void *argp1 ;
20279 int res1 = 0 ;
20280 PyObject * obj0 = 0 ;
20281 char * kwnames[] = {
20282 (char *) "rgb", NULL
20283 };
20284
20285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
20286 {
20287 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
20288 if (!SWIG_IsOK(res1)) {
20289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
20290 }
20291 if (!argp1) {
20292 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
20293 } else {
20294 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
20295 arg1 = *temp;
20296 if (SWIG_IsNewObj(res1)) delete temp;
20297 }
20298 }
20299 {
20300 PyThreadState* __tstate = wxPyBeginAllowThreads();
20301 result = wxImage::RGBtoHSV(arg1);
20302 wxPyEndAllowThreads(__tstate);
20303 if (PyErr_Occurred()) SWIG_fail;
20304 }
20305 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
20306 return resultobj;
20307 fail:
20308 return NULL;
20309 }
20310
20311
20312 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20313 PyObject *resultobj = 0;
20314 wxImage_HSVValue arg1 ;
20315 wxImage_RGBValue result;
20316 void *argp1 ;
20317 int res1 = 0 ;
20318 PyObject * obj0 = 0 ;
20319 char * kwnames[] = {
20320 (char *) "hsv", NULL
20321 };
20322
20323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
20324 {
20325 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
20326 if (!SWIG_IsOK(res1)) {
20327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
20328 }
20329 if (!argp1) {
20330 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
20331 } else {
20332 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
20333 arg1 = *temp;
20334 if (SWIG_IsNewObj(res1)) delete temp;
20335 }
20336 }
20337 {
20338 PyThreadState* __tstate = wxPyBeginAllowThreads();
20339 result = wxImage::HSVtoRGB(arg1);
20340 wxPyEndAllowThreads(__tstate);
20341 if (PyErr_Occurred()) SWIG_fail;
20342 }
20343 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
20344 return resultobj;
20345 fail:
20346 return NULL;
20347 }
20348
20349
20350 SWIGINTERN PyObject *Image_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_wxImage, SWIG_NewClientData(obj));
20354 return SWIG_Py_Void();
20355 }
20356
20357 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20358 return SWIG_Python_InitShadowInstance(args);
20359 }
20360
20361 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20362 PyObject *resultobj = 0;
20363 int arg1 ;
20364 int arg2 ;
20365 buffer arg3 ;
20366 int arg4 ;
20367 buffer arg5 = (buffer) NULL ;
20368 int arg6 = (int) 0 ;
20369 wxImage *result = 0 ;
20370 int val1 ;
20371 int ecode1 = 0 ;
20372 int val2 ;
20373 int ecode2 = 0 ;
20374 Py_ssize_t temp3 ;
20375 Py_ssize_t temp5 ;
20376 PyObject * obj0 = 0 ;
20377 PyObject * obj1 = 0 ;
20378 PyObject * obj2 = 0 ;
20379 PyObject * obj3 = 0 ;
20380 char * kwnames[] = {
20381 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
20382 };
20383
20384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20385 ecode1 = SWIG_AsVal_int(obj0, &val1);
20386 if (!SWIG_IsOK(ecode1)) {
20387 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
20388 }
20389 arg1 = static_cast< int >(val1);
20390 ecode2 = SWIG_AsVal_int(obj1, &val2);
20391 if (!SWIG_IsOK(ecode2)) {
20392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
20393 }
20394 arg2 = static_cast< int >(val2);
20395 {
20396 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
20397 arg4 = (int)temp3;
20398 }
20399 if (obj3) {
20400 {
20401 if (obj3 != Py_None) {
20402 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
20403 arg6 = (int)temp5;
20404 }
20405 }
20406 }
20407 {
20408 PyThreadState* __tstate = wxPyBeginAllowThreads();
20409 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
20410 wxPyEndAllowThreads(__tstate);
20411 if (PyErr_Occurred()) SWIG_fail;
20412 }
20413 {
20414 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
20415 }
20416 return resultobj;
20417 fail:
20418 return NULL;
20419 }
20420
20421
20422 SWIGINTERN int NullImage_set(PyObject *) {
20423 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
20424 return 1;
20425 }
20426
20427
20428 SWIGINTERN PyObject *NullImage_get(void) {
20429 PyObject *pyobj = 0;
20430
20431 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
20432 return pyobj;
20433 }
20434
20435
20436 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
20437 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
20438 return 1;
20439 }
20440
20441
20442 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
20443 PyObject *pyobj = 0;
20444
20445 {
20446 #if wxUSE_UNICODE
20447 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
20448 #else
20449 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
20450 #endif
20451 }
20452 return pyobj;
20453 }
20454
20455
20456 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
20457 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
20458 return 1;
20459 }
20460
20461
20462 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
20463 PyObject *pyobj = 0;
20464
20465 {
20466 #if wxUSE_UNICODE
20467 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
20468 #else
20469 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
20470 #endif
20471 }
20472 return pyobj;
20473 }
20474
20475
20476 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
20477 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
20478 return 1;
20479 }
20480
20481
20482 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
20483 PyObject *pyobj = 0;
20484
20485 {
20486 #if wxUSE_UNICODE
20487 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
20488 #else
20489 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
20490 #endif
20491 }
20492 return pyobj;
20493 }
20494
20495
20496 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
20497 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
20498 return 1;
20499 }
20500
20501
20502 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
20503 PyObject *pyobj = 0;
20504
20505 {
20506 #if wxUSE_UNICODE
20507 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
20508 #else
20509 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
20510 #endif
20511 }
20512 return pyobj;
20513 }
20514
20515
20516 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
20517 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
20518 return 1;
20519 }
20520
20521
20522 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
20523 PyObject *pyobj = 0;
20524
20525 {
20526 #if wxUSE_UNICODE
20527 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
20528 #else
20529 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
20530 #endif
20531 }
20532 return pyobj;
20533 }
20534
20535
20536 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
20537 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
20538 return 1;
20539 }
20540
20541
20542 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
20543 PyObject *pyobj = 0;
20544
20545 {
20546 #if wxUSE_UNICODE
20547 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
20548 #else
20549 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
20550 #endif
20551 }
20552 return pyobj;
20553 }
20554
20555
20556 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
20557 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
20558 return 1;
20559 }
20560
20561
20562 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
20563 PyObject *pyobj = 0;
20564
20565 {
20566 #if wxUSE_UNICODE
20567 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
20568 #else
20569 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
20570 #endif
20571 }
20572 return pyobj;
20573 }
20574
20575
20576 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
20577 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
20578 return 1;
20579 }
20580
20581
20582 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
20583 PyObject *pyobj = 0;
20584
20585 {
20586 #if wxUSE_UNICODE
20587 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
20588 #else
20589 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
20590 #endif
20591 }
20592 return pyobj;
20593 }
20594
20595
20596 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
20597 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
20598 return 1;
20599 }
20600
20601
20602 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
20603 PyObject *pyobj = 0;
20604
20605 {
20606 #if wxUSE_UNICODE
20607 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
20608 #else
20609 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
20610 #endif
20611 }
20612 return pyobj;
20613 }
20614
20615
20616 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
20617 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
20618 return 1;
20619 }
20620
20621
20622 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
20623 PyObject *pyobj = 0;
20624
20625 {
20626 #if wxUSE_UNICODE
20627 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20628 #else
20629 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20630 #endif
20631 }
20632 return pyobj;
20633 }
20634
20635
20636 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
20637 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
20638 return 1;
20639 }
20640
20641
20642 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
20643 PyObject *pyobj = 0;
20644
20645 {
20646 #if wxUSE_UNICODE
20647 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20648 #else
20649 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20650 #endif
20651 }
20652 return pyobj;
20653 }
20654
20655
20656 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
20657 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
20658 return 1;
20659 }
20660
20661
20662 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
20663 PyObject *pyobj = 0;
20664
20665 {
20666 #if wxUSE_UNICODE
20667 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20668 #else
20669 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20670 #endif
20671 }
20672 return pyobj;
20673 }
20674
20675
20676 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
20677 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
20678 return 1;
20679 }
20680
20681
20682 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
20683 PyObject *pyobj = 0;
20684
20685 {
20686 #if wxUSE_UNICODE
20687 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20688 #else
20689 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20690 #endif
20691 }
20692 return pyobj;
20693 }
20694
20695
20696 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
20697 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
20698 return 1;
20699 }
20700
20701
20702 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
20703 PyObject *pyobj = 0;
20704
20705 {
20706 #if wxUSE_UNICODE
20707 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20708 #else
20709 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20710 #endif
20711 }
20712 return pyobj;
20713 }
20714
20715
20716 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
20717 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
20718 return 1;
20719 }
20720
20721
20722 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
20723 PyObject *pyobj = 0;
20724
20725 {
20726 #if wxUSE_UNICODE
20727 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20728 #else
20729 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20730 #endif
20731 }
20732 return pyobj;
20733 }
20734
20735
20736 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20737 PyObject *resultobj = 0;
20738 wxBMPHandler *result = 0 ;
20739
20740 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
20741 {
20742 PyThreadState* __tstate = wxPyBeginAllowThreads();
20743 result = (wxBMPHandler *)new wxBMPHandler();
20744 wxPyEndAllowThreads(__tstate);
20745 if (PyErr_Occurred()) SWIG_fail;
20746 }
20747 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
20748 return resultobj;
20749 fail:
20750 return NULL;
20751 }
20752
20753
20754 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20755 PyObject *obj;
20756 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20757 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
20758 return SWIG_Py_Void();
20759 }
20760
20761 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20762 return SWIG_Python_InitShadowInstance(args);
20763 }
20764
20765 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20766 PyObject *resultobj = 0;
20767 wxICOHandler *result = 0 ;
20768
20769 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
20770 {
20771 PyThreadState* __tstate = wxPyBeginAllowThreads();
20772 result = (wxICOHandler *)new wxICOHandler();
20773 wxPyEndAllowThreads(__tstate);
20774 if (PyErr_Occurred()) SWIG_fail;
20775 }
20776 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
20777 return resultobj;
20778 fail:
20779 return NULL;
20780 }
20781
20782
20783 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20784 PyObject *obj;
20785 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20786 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
20787 return SWIG_Py_Void();
20788 }
20789
20790 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20791 return SWIG_Python_InitShadowInstance(args);
20792 }
20793
20794 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20795 PyObject *resultobj = 0;
20796 wxCURHandler *result = 0 ;
20797
20798 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
20799 {
20800 PyThreadState* __tstate = wxPyBeginAllowThreads();
20801 result = (wxCURHandler *)new wxCURHandler();
20802 wxPyEndAllowThreads(__tstate);
20803 if (PyErr_Occurred()) SWIG_fail;
20804 }
20805 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
20806 return resultobj;
20807 fail:
20808 return NULL;
20809 }
20810
20811
20812 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20813 PyObject *obj;
20814 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20815 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
20816 return SWIG_Py_Void();
20817 }
20818
20819 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20820 return SWIG_Python_InitShadowInstance(args);
20821 }
20822
20823 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20824 PyObject *resultobj = 0;
20825 wxANIHandler *result = 0 ;
20826
20827 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
20828 {
20829 PyThreadState* __tstate = wxPyBeginAllowThreads();
20830 result = (wxANIHandler *)new wxANIHandler();
20831 wxPyEndAllowThreads(__tstate);
20832 if (PyErr_Occurred()) SWIG_fail;
20833 }
20834 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
20835 return resultobj;
20836 fail:
20837 return NULL;
20838 }
20839
20840
20841 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20842 PyObject *obj;
20843 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20844 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
20845 return SWIG_Py_Void();
20846 }
20847
20848 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20849 return SWIG_Python_InitShadowInstance(args);
20850 }
20851
20852 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20853 PyObject *resultobj = 0;
20854 wxPNGHandler *result = 0 ;
20855
20856 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
20857 {
20858 PyThreadState* __tstate = wxPyBeginAllowThreads();
20859 result = (wxPNGHandler *)new wxPNGHandler();
20860 wxPyEndAllowThreads(__tstate);
20861 if (PyErr_Occurred()) SWIG_fail;
20862 }
20863 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
20864 return resultobj;
20865 fail:
20866 return NULL;
20867 }
20868
20869
20870 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20871 PyObject *obj;
20872 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20873 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
20874 return SWIG_Py_Void();
20875 }
20876
20877 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20878 return SWIG_Python_InitShadowInstance(args);
20879 }
20880
20881 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20882 PyObject *resultobj = 0;
20883 wxGIFHandler *result = 0 ;
20884
20885 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
20886 {
20887 PyThreadState* __tstate = wxPyBeginAllowThreads();
20888 result = (wxGIFHandler *)new wxGIFHandler();
20889 wxPyEndAllowThreads(__tstate);
20890 if (PyErr_Occurred()) SWIG_fail;
20891 }
20892 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
20893 return resultobj;
20894 fail:
20895 return NULL;
20896 }
20897
20898
20899 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20900 PyObject *obj;
20901 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20902 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
20903 return SWIG_Py_Void();
20904 }
20905
20906 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20907 return SWIG_Python_InitShadowInstance(args);
20908 }
20909
20910 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20911 PyObject *resultobj = 0;
20912 wxPCXHandler *result = 0 ;
20913
20914 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
20915 {
20916 PyThreadState* __tstate = wxPyBeginAllowThreads();
20917 result = (wxPCXHandler *)new wxPCXHandler();
20918 wxPyEndAllowThreads(__tstate);
20919 if (PyErr_Occurred()) SWIG_fail;
20920 }
20921 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
20922 return resultobj;
20923 fail:
20924 return NULL;
20925 }
20926
20927
20928 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20929 PyObject *obj;
20930 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20931 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
20932 return SWIG_Py_Void();
20933 }
20934
20935 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20936 return SWIG_Python_InitShadowInstance(args);
20937 }
20938
20939 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20940 PyObject *resultobj = 0;
20941 wxJPEGHandler *result = 0 ;
20942
20943 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
20944 {
20945 PyThreadState* __tstate = wxPyBeginAllowThreads();
20946 result = (wxJPEGHandler *)new wxJPEGHandler();
20947 wxPyEndAllowThreads(__tstate);
20948 if (PyErr_Occurred()) SWIG_fail;
20949 }
20950 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
20951 return resultobj;
20952 fail:
20953 return NULL;
20954 }
20955
20956
20957 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20958 PyObject *obj;
20959 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20960 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
20961 return SWIG_Py_Void();
20962 }
20963
20964 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20965 return SWIG_Python_InitShadowInstance(args);
20966 }
20967
20968 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20969 PyObject *resultobj = 0;
20970 wxPNMHandler *result = 0 ;
20971
20972 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
20973 {
20974 PyThreadState* __tstate = wxPyBeginAllowThreads();
20975 result = (wxPNMHandler *)new wxPNMHandler();
20976 wxPyEndAllowThreads(__tstate);
20977 if (PyErr_Occurred()) SWIG_fail;
20978 }
20979 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
20980 return resultobj;
20981 fail:
20982 return NULL;
20983 }
20984
20985
20986 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20987 PyObject *obj;
20988 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20989 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
20990 return SWIG_Py_Void();
20991 }
20992
20993 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20994 return SWIG_Python_InitShadowInstance(args);
20995 }
20996
20997 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20998 PyObject *resultobj = 0;
20999 wxXPMHandler *result = 0 ;
21000
21001 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
21002 {
21003 PyThreadState* __tstate = wxPyBeginAllowThreads();
21004 result = (wxXPMHandler *)new wxXPMHandler();
21005 wxPyEndAllowThreads(__tstate);
21006 if (PyErr_Occurred()) SWIG_fail;
21007 }
21008 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
21009 return resultobj;
21010 fail:
21011 return NULL;
21012 }
21013
21014
21015 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21016 PyObject *obj;
21017 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21018 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
21019 return SWIG_Py_Void();
21020 }
21021
21022 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21023 return SWIG_Python_InitShadowInstance(args);
21024 }
21025
21026 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21027 PyObject *resultobj = 0;
21028 wxTIFFHandler *result = 0 ;
21029
21030 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
21031 {
21032 PyThreadState* __tstate = wxPyBeginAllowThreads();
21033 result = (wxTIFFHandler *)new wxTIFFHandler();
21034 wxPyEndAllowThreads(__tstate);
21035 if (PyErr_Occurred()) SWIG_fail;
21036 }
21037 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
21038 return resultobj;
21039 fail:
21040 return NULL;
21041 }
21042
21043
21044 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21045 PyObject *obj;
21046 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21047 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
21048 return SWIG_Py_Void();
21049 }
21050
21051 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21052 return SWIG_Python_InitShadowInstance(args);
21053 }
21054
21055 SWIGINTERN PyObject *_wrap_new_TGAHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21056 PyObject *resultobj = 0;
21057 wxTGAHandler *result = 0 ;
21058
21059 if (!SWIG_Python_UnpackTuple(args,"new_TGAHandler",0,0,0)) SWIG_fail;
21060 {
21061 PyThreadState* __tstate = wxPyBeginAllowThreads();
21062 result = (wxTGAHandler *)new wxTGAHandler();
21063 wxPyEndAllowThreads(__tstate);
21064 if (PyErr_Occurred()) SWIG_fail;
21065 }
21066 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTGAHandler, SWIG_POINTER_NEW | 0 );
21067 return resultobj;
21068 fail:
21069 return NULL;
21070 }
21071
21072
21073 SWIGINTERN PyObject *TGAHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21074 PyObject *obj;
21075 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21076 SWIG_TypeNewClientData(SWIGTYPE_p_wxTGAHandler, SWIG_NewClientData(obj));
21077 return SWIG_Py_Void();
21078 }
21079
21080 SWIGINTERN PyObject *TGAHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21081 return SWIG_Python_InitShadowInstance(args);
21082 }
21083
21084 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21085 PyObject *resultobj = 0;
21086 wxImage *arg1 = 0 ;
21087 wxImage *arg2 = 0 ;
21088 int arg3 = (int) 236 ;
21089 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
21090 bool result;
21091 void *argp1 = 0 ;
21092 int res1 = 0 ;
21093 void *argp2 = 0 ;
21094 int res2 = 0 ;
21095 int val3 ;
21096 int ecode3 = 0 ;
21097 int val4 ;
21098 int ecode4 = 0 ;
21099 PyObject * obj0 = 0 ;
21100 PyObject * obj1 = 0 ;
21101 PyObject * obj2 = 0 ;
21102 PyObject * obj3 = 0 ;
21103 char * kwnames[] = {
21104 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
21105 };
21106
21107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
21108 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
21109 if (!SWIG_IsOK(res1)) {
21110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
21111 }
21112 if (!argp1) {
21113 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
21114 }
21115 arg1 = reinterpret_cast< wxImage * >(argp1);
21116 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
21117 if (!SWIG_IsOK(res2)) {
21118 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
21119 }
21120 if (!argp2) {
21121 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
21122 }
21123 arg2 = reinterpret_cast< wxImage * >(argp2);
21124 if (obj2) {
21125 ecode3 = SWIG_AsVal_int(obj2, &val3);
21126 if (!SWIG_IsOK(ecode3)) {
21127 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
21128 }
21129 arg3 = static_cast< int >(val3);
21130 }
21131 if (obj3) {
21132 ecode4 = SWIG_AsVal_int(obj3, &val4);
21133 if (!SWIG_IsOK(ecode4)) {
21134 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
21135 }
21136 arg4 = static_cast< int >(val4);
21137 }
21138 {
21139 PyThreadState* __tstate = wxPyBeginAllowThreads();
21140 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
21141 wxPyEndAllowThreads(__tstate);
21142 if (PyErr_Occurred()) SWIG_fail;
21143 }
21144 {
21145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21146 }
21147 return resultobj;
21148 fail:
21149 return NULL;
21150 }
21151
21152
21153 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21154 PyObject *obj;
21155 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21156 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
21157 return SWIG_Py_Void();
21158 }
21159
21160 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21161 PyObject *resultobj = 0;
21162 wxEvtHandler *result = 0 ;
21163
21164 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
21165 {
21166 PyThreadState* __tstate = wxPyBeginAllowThreads();
21167 result = (wxEvtHandler *)new wxEvtHandler();
21168 wxPyEndAllowThreads(__tstate);
21169 if (PyErr_Occurred()) SWIG_fail;
21170 }
21171 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
21172 return resultobj;
21173 fail:
21174 return NULL;
21175 }
21176
21177
21178 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21179 PyObject *resultobj = 0;
21180 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21181 wxEvtHandler *result = 0 ;
21182 void *argp1 = 0 ;
21183 int res1 = 0 ;
21184 PyObject *swig_obj[1] ;
21185
21186 if (!args) SWIG_fail;
21187 swig_obj[0] = args;
21188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21189 if (!SWIG_IsOK(res1)) {
21190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21191 }
21192 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21193 {
21194 PyThreadState* __tstate = wxPyBeginAllowThreads();
21195 result = (wxEvtHandler *)(arg1)->GetNextHandler();
21196 wxPyEndAllowThreads(__tstate);
21197 if (PyErr_Occurred()) SWIG_fail;
21198 }
21199 {
21200 resultobj = wxPyMake_wxObject(result, 0);
21201 }
21202 return resultobj;
21203 fail:
21204 return NULL;
21205 }
21206
21207
21208 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21209 PyObject *resultobj = 0;
21210 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21211 wxEvtHandler *result = 0 ;
21212 void *argp1 = 0 ;
21213 int res1 = 0 ;
21214 PyObject *swig_obj[1] ;
21215
21216 if (!args) SWIG_fail;
21217 swig_obj[0] = args;
21218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21219 if (!SWIG_IsOK(res1)) {
21220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21221 }
21222 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21223 {
21224 PyThreadState* __tstate = wxPyBeginAllowThreads();
21225 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
21226 wxPyEndAllowThreads(__tstate);
21227 if (PyErr_Occurred()) SWIG_fail;
21228 }
21229 {
21230 resultobj = wxPyMake_wxObject(result, 0);
21231 }
21232 return resultobj;
21233 fail:
21234 return NULL;
21235 }
21236
21237
21238 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21239 PyObject *resultobj = 0;
21240 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21241 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
21242 void *argp1 = 0 ;
21243 int res1 = 0 ;
21244 void *argp2 = 0 ;
21245 int res2 = 0 ;
21246 PyObject * obj0 = 0 ;
21247 PyObject * obj1 = 0 ;
21248 char * kwnames[] = {
21249 (char *) "self",(char *) "handler", NULL
21250 };
21251
21252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
21253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21254 if (!SWIG_IsOK(res1)) {
21255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21256 }
21257 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21258 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21259 if (!SWIG_IsOK(res2)) {
21260 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
21261 }
21262 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
21263 {
21264 PyThreadState* __tstate = wxPyBeginAllowThreads();
21265 (arg1)->SetNextHandler(arg2);
21266 wxPyEndAllowThreads(__tstate);
21267 if (PyErr_Occurred()) SWIG_fail;
21268 }
21269 resultobj = SWIG_Py_Void();
21270 return resultobj;
21271 fail:
21272 return NULL;
21273 }
21274
21275
21276 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21277 PyObject *resultobj = 0;
21278 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21279 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
21280 void *argp1 = 0 ;
21281 int res1 = 0 ;
21282 void *argp2 = 0 ;
21283 int res2 = 0 ;
21284 PyObject * obj0 = 0 ;
21285 PyObject * obj1 = 0 ;
21286 char * kwnames[] = {
21287 (char *) "self",(char *) "handler", NULL
21288 };
21289
21290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
21291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21292 if (!SWIG_IsOK(res1)) {
21293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21294 }
21295 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21296 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21297 if (!SWIG_IsOK(res2)) {
21298 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
21299 }
21300 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
21301 {
21302 PyThreadState* __tstate = wxPyBeginAllowThreads();
21303 (arg1)->SetPreviousHandler(arg2);
21304 wxPyEndAllowThreads(__tstate);
21305 if (PyErr_Occurred()) SWIG_fail;
21306 }
21307 resultobj = SWIG_Py_Void();
21308 return resultobj;
21309 fail:
21310 return NULL;
21311 }
21312
21313
21314 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21315 PyObject *resultobj = 0;
21316 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21317 bool result;
21318 void *argp1 = 0 ;
21319 int res1 = 0 ;
21320 PyObject *swig_obj[1] ;
21321
21322 if (!args) SWIG_fail;
21323 swig_obj[0] = args;
21324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21325 if (!SWIG_IsOK(res1)) {
21326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21327 }
21328 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21329 {
21330 PyThreadState* __tstate = wxPyBeginAllowThreads();
21331 result = (bool)(arg1)->GetEvtHandlerEnabled();
21332 wxPyEndAllowThreads(__tstate);
21333 if (PyErr_Occurred()) SWIG_fail;
21334 }
21335 {
21336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21337 }
21338 return resultobj;
21339 fail:
21340 return NULL;
21341 }
21342
21343
21344 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21345 PyObject *resultobj = 0;
21346 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21347 bool arg2 ;
21348 void *argp1 = 0 ;
21349 int res1 = 0 ;
21350 bool val2 ;
21351 int ecode2 = 0 ;
21352 PyObject * obj0 = 0 ;
21353 PyObject * obj1 = 0 ;
21354 char * kwnames[] = {
21355 (char *) "self",(char *) "enabled", NULL
21356 };
21357
21358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
21359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21360 if (!SWIG_IsOK(res1)) {
21361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21362 }
21363 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21364 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21365 if (!SWIG_IsOK(ecode2)) {
21366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
21367 }
21368 arg2 = static_cast< bool >(val2);
21369 {
21370 PyThreadState* __tstate = wxPyBeginAllowThreads();
21371 (arg1)->SetEvtHandlerEnabled(arg2);
21372 wxPyEndAllowThreads(__tstate);
21373 if (PyErr_Occurred()) SWIG_fail;
21374 }
21375 resultobj = SWIG_Py_Void();
21376 return resultobj;
21377 fail:
21378 return NULL;
21379 }
21380
21381
21382 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21383 PyObject *resultobj = 0;
21384 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21385 wxEvent *arg2 = 0 ;
21386 bool result;
21387 void *argp1 = 0 ;
21388 int res1 = 0 ;
21389 void *argp2 = 0 ;
21390 int res2 = 0 ;
21391 PyObject * obj0 = 0 ;
21392 PyObject * obj1 = 0 ;
21393 char * kwnames[] = {
21394 (char *) "self",(char *) "event", NULL
21395 };
21396
21397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21399 if (!SWIG_IsOK(res1)) {
21400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21401 }
21402 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21403 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
21404 if (!SWIG_IsOK(res2)) {
21405 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
21406 }
21407 if (!argp2) {
21408 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
21409 }
21410 arg2 = reinterpret_cast< wxEvent * >(argp2);
21411 {
21412 PyThreadState* __tstate = wxPyBeginAllowThreads();
21413 result = (bool)(arg1)->ProcessEvent(*arg2);
21414 wxPyEndAllowThreads(__tstate);
21415 if (PyErr_Occurred()) SWIG_fail;
21416 }
21417 {
21418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21419 }
21420 return resultobj;
21421 fail:
21422 return NULL;
21423 }
21424
21425
21426 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21427 PyObject *resultobj = 0;
21428 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21429 wxEvent *arg2 = 0 ;
21430 void *argp1 = 0 ;
21431 int res1 = 0 ;
21432 void *argp2 = 0 ;
21433 int res2 = 0 ;
21434 PyObject * obj0 = 0 ;
21435 PyObject * obj1 = 0 ;
21436 char * kwnames[] = {
21437 (char *) "self",(char *) "event", NULL
21438 };
21439
21440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21442 if (!SWIG_IsOK(res1)) {
21443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21444 }
21445 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21446 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
21447 if (!SWIG_IsOK(res2)) {
21448 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
21449 }
21450 if (!argp2) {
21451 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
21452 }
21453 arg2 = reinterpret_cast< wxEvent * >(argp2);
21454 {
21455 PyThreadState* __tstate = wxPyBeginAllowThreads();
21456 (arg1)->AddPendingEvent(*arg2);
21457 wxPyEndAllowThreads(__tstate);
21458 if (PyErr_Occurred()) SWIG_fail;
21459 }
21460 resultobj = SWIG_Py_Void();
21461 return resultobj;
21462 fail:
21463 return NULL;
21464 }
21465
21466
21467 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21468 PyObject *resultobj = 0;
21469 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21470 void *argp1 = 0 ;
21471 int res1 = 0 ;
21472 PyObject *swig_obj[1] ;
21473
21474 if (!args) SWIG_fail;
21475 swig_obj[0] = args;
21476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21477 if (!SWIG_IsOK(res1)) {
21478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21479 }
21480 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21481 {
21482 PyThreadState* __tstate = wxPyBeginAllowThreads();
21483 (arg1)->ProcessPendingEvents();
21484 wxPyEndAllowThreads(__tstate);
21485 if (PyErr_Occurred()) SWIG_fail;
21486 }
21487 resultobj = SWIG_Py_Void();
21488 return resultobj;
21489 fail:
21490 return NULL;
21491 }
21492
21493
21494 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21495 PyObject *resultobj = 0;
21496 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21497 int arg2 ;
21498 int arg3 ;
21499 int arg4 ;
21500 PyObject *arg5 = (PyObject *) 0 ;
21501 void *argp1 = 0 ;
21502 int res1 = 0 ;
21503 int val2 ;
21504 int ecode2 = 0 ;
21505 int val3 ;
21506 int ecode3 = 0 ;
21507 int val4 ;
21508 int ecode4 = 0 ;
21509 PyObject * obj0 = 0 ;
21510 PyObject * obj1 = 0 ;
21511 PyObject * obj2 = 0 ;
21512 PyObject * obj3 = 0 ;
21513 PyObject * obj4 = 0 ;
21514 char * kwnames[] = {
21515 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
21516 };
21517
21518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21520 if (!SWIG_IsOK(res1)) {
21521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21522 }
21523 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21524 ecode2 = SWIG_AsVal_int(obj1, &val2);
21525 if (!SWIG_IsOK(ecode2)) {
21526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
21527 }
21528 arg2 = static_cast< int >(val2);
21529 ecode3 = SWIG_AsVal_int(obj2, &val3);
21530 if (!SWIG_IsOK(ecode3)) {
21531 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
21532 }
21533 arg3 = static_cast< int >(val3);
21534 ecode4 = SWIG_AsVal_int(obj3, &val4);
21535 if (!SWIG_IsOK(ecode4)) {
21536 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
21537 }
21538 arg4 = static_cast< int >(val4);
21539 arg5 = obj4;
21540 {
21541 PyThreadState* __tstate = wxPyBeginAllowThreads();
21542 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
21543 wxPyEndAllowThreads(__tstate);
21544 if (PyErr_Occurred()) SWIG_fail;
21545 }
21546 resultobj = SWIG_Py_Void();
21547 return resultobj;
21548 fail:
21549 return NULL;
21550 }
21551
21552
21553 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21554 PyObject *resultobj = 0;
21555 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21556 int arg2 ;
21557 int arg3 = (int) -1 ;
21558 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
21559 bool result;
21560 void *argp1 = 0 ;
21561 int res1 = 0 ;
21562 int val2 ;
21563 int ecode2 = 0 ;
21564 int val3 ;
21565 int ecode3 = 0 ;
21566 int val4 ;
21567 int ecode4 = 0 ;
21568 PyObject * obj0 = 0 ;
21569 PyObject * obj1 = 0 ;
21570 PyObject * obj2 = 0 ;
21571 PyObject * obj3 = 0 ;
21572 char * kwnames[] = {
21573 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
21574 };
21575
21576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
21577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21578 if (!SWIG_IsOK(res1)) {
21579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21580 }
21581 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21582 ecode2 = SWIG_AsVal_int(obj1, &val2);
21583 if (!SWIG_IsOK(ecode2)) {
21584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
21585 }
21586 arg2 = static_cast< int >(val2);
21587 if (obj2) {
21588 ecode3 = SWIG_AsVal_int(obj2, &val3);
21589 if (!SWIG_IsOK(ecode3)) {
21590 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
21591 }
21592 arg3 = static_cast< int >(val3);
21593 }
21594 if (obj3) {
21595 ecode4 = SWIG_AsVal_int(obj3, &val4);
21596 if (!SWIG_IsOK(ecode4)) {
21597 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
21598 }
21599 arg4 = static_cast< wxEventType >(val4);
21600 }
21601 {
21602 PyThreadState* __tstate = wxPyBeginAllowThreads();
21603 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
21604 wxPyEndAllowThreads(__tstate);
21605 if (PyErr_Occurred()) SWIG_fail;
21606 }
21607 {
21608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21609 }
21610 return resultobj;
21611 fail:
21612 return NULL;
21613 }
21614
21615
21616 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21617 PyObject *resultobj = 0;
21618 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21619 PyObject *arg2 = (PyObject *) 0 ;
21620 bool arg3 = (bool) true ;
21621 void *argp1 = 0 ;
21622 int res1 = 0 ;
21623 bool val3 ;
21624 int ecode3 = 0 ;
21625 PyObject * obj0 = 0 ;
21626 PyObject * obj1 = 0 ;
21627 PyObject * obj2 = 0 ;
21628 char * kwnames[] = {
21629 (char *) "self",(char *) "_self",(char *) "incref", NULL
21630 };
21631
21632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21634 if (!SWIG_IsOK(res1)) {
21635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21636 }
21637 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21638 arg2 = obj1;
21639 if (obj2) {
21640 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21641 if (!SWIG_IsOK(ecode3)) {
21642 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
21643 }
21644 arg3 = static_cast< bool >(val3);
21645 }
21646 {
21647 PyThreadState* __tstate = wxPyBeginAllowThreads();
21648 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
21649 wxPyEndAllowThreads(__tstate);
21650 if (PyErr_Occurred()) SWIG_fail;
21651 }
21652 resultobj = SWIG_Py_Void();
21653 return resultobj;
21654 fail:
21655 return NULL;
21656 }
21657
21658
21659 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21660 PyObject *obj;
21661 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21662 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
21663 return SWIG_Py_Void();
21664 }
21665
21666 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21667 return SWIG_Python_InitShadowInstance(args);
21668 }
21669
21670 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21671 PyObject *resultobj = 0;
21672 wxEventType result;
21673
21674 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
21675 {
21676 PyThreadState* __tstate = wxPyBeginAllowThreads();
21677 result = (wxEventType)wxNewEventType();
21678 wxPyEndAllowThreads(__tstate);
21679 if (PyErr_Occurred()) SWIG_fail;
21680 }
21681 resultobj = SWIG_From_int(static_cast< int >(result));
21682 return resultobj;
21683 fail:
21684 return NULL;
21685 }
21686
21687
21688 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21689 PyObject *resultobj = 0;
21690 wxEvent *arg1 = (wxEvent *) 0 ;
21691 void *argp1 = 0 ;
21692 int res1 = 0 ;
21693 PyObject *swig_obj[1] ;
21694
21695 if (!args) SWIG_fail;
21696 swig_obj[0] = args;
21697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
21698 if (!SWIG_IsOK(res1)) {
21699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
21700 }
21701 arg1 = reinterpret_cast< wxEvent * >(argp1);
21702 {
21703 PyThreadState* __tstate = wxPyBeginAllowThreads();
21704 delete arg1;
21705
21706 wxPyEndAllowThreads(__tstate);
21707 if (PyErr_Occurred()) SWIG_fail;
21708 }
21709 resultobj = SWIG_Py_Void();
21710 return resultobj;
21711 fail:
21712 return NULL;
21713 }
21714
21715
21716 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21717 PyObject *resultobj = 0;
21718 wxEvent *arg1 = (wxEvent *) 0 ;
21719 wxEventType arg2 ;
21720 void *argp1 = 0 ;
21721 int res1 = 0 ;
21722 int val2 ;
21723 int ecode2 = 0 ;
21724 PyObject * obj0 = 0 ;
21725 PyObject * obj1 = 0 ;
21726 char * kwnames[] = {
21727 (char *) "self",(char *) "typ", NULL
21728 };
21729
21730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
21731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21732 if (!SWIG_IsOK(res1)) {
21733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
21734 }
21735 arg1 = reinterpret_cast< wxEvent * >(argp1);
21736 ecode2 = SWIG_AsVal_int(obj1, &val2);
21737 if (!SWIG_IsOK(ecode2)) {
21738 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
21739 }
21740 arg2 = static_cast< wxEventType >(val2);
21741 {
21742 PyThreadState* __tstate = wxPyBeginAllowThreads();
21743 (arg1)->SetEventType(arg2);
21744 wxPyEndAllowThreads(__tstate);
21745 if (PyErr_Occurred()) SWIG_fail;
21746 }
21747 resultobj = SWIG_Py_Void();
21748 return resultobj;
21749 fail:
21750 return NULL;
21751 }
21752
21753
21754 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21755 PyObject *resultobj = 0;
21756 wxEvent *arg1 = (wxEvent *) 0 ;
21757 wxEventType result;
21758 void *argp1 = 0 ;
21759 int res1 = 0 ;
21760 PyObject *swig_obj[1] ;
21761
21762 if (!args) SWIG_fail;
21763 swig_obj[0] = args;
21764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21765 if (!SWIG_IsOK(res1)) {
21766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
21767 }
21768 arg1 = reinterpret_cast< wxEvent * >(argp1);
21769 {
21770 PyThreadState* __tstate = wxPyBeginAllowThreads();
21771 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
21772 wxPyEndAllowThreads(__tstate);
21773 if (PyErr_Occurred()) SWIG_fail;
21774 }
21775 resultobj = SWIG_From_int(static_cast< int >(result));
21776 return resultobj;
21777 fail:
21778 return NULL;
21779 }
21780
21781
21782 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21783 PyObject *resultobj = 0;
21784 wxEvent *arg1 = (wxEvent *) 0 ;
21785 wxObject *result = 0 ;
21786 void *argp1 = 0 ;
21787 int res1 = 0 ;
21788 PyObject *swig_obj[1] ;
21789
21790 if (!args) SWIG_fail;
21791 swig_obj[0] = args;
21792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21793 if (!SWIG_IsOK(res1)) {
21794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
21795 }
21796 arg1 = reinterpret_cast< wxEvent * >(argp1);
21797 {
21798 PyThreadState* __tstate = wxPyBeginAllowThreads();
21799 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
21800 wxPyEndAllowThreads(__tstate);
21801 if (PyErr_Occurred()) SWIG_fail;
21802 }
21803 {
21804 resultobj = wxPyMake_wxObject(result, (bool)0);
21805 }
21806 return resultobj;
21807 fail:
21808 return NULL;
21809 }
21810
21811
21812 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21813 PyObject *resultobj = 0;
21814 wxEvent *arg1 = (wxEvent *) 0 ;
21815 wxObject *arg2 = (wxObject *) 0 ;
21816 void *argp1 = 0 ;
21817 int res1 = 0 ;
21818 void *argp2 = 0 ;
21819 int res2 = 0 ;
21820 PyObject * obj0 = 0 ;
21821 PyObject * obj1 = 0 ;
21822 char * kwnames[] = {
21823 (char *) "self",(char *) "obj", NULL
21824 };
21825
21826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
21827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21828 if (!SWIG_IsOK(res1)) {
21829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
21830 }
21831 arg1 = reinterpret_cast< wxEvent * >(argp1);
21832 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
21833 if (!SWIG_IsOK(res2)) {
21834 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
21835 }
21836 arg2 = reinterpret_cast< wxObject * >(argp2);
21837 {
21838 PyThreadState* __tstate = wxPyBeginAllowThreads();
21839 (arg1)->SetEventObject(arg2);
21840 wxPyEndAllowThreads(__tstate);
21841 if (PyErr_Occurred()) SWIG_fail;
21842 }
21843 resultobj = SWIG_Py_Void();
21844 return resultobj;
21845 fail:
21846 return NULL;
21847 }
21848
21849
21850 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21851 PyObject *resultobj = 0;
21852 wxEvent *arg1 = (wxEvent *) 0 ;
21853 long result;
21854 void *argp1 = 0 ;
21855 int res1 = 0 ;
21856 PyObject *swig_obj[1] ;
21857
21858 if (!args) SWIG_fail;
21859 swig_obj[0] = args;
21860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21861 if (!SWIG_IsOK(res1)) {
21862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
21863 }
21864 arg1 = reinterpret_cast< wxEvent * >(argp1);
21865 {
21866 PyThreadState* __tstate = wxPyBeginAllowThreads();
21867 result = (long)((wxEvent const *)arg1)->GetTimestamp();
21868 wxPyEndAllowThreads(__tstate);
21869 if (PyErr_Occurred()) SWIG_fail;
21870 }
21871 resultobj = SWIG_From_long(static_cast< long >(result));
21872 return resultobj;
21873 fail:
21874 return NULL;
21875 }
21876
21877
21878 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21879 PyObject *resultobj = 0;
21880 wxEvent *arg1 = (wxEvent *) 0 ;
21881 long arg2 = (long) 0 ;
21882 void *argp1 = 0 ;
21883 int res1 = 0 ;
21884 long val2 ;
21885 int ecode2 = 0 ;
21886 PyObject * obj0 = 0 ;
21887 PyObject * obj1 = 0 ;
21888 char * kwnames[] = {
21889 (char *) "self",(char *) "ts", NULL
21890 };
21891
21892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
21893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21894 if (!SWIG_IsOK(res1)) {
21895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
21896 }
21897 arg1 = reinterpret_cast< wxEvent * >(argp1);
21898 if (obj1) {
21899 ecode2 = SWIG_AsVal_long(obj1, &val2);
21900 if (!SWIG_IsOK(ecode2)) {
21901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
21902 }
21903 arg2 = static_cast< long >(val2);
21904 }
21905 {
21906 PyThreadState* __tstate = wxPyBeginAllowThreads();
21907 (arg1)->SetTimestamp(arg2);
21908 wxPyEndAllowThreads(__tstate);
21909 if (PyErr_Occurred()) SWIG_fail;
21910 }
21911 resultobj = SWIG_Py_Void();
21912 return resultobj;
21913 fail:
21914 return NULL;
21915 }
21916
21917
21918 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21919 PyObject *resultobj = 0;
21920 wxEvent *arg1 = (wxEvent *) 0 ;
21921 int result;
21922 void *argp1 = 0 ;
21923 int res1 = 0 ;
21924 PyObject *swig_obj[1] ;
21925
21926 if (!args) SWIG_fail;
21927 swig_obj[0] = args;
21928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21929 if (!SWIG_IsOK(res1)) {
21930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
21931 }
21932 arg1 = reinterpret_cast< wxEvent * >(argp1);
21933 {
21934 PyThreadState* __tstate = wxPyBeginAllowThreads();
21935 result = (int)((wxEvent const *)arg1)->GetId();
21936 wxPyEndAllowThreads(__tstate);
21937 if (PyErr_Occurred()) SWIG_fail;
21938 }
21939 resultobj = SWIG_From_int(static_cast< int >(result));
21940 return resultobj;
21941 fail:
21942 return NULL;
21943 }
21944
21945
21946 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21947 PyObject *resultobj = 0;
21948 wxEvent *arg1 = (wxEvent *) 0 ;
21949 int arg2 ;
21950 void *argp1 = 0 ;
21951 int res1 = 0 ;
21952 int val2 ;
21953 int ecode2 = 0 ;
21954 PyObject * obj0 = 0 ;
21955 PyObject * obj1 = 0 ;
21956 char * kwnames[] = {
21957 (char *) "self",(char *) "Id", NULL
21958 };
21959
21960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
21961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21962 if (!SWIG_IsOK(res1)) {
21963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
21964 }
21965 arg1 = reinterpret_cast< wxEvent * >(argp1);
21966 ecode2 = SWIG_AsVal_int(obj1, &val2);
21967 if (!SWIG_IsOK(ecode2)) {
21968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
21969 }
21970 arg2 = static_cast< int >(val2);
21971 {
21972 PyThreadState* __tstate = wxPyBeginAllowThreads();
21973 (arg1)->SetId(arg2);
21974 wxPyEndAllowThreads(__tstate);
21975 if (PyErr_Occurred()) SWIG_fail;
21976 }
21977 resultobj = SWIG_Py_Void();
21978 return resultobj;
21979 fail:
21980 return NULL;
21981 }
21982
21983
21984 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21985 PyObject *resultobj = 0;
21986 wxEvent *arg1 = (wxEvent *) 0 ;
21987 bool result;
21988 void *argp1 = 0 ;
21989 int res1 = 0 ;
21990 PyObject *swig_obj[1] ;
21991
21992 if (!args) SWIG_fail;
21993 swig_obj[0] = args;
21994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21995 if (!SWIG_IsOK(res1)) {
21996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
21997 }
21998 arg1 = reinterpret_cast< wxEvent * >(argp1);
21999 {
22000 PyThreadState* __tstate = wxPyBeginAllowThreads();
22001 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
22002 wxPyEndAllowThreads(__tstate);
22003 if (PyErr_Occurred()) SWIG_fail;
22004 }
22005 {
22006 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22007 }
22008 return resultobj;
22009 fail:
22010 return NULL;
22011 }
22012
22013
22014 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22015 PyObject *resultobj = 0;
22016 wxEvent *arg1 = (wxEvent *) 0 ;
22017 bool arg2 = (bool) true ;
22018 void *argp1 = 0 ;
22019 int res1 = 0 ;
22020 bool val2 ;
22021 int ecode2 = 0 ;
22022 PyObject * obj0 = 0 ;
22023 PyObject * obj1 = 0 ;
22024 char * kwnames[] = {
22025 (char *) "self",(char *) "skip", NULL
22026 };
22027
22028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
22029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
22030 if (!SWIG_IsOK(res1)) {
22031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
22032 }
22033 arg1 = reinterpret_cast< wxEvent * >(argp1);
22034 if (obj1) {
22035 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22036 if (!SWIG_IsOK(ecode2)) {
22037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
22038 }
22039 arg2 = static_cast< bool >(val2);
22040 }
22041 {
22042 PyThreadState* __tstate = wxPyBeginAllowThreads();
22043 (arg1)->Skip(arg2);
22044 wxPyEndAllowThreads(__tstate);
22045 if (PyErr_Occurred()) SWIG_fail;
22046 }
22047 resultobj = SWIG_Py_Void();
22048 return resultobj;
22049 fail:
22050 return NULL;
22051 }
22052
22053
22054 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22055 PyObject *resultobj = 0;
22056 wxEvent *arg1 = (wxEvent *) 0 ;
22057 bool result;
22058 void *argp1 = 0 ;
22059 int res1 = 0 ;
22060 PyObject *swig_obj[1] ;
22061
22062 if (!args) SWIG_fail;
22063 swig_obj[0] = args;
22064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
22065 if (!SWIG_IsOK(res1)) {
22066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
22067 }
22068 arg1 = reinterpret_cast< wxEvent * >(argp1);
22069 {
22070 PyThreadState* __tstate = wxPyBeginAllowThreads();
22071 result = (bool)((wxEvent const *)arg1)->GetSkipped();
22072 wxPyEndAllowThreads(__tstate);
22073 if (PyErr_Occurred()) SWIG_fail;
22074 }
22075 {
22076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22077 }
22078 return resultobj;
22079 fail:
22080 return NULL;
22081 }
22082
22083
22084 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22085 PyObject *resultobj = 0;
22086 wxEvent *arg1 = (wxEvent *) 0 ;
22087 bool result;
22088 void *argp1 = 0 ;
22089 int res1 = 0 ;
22090 PyObject *swig_obj[1] ;
22091
22092 if (!args) SWIG_fail;
22093 swig_obj[0] = args;
22094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
22095 if (!SWIG_IsOK(res1)) {
22096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
22097 }
22098 arg1 = reinterpret_cast< wxEvent * >(argp1);
22099 {
22100 PyThreadState* __tstate = wxPyBeginAllowThreads();
22101 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
22102 wxPyEndAllowThreads(__tstate);
22103 if (PyErr_Occurred()) SWIG_fail;
22104 }
22105 {
22106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22107 }
22108 return resultobj;
22109 fail:
22110 return NULL;
22111 }
22112
22113
22114 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22115 PyObject *resultobj = 0;
22116 wxEvent *arg1 = (wxEvent *) 0 ;
22117 int result;
22118 void *argp1 = 0 ;
22119 int res1 = 0 ;
22120 PyObject *swig_obj[1] ;
22121
22122 if (!args) SWIG_fail;
22123 swig_obj[0] = args;
22124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
22125 if (!SWIG_IsOK(res1)) {
22126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
22127 }
22128 arg1 = reinterpret_cast< wxEvent * >(argp1);
22129 {
22130 PyThreadState* __tstate = wxPyBeginAllowThreads();
22131 result = (int)(arg1)->StopPropagation();
22132 wxPyEndAllowThreads(__tstate);
22133 if (PyErr_Occurred()) SWIG_fail;
22134 }
22135 resultobj = SWIG_From_int(static_cast< int >(result));
22136 return resultobj;
22137 fail:
22138 return NULL;
22139 }
22140
22141
22142 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22143 PyObject *resultobj = 0;
22144 wxEvent *arg1 = (wxEvent *) 0 ;
22145 int arg2 ;
22146 void *argp1 = 0 ;
22147 int res1 = 0 ;
22148 int val2 ;
22149 int ecode2 = 0 ;
22150 PyObject * obj0 = 0 ;
22151 PyObject * obj1 = 0 ;
22152 char * kwnames[] = {
22153 (char *) "self",(char *) "propagationLevel", NULL
22154 };
22155
22156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
22157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
22158 if (!SWIG_IsOK(res1)) {
22159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
22160 }
22161 arg1 = reinterpret_cast< wxEvent * >(argp1);
22162 ecode2 = SWIG_AsVal_int(obj1, &val2);
22163 if (!SWIG_IsOK(ecode2)) {
22164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
22165 }
22166 arg2 = static_cast< int >(val2);
22167 {
22168 PyThreadState* __tstate = wxPyBeginAllowThreads();
22169 (arg1)->ResumePropagation(arg2);
22170 wxPyEndAllowThreads(__tstate);
22171 if (PyErr_Occurred()) SWIG_fail;
22172 }
22173 resultobj = SWIG_Py_Void();
22174 return resultobj;
22175 fail:
22176 return NULL;
22177 }
22178
22179
22180 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22181 PyObject *resultobj = 0;
22182 wxEvent *arg1 = (wxEvent *) 0 ;
22183 wxEvent *result = 0 ;
22184 void *argp1 = 0 ;
22185 int res1 = 0 ;
22186 PyObject *swig_obj[1] ;
22187
22188 if (!args) SWIG_fail;
22189 swig_obj[0] = args;
22190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
22191 if (!SWIG_IsOK(res1)) {
22192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
22193 }
22194 arg1 = reinterpret_cast< wxEvent * >(argp1);
22195 {
22196 PyThreadState* __tstate = wxPyBeginAllowThreads();
22197 result = (wxEvent *)(arg1)->Clone();
22198 wxPyEndAllowThreads(__tstate);
22199 if (PyErr_Occurred()) SWIG_fail;
22200 }
22201 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
22202 return resultobj;
22203 fail:
22204 return NULL;
22205 }
22206
22207
22208 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22209 PyObject *obj;
22210 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22211 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
22212 return SWIG_Py_Void();
22213 }
22214
22215 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22216 PyObject *resultobj = 0;
22217 wxEvent *arg1 = 0 ;
22218 wxPropagationDisabler *result = 0 ;
22219 void *argp1 = 0 ;
22220 int res1 = 0 ;
22221 PyObject * obj0 = 0 ;
22222 char * kwnames[] = {
22223 (char *) "event", NULL
22224 };
22225
22226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
22227 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
22228 if (!SWIG_IsOK(res1)) {
22229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
22230 }
22231 if (!argp1) {
22232 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
22233 }
22234 arg1 = reinterpret_cast< wxEvent * >(argp1);
22235 {
22236 PyThreadState* __tstate = wxPyBeginAllowThreads();
22237 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
22238 wxPyEndAllowThreads(__tstate);
22239 if (PyErr_Occurred()) SWIG_fail;
22240 }
22241 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
22242 return resultobj;
22243 fail:
22244 return NULL;
22245 }
22246
22247
22248 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22249 PyObject *resultobj = 0;
22250 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
22251 void *argp1 = 0 ;
22252 int res1 = 0 ;
22253 PyObject *swig_obj[1] ;
22254
22255 if (!args) SWIG_fail;
22256 swig_obj[0] = args;
22257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
22258 if (!SWIG_IsOK(res1)) {
22259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
22260 }
22261 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
22262 {
22263 PyThreadState* __tstate = wxPyBeginAllowThreads();
22264 delete arg1;
22265
22266 wxPyEndAllowThreads(__tstate);
22267 if (PyErr_Occurred()) SWIG_fail;
22268 }
22269 resultobj = SWIG_Py_Void();
22270 return resultobj;
22271 fail:
22272 return NULL;
22273 }
22274
22275
22276 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22277 PyObject *obj;
22278 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22279 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
22280 return SWIG_Py_Void();
22281 }
22282
22283 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22284 return SWIG_Python_InitShadowInstance(args);
22285 }
22286
22287 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22288 PyObject *resultobj = 0;
22289 wxEvent *arg1 = 0 ;
22290 wxPropagateOnce *result = 0 ;
22291 void *argp1 = 0 ;
22292 int res1 = 0 ;
22293 PyObject * obj0 = 0 ;
22294 char * kwnames[] = {
22295 (char *) "event", NULL
22296 };
22297
22298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
22299 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
22300 if (!SWIG_IsOK(res1)) {
22301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
22302 }
22303 if (!argp1) {
22304 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
22305 }
22306 arg1 = reinterpret_cast< wxEvent * >(argp1);
22307 {
22308 PyThreadState* __tstate = wxPyBeginAllowThreads();
22309 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
22310 wxPyEndAllowThreads(__tstate);
22311 if (PyErr_Occurred()) SWIG_fail;
22312 }
22313 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
22314 return resultobj;
22315 fail:
22316 return NULL;
22317 }
22318
22319
22320 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22321 PyObject *resultobj = 0;
22322 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
22323 void *argp1 = 0 ;
22324 int res1 = 0 ;
22325 PyObject *swig_obj[1] ;
22326
22327 if (!args) SWIG_fail;
22328 swig_obj[0] = args;
22329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
22330 if (!SWIG_IsOK(res1)) {
22331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
22332 }
22333 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
22334 {
22335 PyThreadState* __tstate = wxPyBeginAllowThreads();
22336 delete arg1;
22337
22338 wxPyEndAllowThreads(__tstate);
22339 if (PyErr_Occurred()) SWIG_fail;
22340 }
22341 resultobj = SWIG_Py_Void();
22342 return resultobj;
22343 fail:
22344 return NULL;
22345 }
22346
22347
22348 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22349 PyObject *obj;
22350 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22351 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
22352 return SWIG_Py_Void();
22353 }
22354
22355 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22356 return SWIG_Python_InitShadowInstance(args);
22357 }
22358
22359 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22360 PyObject *resultobj = 0;
22361 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22362 int arg2 = (int) 0 ;
22363 wxCommandEvent *result = 0 ;
22364 int val1 ;
22365 int ecode1 = 0 ;
22366 int val2 ;
22367 int ecode2 = 0 ;
22368 PyObject * obj0 = 0 ;
22369 PyObject * obj1 = 0 ;
22370 char * kwnames[] = {
22371 (char *) "commandType",(char *) "winid", NULL
22372 };
22373
22374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22375 if (obj0) {
22376 ecode1 = SWIG_AsVal_int(obj0, &val1);
22377 if (!SWIG_IsOK(ecode1)) {
22378 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22379 }
22380 arg1 = static_cast< wxEventType >(val1);
22381 }
22382 if (obj1) {
22383 ecode2 = SWIG_AsVal_int(obj1, &val2);
22384 if (!SWIG_IsOK(ecode2)) {
22385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
22386 }
22387 arg2 = static_cast< int >(val2);
22388 }
22389 {
22390 PyThreadState* __tstate = wxPyBeginAllowThreads();
22391 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
22392 wxPyEndAllowThreads(__tstate);
22393 if (PyErr_Occurred()) SWIG_fail;
22394 }
22395 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
22396 return resultobj;
22397 fail:
22398 return NULL;
22399 }
22400
22401
22402 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22403 PyObject *resultobj = 0;
22404 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22405 int result;
22406 void *argp1 = 0 ;
22407 int res1 = 0 ;
22408 PyObject *swig_obj[1] ;
22409
22410 if (!args) SWIG_fail;
22411 swig_obj[0] = args;
22412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22413 if (!SWIG_IsOK(res1)) {
22414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22415 }
22416 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22417 {
22418 PyThreadState* __tstate = wxPyBeginAllowThreads();
22419 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
22420 wxPyEndAllowThreads(__tstate);
22421 if (PyErr_Occurred()) SWIG_fail;
22422 }
22423 resultobj = SWIG_From_int(static_cast< int >(result));
22424 return resultobj;
22425 fail:
22426 return NULL;
22427 }
22428
22429
22430 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22431 PyObject *resultobj = 0;
22432 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22433 wxString *arg2 = 0 ;
22434 void *argp1 = 0 ;
22435 int res1 = 0 ;
22436 bool temp2 = false ;
22437 PyObject * obj0 = 0 ;
22438 PyObject * obj1 = 0 ;
22439 char * kwnames[] = {
22440 (char *) "self",(char *) "s", NULL
22441 };
22442
22443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
22444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22445 if (!SWIG_IsOK(res1)) {
22446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22447 }
22448 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22449 {
22450 arg2 = wxString_in_helper(obj1);
22451 if (arg2 == NULL) SWIG_fail;
22452 temp2 = true;
22453 }
22454 {
22455 PyThreadState* __tstate = wxPyBeginAllowThreads();
22456 (arg1)->SetString((wxString const &)*arg2);
22457 wxPyEndAllowThreads(__tstate);
22458 if (PyErr_Occurred()) SWIG_fail;
22459 }
22460 resultobj = SWIG_Py_Void();
22461 {
22462 if (temp2)
22463 delete arg2;
22464 }
22465 return resultobj;
22466 fail:
22467 {
22468 if (temp2)
22469 delete arg2;
22470 }
22471 return NULL;
22472 }
22473
22474
22475 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22476 PyObject *resultobj = 0;
22477 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22478 wxString result;
22479 void *argp1 = 0 ;
22480 int res1 = 0 ;
22481 PyObject *swig_obj[1] ;
22482
22483 if (!args) SWIG_fail;
22484 swig_obj[0] = args;
22485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22486 if (!SWIG_IsOK(res1)) {
22487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22488 }
22489 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22490 {
22491 PyThreadState* __tstate = wxPyBeginAllowThreads();
22492 result = ((wxCommandEvent const *)arg1)->GetString();
22493 wxPyEndAllowThreads(__tstate);
22494 if (PyErr_Occurred()) SWIG_fail;
22495 }
22496 {
22497 #if wxUSE_UNICODE
22498 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22499 #else
22500 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22501 #endif
22502 }
22503 return resultobj;
22504 fail:
22505 return NULL;
22506 }
22507
22508
22509 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22510 PyObject *resultobj = 0;
22511 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22512 bool result;
22513 void *argp1 = 0 ;
22514 int res1 = 0 ;
22515 PyObject *swig_obj[1] ;
22516
22517 if (!args) SWIG_fail;
22518 swig_obj[0] = args;
22519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22520 if (!SWIG_IsOK(res1)) {
22521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22522 }
22523 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22524 {
22525 PyThreadState* __tstate = wxPyBeginAllowThreads();
22526 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
22527 wxPyEndAllowThreads(__tstate);
22528 if (PyErr_Occurred()) SWIG_fail;
22529 }
22530 {
22531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22532 }
22533 return resultobj;
22534 fail:
22535 return NULL;
22536 }
22537
22538
22539 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22540 PyObject *resultobj = 0;
22541 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22542 bool result;
22543 void *argp1 = 0 ;
22544 int res1 = 0 ;
22545 PyObject *swig_obj[1] ;
22546
22547 if (!args) SWIG_fail;
22548 swig_obj[0] = args;
22549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22550 if (!SWIG_IsOK(res1)) {
22551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22552 }
22553 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22554 {
22555 PyThreadState* __tstate = wxPyBeginAllowThreads();
22556 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
22557 wxPyEndAllowThreads(__tstate);
22558 if (PyErr_Occurred()) SWIG_fail;
22559 }
22560 {
22561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22562 }
22563 return resultobj;
22564 fail:
22565 return NULL;
22566 }
22567
22568
22569 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22570 PyObject *resultobj = 0;
22571 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22572 long arg2 ;
22573 void *argp1 = 0 ;
22574 int res1 = 0 ;
22575 long val2 ;
22576 int ecode2 = 0 ;
22577 PyObject * obj0 = 0 ;
22578 PyObject * obj1 = 0 ;
22579 char * kwnames[] = {
22580 (char *) "self",(char *) "extraLong", NULL
22581 };
22582
22583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
22584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22585 if (!SWIG_IsOK(res1)) {
22586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22587 }
22588 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22589 ecode2 = SWIG_AsVal_long(obj1, &val2);
22590 if (!SWIG_IsOK(ecode2)) {
22591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
22592 }
22593 arg2 = static_cast< long >(val2);
22594 {
22595 PyThreadState* __tstate = wxPyBeginAllowThreads();
22596 (arg1)->SetExtraLong(arg2);
22597 wxPyEndAllowThreads(__tstate);
22598 if (PyErr_Occurred()) SWIG_fail;
22599 }
22600 resultobj = SWIG_Py_Void();
22601 return resultobj;
22602 fail:
22603 return NULL;
22604 }
22605
22606
22607 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22608 PyObject *resultobj = 0;
22609 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22610 long result;
22611 void *argp1 = 0 ;
22612 int res1 = 0 ;
22613 PyObject *swig_obj[1] ;
22614
22615 if (!args) SWIG_fail;
22616 swig_obj[0] = args;
22617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22618 if (!SWIG_IsOK(res1)) {
22619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22620 }
22621 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22622 {
22623 PyThreadState* __tstate = wxPyBeginAllowThreads();
22624 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
22625 wxPyEndAllowThreads(__tstate);
22626 if (PyErr_Occurred()) SWIG_fail;
22627 }
22628 resultobj = SWIG_From_long(static_cast< long >(result));
22629 return resultobj;
22630 fail:
22631 return NULL;
22632 }
22633
22634
22635 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22636 PyObject *resultobj = 0;
22637 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22638 int arg2 ;
22639 void *argp1 = 0 ;
22640 int res1 = 0 ;
22641 int val2 ;
22642 int ecode2 = 0 ;
22643 PyObject * obj0 = 0 ;
22644 PyObject * obj1 = 0 ;
22645 char * kwnames[] = {
22646 (char *) "self",(char *) "i", NULL
22647 };
22648
22649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
22650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22651 if (!SWIG_IsOK(res1)) {
22652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22653 }
22654 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22655 ecode2 = SWIG_AsVal_int(obj1, &val2);
22656 if (!SWIG_IsOK(ecode2)) {
22657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
22658 }
22659 arg2 = static_cast< int >(val2);
22660 {
22661 PyThreadState* __tstate = wxPyBeginAllowThreads();
22662 (arg1)->SetInt(arg2);
22663 wxPyEndAllowThreads(__tstate);
22664 if (PyErr_Occurred()) SWIG_fail;
22665 }
22666 resultobj = SWIG_Py_Void();
22667 return resultobj;
22668 fail:
22669 return NULL;
22670 }
22671
22672
22673 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22674 PyObject *resultobj = 0;
22675 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22676 int result;
22677 void *argp1 = 0 ;
22678 int res1 = 0 ;
22679 PyObject *swig_obj[1] ;
22680
22681 if (!args) SWIG_fail;
22682 swig_obj[0] = args;
22683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22684 if (!SWIG_IsOK(res1)) {
22685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22686 }
22687 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22688 {
22689 PyThreadState* __tstate = wxPyBeginAllowThreads();
22690 result = (int)((wxCommandEvent const *)arg1)->GetInt();
22691 wxPyEndAllowThreads(__tstate);
22692 if (PyErr_Occurred()) SWIG_fail;
22693 }
22694 resultobj = SWIG_From_int(static_cast< int >(result));
22695 return resultobj;
22696 fail:
22697 return NULL;
22698 }
22699
22700
22701 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22702 PyObject *resultobj = 0;
22703 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22704 PyObject *result = 0 ;
22705 void *argp1 = 0 ;
22706 int res1 = 0 ;
22707 PyObject *swig_obj[1] ;
22708
22709 if (!args) SWIG_fail;
22710 swig_obj[0] = args;
22711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22712 if (!SWIG_IsOK(res1)) {
22713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22714 }
22715 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22716 {
22717 PyThreadState* __tstate = wxPyBeginAllowThreads();
22718 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
22719 wxPyEndAllowThreads(__tstate);
22720 if (PyErr_Occurred()) SWIG_fail;
22721 }
22722 resultobj = result;
22723 return resultobj;
22724 fail:
22725 return NULL;
22726 }
22727
22728
22729 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22730 PyObject *resultobj = 0;
22731 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22732 PyObject *arg2 = (PyObject *) 0 ;
22733 void *argp1 = 0 ;
22734 int res1 = 0 ;
22735 PyObject * obj0 = 0 ;
22736 PyObject * obj1 = 0 ;
22737 char * kwnames[] = {
22738 (char *) "self",(char *) "clientData", NULL
22739 };
22740
22741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
22742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22743 if (!SWIG_IsOK(res1)) {
22744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22745 }
22746 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22747 arg2 = obj1;
22748 {
22749 PyThreadState* __tstate = wxPyBeginAllowThreads();
22750 wxCommandEvent_SetClientData(arg1,arg2);
22751 wxPyEndAllowThreads(__tstate);
22752 if (PyErr_Occurred()) SWIG_fail;
22753 }
22754 resultobj = SWIG_Py_Void();
22755 return resultobj;
22756 fail:
22757 return NULL;
22758 }
22759
22760
22761 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22762 PyObject *resultobj = 0;
22763 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22764 wxEvent *result = 0 ;
22765 void *argp1 = 0 ;
22766 int res1 = 0 ;
22767 PyObject *swig_obj[1] ;
22768
22769 if (!args) SWIG_fail;
22770 swig_obj[0] = args;
22771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22772 if (!SWIG_IsOK(res1)) {
22773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22774 }
22775 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22776 {
22777 PyThreadState* __tstate = wxPyBeginAllowThreads();
22778 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
22779 wxPyEndAllowThreads(__tstate);
22780 if (PyErr_Occurred()) SWIG_fail;
22781 }
22782 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
22783 return resultobj;
22784 fail:
22785 return NULL;
22786 }
22787
22788
22789 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22790 PyObject *obj;
22791 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22792 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
22793 return SWIG_Py_Void();
22794 }
22795
22796 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22797 return SWIG_Python_InitShadowInstance(args);
22798 }
22799
22800 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22801 PyObject *resultobj = 0;
22802 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22803 int arg2 = (int) 0 ;
22804 wxNotifyEvent *result = 0 ;
22805 int val1 ;
22806 int ecode1 = 0 ;
22807 int val2 ;
22808 int ecode2 = 0 ;
22809 PyObject * obj0 = 0 ;
22810 PyObject * obj1 = 0 ;
22811 char * kwnames[] = {
22812 (char *) "commandType",(char *) "winid", NULL
22813 };
22814
22815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22816 if (obj0) {
22817 ecode1 = SWIG_AsVal_int(obj0, &val1);
22818 if (!SWIG_IsOK(ecode1)) {
22819 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22820 }
22821 arg1 = static_cast< wxEventType >(val1);
22822 }
22823 if (obj1) {
22824 ecode2 = SWIG_AsVal_int(obj1, &val2);
22825 if (!SWIG_IsOK(ecode2)) {
22826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
22827 }
22828 arg2 = static_cast< int >(val2);
22829 }
22830 {
22831 PyThreadState* __tstate = wxPyBeginAllowThreads();
22832 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
22833 wxPyEndAllowThreads(__tstate);
22834 if (PyErr_Occurred()) SWIG_fail;
22835 }
22836 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
22837 return resultobj;
22838 fail:
22839 return NULL;
22840 }
22841
22842
22843 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22844 PyObject *resultobj = 0;
22845 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22846 void *argp1 = 0 ;
22847 int res1 = 0 ;
22848 PyObject *swig_obj[1] ;
22849
22850 if (!args) SWIG_fail;
22851 swig_obj[0] = args;
22852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22853 if (!SWIG_IsOK(res1)) {
22854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22855 }
22856 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22857 {
22858 PyThreadState* __tstate = wxPyBeginAllowThreads();
22859 (arg1)->Veto();
22860 wxPyEndAllowThreads(__tstate);
22861 if (PyErr_Occurred()) SWIG_fail;
22862 }
22863 resultobj = SWIG_Py_Void();
22864 return resultobj;
22865 fail:
22866 return NULL;
22867 }
22868
22869
22870 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22871 PyObject *resultobj = 0;
22872 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22873 void *argp1 = 0 ;
22874 int res1 = 0 ;
22875 PyObject *swig_obj[1] ;
22876
22877 if (!args) SWIG_fail;
22878 swig_obj[0] = args;
22879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22880 if (!SWIG_IsOK(res1)) {
22881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22882 }
22883 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22884 {
22885 PyThreadState* __tstate = wxPyBeginAllowThreads();
22886 (arg1)->Allow();
22887 wxPyEndAllowThreads(__tstate);
22888 if (PyErr_Occurred()) SWIG_fail;
22889 }
22890 resultobj = SWIG_Py_Void();
22891 return resultobj;
22892 fail:
22893 return NULL;
22894 }
22895
22896
22897 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22898 PyObject *resultobj = 0;
22899 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22900 bool result;
22901 void *argp1 = 0 ;
22902 int res1 = 0 ;
22903 PyObject *swig_obj[1] ;
22904
22905 if (!args) SWIG_fail;
22906 swig_obj[0] = args;
22907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22908 if (!SWIG_IsOK(res1)) {
22909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22910 }
22911 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22912 {
22913 PyThreadState* __tstate = wxPyBeginAllowThreads();
22914 result = (bool)(arg1)->IsAllowed();
22915 wxPyEndAllowThreads(__tstate);
22916 if (PyErr_Occurred()) SWIG_fail;
22917 }
22918 {
22919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22920 }
22921 return resultobj;
22922 fail:
22923 return NULL;
22924 }
22925
22926
22927 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22928 PyObject *obj;
22929 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22930 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
22931 return SWIG_Py_Void();
22932 }
22933
22934 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22935 return SWIG_Python_InitShadowInstance(args);
22936 }
22937
22938 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22939 PyObject *resultobj = 0;
22940 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22941 int arg2 = (int) 0 ;
22942 int arg3 = (int) 0 ;
22943 int arg4 = (int) 0 ;
22944 wxScrollEvent *result = 0 ;
22945 int val1 ;
22946 int ecode1 = 0 ;
22947 int val2 ;
22948 int ecode2 = 0 ;
22949 int val3 ;
22950 int ecode3 = 0 ;
22951 int val4 ;
22952 int ecode4 = 0 ;
22953 PyObject * obj0 = 0 ;
22954 PyObject * obj1 = 0 ;
22955 PyObject * obj2 = 0 ;
22956 PyObject * obj3 = 0 ;
22957 char * kwnames[] = {
22958 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
22959 };
22960
22961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22962 if (obj0) {
22963 ecode1 = SWIG_AsVal_int(obj0, &val1);
22964 if (!SWIG_IsOK(ecode1)) {
22965 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22966 }
22967 arg1 = static_cast< wxEventType >(val1);
22968 }
22969 if (obj1) {
22970 ecode2 = SWIG_AsVal_int(obj1, &val2);
22971 if (!SWIG_IsOK(ecode2)) {
22972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
22973 }
22974 arg2 = static_cast< int >(val2);
22975 }
22976 if (obj2) {
22977 ecode3 = SWIG_AsVal_int(obj2, &val3);
22978 if (!SWIG_IsOK(ecode3)) {
22979 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
22980 }
22981 arg3 = static_cast< int >(val3);
22982 }
22983 if (obj3) {
22984 ecode4 = SWIG_AsVal_int(obj3, &val4);
22985 if (!SWIG_IsOK(ecode4)) {
22986 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
22987 }
22988 arg4 = static_cast< int >(val4);
22989 }
22990 {
22991 PyThreadState* __tstate = wxPyBeginAllowThreads();
22992 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
22993 wxPyEndAllowThreads(__tstate);
22994 if (PyErr_Occurred()) SWIG_fail;
22995 }
22996 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
22997 return resultobj;
22998 fail:
22999 return NULL;
23000 }
23001
23002
23003 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23004 PyObject *resultobj = 0;
23005 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
23006 int result;
23007 void *argp1 = 0 ;
23008 int res1 = 0 ;
23009 PyObject *swig_obj[1] ;
23010
23011 if (!args) SWIG_fail;
23012 swig_obj[0] = args;
23013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
23014 if (!SWIG_IsOK(res1)) {
23015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
23016 }
23017 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
23018 {
23019 PyThreadState* __tstate = wxPyBeginAllowThreads();
23020 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
23021 wxPyEndAllowThreads(__tstate);
23022 if (PyErr_Occurred()) SWIG_fail;
23023 }
23024 resultobj = SWIG_From_int(static_cast< int >(result));
23025 return resultobj;
23026 fail:
23027 return NULL;
23028 }
23029
23030
23031 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23032 PyObject *resultobj = 0;
23033 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
23034 int result;
23035 void *argp1 = 0 ;
23036 int res1 = 0 ;
23037 PyObject *swig_obj[1] ;
23038
23039 if (!args) SWIG_fail;
23040 swig_obj[0] = args;
23041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
23042 if (!SWIG_IsOK(res1)) {
23043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
23044 }
23045 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
23046 {
23047 PyThreadState* __tstate = wxPyBeginAllowThreads();
23048 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
23049 wxPyEndAllowThreads(__tstate);
23050 if (PyErr_Occurred()) SWIG_fail;
23051 }
23052 resultobj = SWIG_From_int(static_cast< int >(result));
23053 return resultobj;
23054 fail:
23055 return NULL;
23056 }
23057
23058
23059 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23060 PyObject *resultobj = 0;
23061 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
23062 int arg2 ;
23063 void *argp1 = 0 ;
23064 int res1 = 0 ;
23065 int val2 ;
23066 int ecode2 = 0 ;
23067 PyObject * obj0 = 0 ;
23068 PyObject * obj1 = 0 ;
23069 char * kwnames[] = {
23070 (char *) "self",(char *) "orient", NULL
23071 };
23072
23073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
23074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
23075 if (!SWIG_IsOK(res1)) {
23076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
23077 }
23078 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
23079 ecode2 = SWIG_AsVal_int(obj1, &val2);
23080 if (!SWIG_IsOK(ecode2)) {
23081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
23082 }
23083 arg2 = static_cast< int >(val2);
23084 {
23085 PyThreadState* __tstate = wxPyBeginAllowThreads();
23086 (arg1)->SetOrientation(arg2);
23087 wxPyEndAllowThreads(__tstate);
23088 if (PyErr_Occurred()) SWIG_fail;
23089 }
23090 resultobj = SWIG_Py_Void();
23091 return resultobj;
23092 fail:
23093 return NULL;
23094 }
23095
23096
23097 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23098 PyObject *resultobj = 0;
23099 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
23100 int arg2 ;
23101 void *argp1 = 0 ;
23102 int res1 = 0 ;
23103 int val2 ;
23104 int ecode2 = 0 ;
23105 PyObject * obj0 = 0 ;
23106 PyObject * obj1 = 0 ;
23107 char * kwnames[] = {
23108 (char *) "self",(char *) "pos", NULL
23109 };
23110
23111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
23113 if (!SWIG_IsOK(res1)) {
23114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
23115 }
23116 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
23117 ecode2 = SWIG_AsVal_int(obj1, &val2);
23118 if (!SWIG_IsOK(ecode2)) {
23119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
23120 }
23121 arg2 = static_cast< int >(val2);
23122 {
23123 PyThreadState* __tstate = wxPyBeginAllowThreads();
23124 (arg1)->SetPosition(arg2);
23125 wxPyEndAllowThreads(__tstate);
23126 if (PyErr_Occurred()) SWIG_fail;
23127 }
23128 resultobj = SWIG_Py_Void();
23129 return resultobj;
23130 fail:
23131 return NULL;
23132 }
23133
23134
23135 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23136 PyObject *obj;
23137 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23138 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
23139 return SWIG_Py_Void();
23140 }
23141
23142 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23143 return SWIG_Python_InitShadowInstance(args);
23144 }
23145
23146 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23147 PyObject *resultobj = 0;
23148 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23149 int arg2 = (int) 0 ;
23150 int arg3 = (int) 0 ;
23151 wxScrollWinEvent *result = 0 ;
23152 int val1 ;
23153 int ecode1 = 0 ;
23154 int val2 ;
23155 int ecode2 = 0 ;
23156 int val3 ;
23157 int ecode3 = 0 ;
23158 PyObject * obj0 = 0 ;
23159 PyObject * obj1 = 0 ;
23160 PyObject * obj2 = 0 ;
23161 char * kwnames[] = {
23162 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
23163 };
23164
23165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23166 if (obj0) {
23167 ecode1 = SWIG_AsVal_int(obj0, &val1);
23168 if (!SWIG_IsOK(ecode1)) {
23169 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23170 }
23171 arg1 = static_cast< wxEventType >(val1);
23172 }
23173 if (obj1) {
23174 ecode2 = SWIG_AsVal_int(obj1, &val2);
23175 if (!SWIG_IsOK(ecode2)) {
23176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
23177 }
23178 arg2 = static_cast< int >(val2);
23179 }
23180 if (obj2) {
23181 ecode3 = SWIG_AsVal_int(obj2, &val3);
23182 if (!SWIG_IsOK(ecode3)) {
23183 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
23184 }
23185 arg3 = static_cast< int >(val3);
23186 }
23187 {
23188 PyThreadState* __tstate = wxPyBeginAllowThreads();
23189 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
23190 wxPyEndAllowThreads(__tstate);
23191 if (PyErr_Occurred()) SWIG_fail;
23192 }
23193 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
23194 return resultobj;
23195 fail:
23196 return NULL;
23197 }
23198
23199
23200 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23201 PyObject *resultobj = 0;
23202 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
23203 int result;
23204 void *argp1 = 0 ;
23205 int res1 = 0 ;
23206 PyObject *swig_obj[1] ;
23207
23208 if (!args) SWIG_fail;
23209 swig_obj[0] = args;
23210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
23211 if (!SWIG_IsOK(res1)) {
23212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
23213 }
23214 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
23215 {
23216 PyThreadState* __tstate = wxPyBeginAllowThreads();
23217 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
23218 wxPyEndAllowThreads(__tstate);
23219 if (PyErr_Occurred()) SWIG_fail;
23220 }
23221 resultobj = SWIG_From_int(static_cast< int >(result));
23222 return resultobj;
23223 fail:
23224 return NULL;
23225 }
23226
23227
23228 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23229 PyObject *resultobj = 0;
23230 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
23231 int result;
23232 void *argp1 = 0 ;
23233 int res1 = 0 ;
23234 PyObject *swig_obj[1] ;
23235
23236 if (!args) SWIG_fail;
23237 swig_obj[0] = args;
23238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
23239 if (!SWIG_IsOK(res1)) {
23240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
23241 }
23242 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
23243 {
23244 PyThreadState* __tstate = wxPyBeginAllowThreads();
23245 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
23246 wxPyEndAllowThreads(__tstate);
23247 if (PyErr_Occurred()) SWIG_fail;
23248 }
23249 resultobj = SWIG_From_int(static_cast< int >(result));
23250 return resultobj;
23251 fail:
23252 return NULL;
23253 }
23254
23255
23256 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23257 PyObject *resultobj = 0;
23258 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
23259 int arg2 ;
23260 void *argp1 = 0 ;
23261 int res1 = 0 ;
23262 int val2 ;
23263 int ecode2 = 0 ;
23264 PyObject * obj0 = 0 ;
23265 PyObject * obj1 = 0 ;
23266 char * kwnames[] = {
23267 (char *) "self",(char *) "orient", NULL
23268 };
23269
23270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
23271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
23272 if (!SWIG_IsOK(res1)) {
23273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
23274 }
23275 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
23276 ecode2 = SWIG_AsVal_int(obj1, &val2);
23277 if (!SWIG_IsOK(ecode2)) {
23278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
23279 }
23280 arg2 = static_cast< int >(val2);
23281 {
23282 PyThreadState* __tstate = wxPyBeginAllowThreads();
23283 (arg1)->SetOrientation(arg2);
23284 wxPyEndAllowThreads(__tstate);
23285 if (PyErr_Occurred()) SWIG_fail;
23286 }
23287 resultobj = SWIG_Py_Void();
23288 return resultobj;
23289 fail:
23290 return NULL;
23291 }
23292
23293
23294 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23295 PyObject *resultobj = 0;
23296 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
23297 int arg2 ;
23298 void *argp1 = 0 ;
23299 int res1 = 0 ;
23300 int val2 ;
23301 int ecode2 = 0 ;
23302 PyObject * obj0 = 0 ;
23303 PyObject * obj1 = 0 ;
23304 char * kwnames[] = {
23305 (char *) "self",(char *) "pos", NULL
23306 };
23307
23308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
23310 if (!SWIG_IsOK(res1)) {
23311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
23312 }
23313 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
23314 ecode2 = SWIG_AsVal_int(obj1, &val2);
23315 if (!SWIG_IsOK(ecode2)) {
23316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
23317 }
23318 arg2 = static_cast< int >(val2);
23319 {
23320 PyThreadState* __tstate = wxPyBeginAllowThreads();
23321 (arg1)->SetPosition(arg2);
23322 wxPyEndAllowThreads(__tstate);
23323 if (PyErr_Occurred()) SWIG_fail;
23324 }
23325 resultobj = SWIG_Py_Void();
23326 return resultobj;
23327 fail:
23328 return NULL;
23329 }
23330
23331
23332 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23333 PyObject *obj;
23334 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23335 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
23336 return SWIG_Py_Void();
23337 }
23338
23339 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23340 return SWIG_Python_InitShadowInstance(args);
23341 }
23342
23343 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23344 PyObject *resultobj = 0;
23345 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23346 wxMouseEvent *result = 0 ;
23347 int val1 ;
23348 int ecode1 = 0 ;
23349 PyObject * obj0 = 0 ;
23350 char * kwnames[] = {
23351 (char *) "mouseType", NULL
23352 };
23353
23354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
23355 if (obj0) {
23356 ecode1 = SWIG_AsVal_int(obj0, &val1);
23357 if (!SWIG_IsOK(ecode1)) {
23358 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23359 }
23360 arg1 = static_cast< wxEventType >(val1);
23361 }
23362 {
23363 PyThreadState* __tstate = wxPyBeginAllowThreads();
23364 result = (wxMouseEvent *)new wxMouseEvent(arg1);
23365 wxPyEndAllowThreads(__tstate);
23366 if (PyErr_Occurred()) SWIG_fail;
23367 }
23368 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_NEW | 0 );
23369 return resultobj;
23370 fail:
23371 return NULL;
23372 }
23373
23374
23375 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23376 PyObject *resultobj = 0;
23377 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23378 bool result;
23379 void *argp1 = 0 ;
23380 int res1 = 0 ;
23381 PyObject *swig_obj[1] ;
23382
23383 if (!args) SWIG_fail;
23384 swig_obj[0] = args;
23385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23386 if (!SWIG_IsOK(res1)) {
23387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23388 }
23389 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23390 {
23391 PyThreadState* __tstate = wxPyBeginAllowThreads();
23392 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
23393 wxPyEndAllowThreads(__tstate);
23394 if (PyErr_Occurred()) SWIG_fail;
23395 }
23396 {
23397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23398 }
23399 return resultobj;
23400 fail:
23401 return NULL;
23402 }
23403
23404
23405 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23406 PyObject *resultobj = 0;
23407 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23408 int arg2 = (int) wxMOUSE_BTN_ANY ;
23409 bool result;
23410 void *argp1 = 0 ;
23411 int res1 = 0 ;
23412 int val2 ;
23413 int ecode2 = 0 ;
23414 PyObject * obj0 = 0 ;
23415 PyObject * obj1 = 0 ;
23416 char * kwnames[] = {
23417 (char *) "self",(char *) "but", NULL
23418 };
23419
23420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
23421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23422 if (!SWIG_IsOK(res1)) {
23423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23424 }
23425 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23426 if (obj1) {
23427 ecode2 = SWIG_AsVal_int(obj1, &val2);
23428 if (!SWIG_IsOK(ecode2)) {
23429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
23430 }
23431 arg2 = static_cast< int >(val2);
23432 }
23433 {
23434 PyThreadState* __tstate = wxPyBeginAllowThreads();
23435 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
23436 wxPyEndAllowThreads(__tstate);
23437 if (PyErr_Occurred()) SWIG_fail;
23438 }
23439 {
23440 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23441 }
23442 return resultobj;
23443 fail:
23444 return NULL;
23445 }
23446
23447
23448 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23449 PyObject *resultobj = 0;
23450 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23451 int arg2 = (int) wxMOUSE_BTN_ANY ;
23452 bool result;
23453 void *argp1 = 0 ;
23454 int res1 = 0 ;
23455 int val2 ;
23456 int ecode2 = 0 ;
23457 PyObject * obj0 = 0 ;
23458 PyObject * obj1 = 0 ;
23459 char * kwnames[] = {
23460 (char *) "self",(char *) "but", NULL
23461 };
23462
23463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
23464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23465 if (!SWIG_IsOK(res1)) {
23466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23467 }
23468 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23469 if (obj1) {
23470 ecode2 = SWIG_AsVal_int(obj1, &val2);
23471 if (!SWIG_IsOK(ecode2)) {
23472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
23473 }
23474 arg2 = static_cast< int >(val2);
23475 }
23476 {
23477 PyThreadState* __tstate = wxPyBeginAllowThreads();
23478 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
23479 wxPyEndAllowThreads(__tstate);
23480 if (PyErr_Occurred()) SWIG_fail;
23481 }
23482 {
23483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23484 }
23485 return resultobj;
23486 fail:
23487 return NULL;
23488 }
23489
23490
23491 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23492 PyObject *resultobj = 0;
23493 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23494 int arg2 = (int) wxMOUSE_BTN_ANY ;
23495 bool result;
23496 void *argp1 = 0 ;
23497 int res1 = 0 ;
23498 int val2 ;
23499 int ecode2 = 0 ;
23500 PyObject * obj0 = 0 ;
23501 PyObject * obj1 = 0 ;
23502 char * kwnames[] = {
23503 (char *) "self",(char *) "but", NULL
23504 };
23505
23506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
23507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23508 if (!SWIG_IsOK(res1)) {
23509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23510 }
23511 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23512 if (obj1) {
23513 ecode2 = SWIG_AsVal_int(obj1, &val2);
23514 if (!SWIG_IsOK(ecode2)) {
23515 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
23516 }
23517 arg2 = static_cast< int >(val2);
23518 }
23519 {
23520 PyThreadState* __tstate = wxPyBeginAllowThreads();
23521 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
23522 wxPyEndAllowThreads(__tstate);
23523 if (PyErr_Occurred()) SWIG_fail;
23524 }
23525 {
23526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23527 }
23528 return resultobj;
23529 fail:
23530 return NULL;
23531 }
23532
23533
23534 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23535 PyObject *resultobj = 0;
23536 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23537 int arg2 ;
23538 bool result;
23539 void *argp1 = 0 ;
23540 int res1 = 0 ;
23541 int val2 ;
23542 int ecode2 = 0 ;
23543 PyObject * obj0 = 0 ;
23544 PyObject * obj1 = 0 ;
23545 char * kwnames[] = {
23546 (char *) "self",(char *) "button", NULL
23547 };
23548
23549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
23550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23551 if (!SWIG_IsOK(res1)) {
23552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23553 }
23554 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23555 ecode2 = SWIG_AsVal_int(obj1, &val2);
23556 if (!SWIG_IsOK(ecode2)) {
23557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
23558 }
23559 arg2 = static_cast< int >(val2);
23560 {
23561 PyThreadState* __tstate = wxPyBeginAllowThreads();
23562 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
23563 wxPyEndAllowThreads(__tstate);
23564 if (PyErr_Occurred()) SWIG_fail;
23565 }
23566 {
23567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23568 }
23569 return resultobj;
23570 fail:
23571 return NULL;
23572 }
23573
23574
23575 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23576 PyObject *resultobj = 0;
23577 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23578 int arg2 ;
23579 bool result;
23580 void *argp1 = 0 ;
23581 int res1 = 0 ;
23582 int val2 ;
23583 int ecode2 = 0 ;
23584 PyObject * obj0 = 0 ;
23585 PyObject * obj1 = 0 ;
23586 char * kwnames[] = {
23587 (char *) "self",(char *) "but", NULL
23588 };
23589
23590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
23591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23592 if (!SWIG_IsOK(res1)) {
23593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23594 }
23595 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23596 ecode2 = SWIG_AsVal_int(obj1, &val2);
23597 if (!SWIG_IsOK(ecode2)) {
23598 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
23599 }
23600 arg2 = static_cast< int >(val2);
23601 {
23602 PyThreadState* __tstate = wxPyBeginAllowThreads();
23603 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
23604 wxPyEndAllowThreads(__tstate);
23605 if (PyErr_Occurred()) SWIG_fail;
23606 }
23607 {
23608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23609 }
23610 return resultobj;
23611 fail:
23612 return NULL;
23613 }
23614
23615
23616 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23617 PyObject *resultobj = 0;
23618 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23619 int result;
23620 void *argp1 = 0 ;
23621 int res1 = 0 ;
23622 PyObject *swig_obj[1] ;
23623
23624 if (!args) SWIG_fail;
23625 swig_obj[0] = args;
23626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23627 if (!SWIG_IsOK(res1)) {
23628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23629 }
23630 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23631 {
23632 PyThreadState* __tstate = wxPyBeginAllowThreads();
23633 result = (int)((wxMouseEvent const *)arg1)->GetButton();
23634 wxPyEndAllowThreads(__tstate);
23635 if (PyErr_Occurred()) SWIG_fail;
23636 }
23637 resultobj = SWIG_From_int(static_cast< int >(result));
23638 return resultobj;
23639 fail:
23640 return NULL;
23641 }
23642
23643
23644 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23645 PyObject *resultobj = 0;
23646 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23647 bool result;
23648 void *argp1 = 0 ;
23649 int res1 = 0 ;
23650 PyObject *swig_obj[1] ;
23651
23652 if (!args) SWIG_fail;
23653 swig_obj[0] = args;
23654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23655 if (!SWIG_IsOK(res1)) {
23656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23657 }
23658 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23659 {
23660 PyThreadState* __tstate = wxPyBeginAllowThreads();
23661 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
23662 wxPyEndAllowThreads(__tstate);
23663 if (PyErr_Occurred()) SWIG_fail;
23664 }
23665 {
23666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23667 }
23668 return resultobj;
23669 fail:
23670 return NULL;
23671 }
23672
23673
23674 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23675 PyObject *resultobj = 0;
23676 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23677 bool result;
23678 void *argp1 = 0 ;
23679 int res1 = 0 ;
23680 PyObject *swig_obj[1] ;
23681
23682 if (!args) SWIG_fail;
23683 swig_obj[0] = args;
23684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23685 if (!SWIG_IsOK(res1)) {
23686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23687 }
23688 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23689 {
23690 PyThreadState* __tstate = wxPyBeginAllowThreads();
23691 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
23692 wxPyEndAllowThreads(__tstate);
23693 if (PyErr_Occurred()) SWIG_fail;
23694 }
23695 {
23696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23697 }
23698 return resultobj;
23699 fail:
23700 return NULL;
23701 }
23702
23703
23704 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23705 PyObject *resultobj = 0;
23706 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23707 bool result;
23708 void *argp1 = 0 ;
23709 int res1 = 0 ;
23710 PyObject *swig_obj[1] ;
23711
23712 if (!args) SWIG_fail;
23713 swig_obj[0] = args;
23714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23715 if (!SWIG_IsOK(res1)) {
23716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23717 }
23718 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23719 {
23720 PyThreadState* __tstate = wxPyBeginAllowThreads();
23721 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
23722 wxPyEndAllowThreads(__tstate);
23723 if (PyErr_Occurred()) SWIG_fail;
23724 }
23725 {
23726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23727 }
23728 return resultobj;
23729 fail:
23730 return NULL;
23731 }
23732
23733
23734 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23735 PyObject *resultobj = 0;
23736 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23737 bool result;
23738 void *argp1 = 0 ;
23739 int res1 = 0 ;
23740 PyObject *swig_obj[1] ;
23741
23742 if (!args) SWIG_fail;
23743 swig_obj[0] = args;
23744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23745 if (!SWIG_IsOK(res1)) {
23746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23747 }
23748 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23749 {
23750 PyThreadState* __tstate = wxPyBeginAllowThreads();
23751 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
23752 wxPyEndAllowThreads(__tstate);
23753 if (PyErr_Occurred()) SWIG_fail;
23754 }
23755 {
23756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23757 }
23758 return resultobj;
23759 fail:
23760 return NULL;
23761 }
23762
23763
23764 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23765 PyObject *resultobj = 0;
23766 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23767 bool result;
23768 void *argp1 = 0 ;
23769 int res1 = 0 ;
23770 PyObject *swig_obj[1] ;
23771
23772 if (!args) SWIG_fail;
23773 swig_obj[0] = args;
23774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23775 if (!SWIG_IsOK(res1)) {
23776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23777 }
23778 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23779 {
23780 PyThreadState* __tstate = wxPyBeginAllowThreads();
23781 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
23782 wxPyEndAllowThreads(__tstate);
23783 if (PyErr_Occurred()) SWIG_fail;
23784 }
23785 {
23786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23787 }
23788 return resultobj;
23789 fail:
23790 return NULL;
23791 }
23792
23793
23794 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23795 PyObject *resultobj = 0;
23796 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23797 bool result;
23798 void *argp1 = 0 ;
23799 int res1 = 0 ;
23800 PyObject *swig_obj[1] ;
23801
23802 if (!args) SWIG_fail;
23803 swig_obj[0] = args;
23804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23805 if (!SWIG_IsOK(res1)) {
23806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23807 }
23808 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23809 {
23810 PyThreadState* __tstate = wxPyBeginAllowThreads();
23811 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
23812 wxPyEndAllowThreads(__tstate);
23813 if (PyErr_Occurred()) SWIG_fail;
23814 }
23815 {
23816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23817 }
23818 return resultobj;
23819 fail:
23820 return NULL;
23821 }
23822
23823
23824 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23825 PyObject *resultobj = 0;
23826 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23827 bool result;
23828 void *argp1 = 0 ;
23829 int res1 = 0 ;
23830 PyObject *swig_obj[1] ;
23831
23832 if (!args) SWIG_fail;
23833 swig_obj[0] = args;
23834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23835 if (!SWIG_IsOK(res1)) {
23836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23837 }
23838 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23839 {
23840 PyThreadState* __tstate = wxPyBeginAllowThreads();
23841 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
23842 wxPyEndAllowThreads(__tstate);
23843 if (PyErr_Occurred()) SWIG_fail;
23844 }
23845 {
23846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23847 }
23848 return resultobj;
23849 fail:
23850 return NULL;
23851 }
23852
23853
23854 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23855 PyObject *resultobj = 0;
23856 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23857 bool result;
23858 void *argp1 = 0 ;
23859 int res1 = 0 ;
23860 PyObject *swig_obj[1] ;
23861
23862 if (!args) SWIG_fail;
23863 swig_obj[0] = args;
23864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23865 if (!SWIG_IsOK(res1)) {
23866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23867 }
23868 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23869 {
23870 PyThreadState* __tstate = wxPyBeginAllowThreads();
23871 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
23872 wxPyEndAllowThreads(__tstate);
23873 if (PyErr_Occurred()) SWIG_fail;
23874 }
23875 {
23876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23877 }
23878 return resultobj;
23879 fail:
23880 return NULL;
23881 }
23882
23883
23884 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23885 PyObject *resultobj = 0;
23886 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23887 bool 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_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23897 }
23898 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23899 {
23900 PyThreadState* __tstate = wxPyBeginAllowThreads();
23901 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
23902 wxPyEndAllowThreads(__tstate);
23903 if (PyErr_Occurred()) SWIG_fail;
23904 }
23905 {
23906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23907 }
23908 return resultobj;
23909 fail:
23910 return NULL;
23911 }
23912
23913
23914 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23915 PyObject *resultobj = 0;
23916 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23917 bool result;
23918 void *argp1 = 0 ;
23919 int res1 = 0 ;
23920 PyObject *swig_obj[1] ;
23921
23922 if (!args) SWIG_fail;
23923 swig_obj[0] = args;
23924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23925 if (!SWIG_IsOK(res1)) {
23926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23927 }
23928 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23929 {
23930 PyThreadState* __tstate = wxPyBeginAllowThreads();
23931 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
23932 wxPyEndAllowThreads(__tstate);
23933 if (PyErr_Occurred()) SWIG_fail;
23934 }
23935 {
23936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23937 }
23938 return resultobj;
23939 fail:
23940 return NULL;
23941 }
23942
23943
23944 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23945 PyObject *resultobj = 0;
23946 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23947 bool result;
23948 void *argp1 = 0 ;
23949 int res1 = 0 ;
23950 PyObject *swig_obj[1] ;
23951
23952 if (!args) SWIG_fail;
23953 swig_obj[0] = args;
23954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23955 if (!SWIG_IsOK(res1)) {
23956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23957 }
23958 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23959 {
23960 PyThreadState* __tstate = wxPyBeginAllowThreads();
23961 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
23962 wxPyEndAllowThreads(__tstate);
23963 if (PyErr_Occurred()) SWIG_fail;
23964 }
23965 {
23966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23967 }
23968 return resultobj;
23969 fail:
23970 return NULL;
23971 }
23972
23973
23974 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23975 PyObject *resultobj = 0;
23976 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23977 bool result;
23978 void *argp1 = 0 ;
23979 int res1 = 0 ;
23980 PyObject *swig_obj[1] ;
23981
23982 if (!args) SWIG_fail;
23983 swig_obj[0] = args;
23984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23985 if (!SWIG_IsOK(res1)) {
23986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23987 }
23988 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23989 {
23990 PyThreadState* __tstate = wxPyBeginAllowThreads();
23991 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
23992 wxPyEndAllowThreads(__tstate);
23993 if (PyErr_Occurred()) SWIG_fail;
23994 }
23995 {
23996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23997 }
23998 return resultobj;
23999 fail:
24000 return NULL;
24001 }
24002
24003
24004 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24005 PyObject *resultobj = 0;
24006 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24007 bool result;
24008 void *argp1 = 0 ;
24009 int res1 = 0 ;
24010 PyObject *swig_obj[1] ;
24011
24012 if (!args) SWIG_fail;
24013 swig_obj[0] = args;
24014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24015 if (!SWIG_IsOK(res1)) {
24016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24017 }
24018 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24019 {
24020 PyThreadState* __tstate = wxPyBeginAllowThreads();
24021 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
24022 wxPyEndAllowThreads(__tstate);
24023 if (PyErr_Occurred()) SWIG_fail;
24024 }
24025 {
24026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24027 }
24028 return resultobj;
24029 fail:
24030 return NULL;
24031 }
24032
24033
24034 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24035 PyObject *resultobj = 0;
24036 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24037 bool result;
24038 void *argp1 = 0 ;
24039 int res1 = 0 ;
24040 PyObject *swig_obj[1] ;
24041
24042 if (!args) SWIG_fail;
24043 swig_obj[0] = args;
24044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24045 if (!SWIG_IsOK(res1)) {
24046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24047 }
24048 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24049 {
24050 PyThreadState* __tstate = wxPyBeginAllowThreads();
24051 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
24052 wxPyEndAllowThreads(__tstate);
24053 if (PyErr_Occurred()) SWIG_fail;
24054 }
24055 {
24056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24057 }
24058 return resultobj;
24059 fail:
24060 return NULL;
24061 }
24062
24063
24064 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24065 PyObject *resultobj = 0;
24066 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24067 bool result;
24068 void *argp1 = 0 ;
24069 int res1 = 0 ;
24070 PyObject *swig_obj[1] ;
24071
24072 if (!args) SWIG_fail;
24073 swig_obj[0] = args;
24074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24075 if (!SWIG_IsOK(res1)) {
24076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24077 }
24078 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24079 {
24080 PyThreadState* __tstate = wxPyBeginAllowThreads();
24081 result = (bool)(arg1)->LeftIsDown();
24082 wxPyEndAllowThreads(__tstate);
24083 if (PyErr_Occurred()) SWIG_fail;
24084 }
24085 {
24086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24087 }
24088 return resultobj;
24089 fail:
24090 return NULL;
24091 }
24092
24093
24094 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24095 PyObject *resultobj = 0;
24096 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24097 bool result;
24098 void *argp1 = 0 ;
24099 int res1 = 0 ;
24100 PyObject *swig_obj[1] ;
24101
24102 if (!args) SWIG_fail;
24103 swig_obj[0] = args;
24104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24105 if (!SWIG_IsOK(res1)) {
24106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24107 }
24108 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24109 {
24110 PyThreadState* __tstate = wxPyBeginAllowThreads();
24111 result = (bool)(arg1)->MiddleIsDown();
24112 wxPyEndAllowThreads(__tstate);
24113 if (PyErr_Occurred()) SWIG_fail;
24114 }
24115 {
24116 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24117 }
24118 return resultobj;
24119 fail:
24120 return NULL;
24121 }
24122
24123
24124 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24125 PyObject *resultobj = 0;
24126 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24127 bool result;
24128 void *argp1 = 0 ;
24129 int res1 = 0 ;
24130 PyObject *swig_obj[1] ;
24131
24132 if (!args) SWIG_fail;
24133 swig_obj[0] = args;
24134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24135 if (!SWIG_IsOK(res1)) {
24136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24137 }
24138 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24139 {
24140 PyThreadState* __tstate = wxPyBeginAllowThreads();
24141 result = (bool)(arg1)->RightIsDown();
24142 wxPyEndAllowThreads(__tstate);
24143 if (PyErr_Occurred()) SWIG_fail;
24144 }
24145 {
24146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24147 }
24148 return resultobj;
24149 fail:
24150 return NULL;
24151 }
24152
24153
24154 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24155 PyObject *resultobj = 0;
24156 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24157 bool result;
24158 void *argp1 = 0 ;
24159 int res1 = 0 ;
24160 PyObject *swig_obj[1] ;
24161
24162 if (!args) SWIG_fail;
24163 swig_obj[0] = args;
24164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24165 if (!SWIG_IsOK(res1)) {
24166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24167 }
24168 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24169 {
24170 PyThreadState* __tstate = wxPyBeginAllowThreads();
24171 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
24172 wxPyEndAllowThreads(__tstate);
24173 if (PyErr_Occurred()) SWIG_fail;
24174 }
24175 {
24176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24177 }
24178 return resultobj;
24179 fail:
24180 return NULL;
24181 }
24182
24183
24184 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24185 PyObject *resultobj = 0;
24186 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24187 bool result;
24188 void *argp1 = 0 ;
24189 int res1 = 0 ;
24190 PyObject *swig_obj[1] ;
24191
24192 if (!args) SWIG_fail;
24193 swig_obj[0] = args;
24194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24195 if (!SWIG_IsOK(res1)) {
24196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24197 }
24198 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24199 {
24200 PyThreadState* __tstate = wxPyBeginAllowThreads();
24201 result = (bool)((wxMouseEvent const *)arg1)->Moving();
24202 wxPyEndAllowThreads(__tstate);
24203 if (PyErr_Occurred()) SWIG_fail;
24204 }
24205 {
24206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24207 }
24208 return resultobj;
24209 fail:
24210 return NULL;
24211 }
24212
24213
24214 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24215 PyObject *resultobj = 0;
24216 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24217 bool result;
24218 void *argp1 = 0 ;
24219 int res1 = 0 ;
24220 PyObject *swig_obj[1] ;
24221
24222 if (!args) SWIG_fail;
24223 swig_obj[0] = args;
24224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24225 if (!SWIG_IsOK(res1)) {
24226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24227 }
24228 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24229 {
24230 PyThreadState* __tstate = wxPyBeginAllowThreads();
24231 result = (bool)((wxMouseEvent const *)arg1)->Entering();
24232 wxPyEndAllowThreads(__tstate);
24233 if (PyErr_Occurred()) SWIG_fail;
24234 }
24235 {
24236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24237 }
24238 return resultobj;
24239 fail:
24240 return NULL;
24241 }
24242
24243
24244 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24245 PyObject *resultobj = 0;
24246 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24247 bool result;
24248 void *argp1 = 0 ;
24249 int res1 = 0 ;
24250 PyObject *swig_obj[1] ;
24251
24252 if (!args) SWIG_fail;
24253 swig_obj[0] = args;
24254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24255 if (!SWIG_IsOK(res1)) {
24256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24257 }
24258 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24259 {
24260 PyThreadState* __tstate = wxPyBeginAllowThreads();
24261 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
24262 wxPyEndAllowThreads(__tstate);
24263 if (PyErr_Occurred()) SWIG_fail;
24264 }
24265 {
24266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24267 }
24268 return resultobj;
24269 fail:
24270 return NULL;
24271 }
24272
24273
24274 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24275 PyObject *resultobj = 0;
24276 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24277 wxPoint result;
24278 void *argp1 = 0 ;
24279 int res1 = 0 ;
24280 PyObject *swig_obj[1] ;
24281
24282 if (!args) SWIG_fail;
24283 swig_obj[0] = args;
24284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24285 if (!SWIG_IsOK(res1)) {
24286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24287 }
24288 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24289 {
24290 PyThreadState* __tstate = wxPyBeginAllowThreads();
24291 result = (arg1)->GetPosition();
24292 wxPyEndAllowThreads(__tstate);
24293 if (PyErr_Occurred()) SWIG_fail;
24294 }
24295 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24296 return resultobj;
24297 fail:
24298 return NULL;
24299 }
24300
24301
24302 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24303 PyObject *resultobj = 0;
24304 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24305 long *arg2 = (long *) 0 ;
24306 long *arg3 = (long *) 0 ;
24307 void *argp1 = 0 ;
24308 int res1 = 0 ;
24309 long temp2 ;
24310 int res2 = SWIG_TMPOBJ ;
24311 long temp3 ;
24312 int res3 = SWIG_TMPOBJ ;
24313 PyObject *swig_obj[1] ;
24314
24315 arg2 = &temp2;
24316 arg3 = &temp3;
24317 if (!args) SWIG_fail;
24318 swig_obj[0] = args;
24319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24320 if (!SWIG_IsOK(res1)) {
24321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24322 }
24323 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24324 {
24325 PyThreadState* __tstate = wxPyBeginAllowThreads();
24326 (arg1)->GetPosition(arg2,arg3);
24327 wxPyEndAllowThreads(__tstate);
24328 if (PyErr_Occurred()) SWIG_fail;
24329 }
24330 resultobj = SWIG_Py_Void();
24331 if (SWIG_IsTmpObj(res2)) {
24332 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
24333 } else {
24334 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
24335 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
24336 }
24337 if (SWIG_IsTmpObj(res3)) {
24338 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
24339 } else {
24340 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
24341 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
24342 }
24343 return resultobj;
24344 fail:
24345 return NULL;
24346 }
24347
24348
24349 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24350 PyObject *resultobj = 0;
24351 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24352 wxDC *arg2 = 0 ;
24353 wxPoint result;
24354 void *argp1 = 0 ;
24355 int res1 = 0 ;
24356 void *argp2 = 0 ;
24357 int res2 = 0 ;
24358 PyObject * obj0 = 0 ;
24359 PyObject * obj1 = 0 ;
24360 char * kwnames[] = {
24361 (char *) "self",(char *) "dc", NULL
24362 };
24363
24364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
24365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24366 if (!SWIG_IsOK(res1)) {
24367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24368 }
24369 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24370 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
24371 if (!SWIG_IsOK(res2)) {
24372 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
24373 }
24374 if (!argp2) {
24375 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
24376 }
24377 arg2 = reinterpret_cast< wxDC * >(argp2);
24378 {
24379 PyThreadState* __tstate = wxPyBeginAllowThreads();
24380 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
24381 wxPyEndAllowThreads(__tstate);
24382 if (PyErr_Occurred()) SWIG_fail;
24383 }
24384 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24385 return resultobj;
24386 fail:
24387 return NULL;
24388 }
24389
24390
24391 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24392 PyObject *resultobj = 0;
24393 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24394 int result;
24395 void *argp1 = 0 ;
24396 int res1 = 0 ;
24397 PyObject *swig_obj[1] ;
24398
24399 if (!args) SWIG_fail;
24400 swig_obj[0] = args;
24401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24402 if (!SWIG_IsOK(res1)) {
24403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24404 }
24405 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24406 {
24407 PyThreadState* __tstate = wxPyBeginAllowThreads();
24408 result = (int)((wxMouseEvent const *)arg1)->GetX();
24409 wxPyEndAllowThreads(__tstate);
24410 if (PyErr_Occurred()) SWIG_fail;
24411 }
24412 resultobj = SWIG_From_int(static_cast< int >(result));
24413 return resultobj;
24414 fail:
24415 return NULL;
24416 }
24417
24418
24419 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24420 PyObject *resultobj = 0;
24421 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24422 int result;
24423 void *argp1 = 0 ;
24424 int res1 = 0 ;
24425 PyObject *swig_obj[1] ;
24426
24427 if (!args) SWIG_fail;
24428 swig_obj[0] = args;
24429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24430 if (!SWIG_IsOK(res1)) {
24431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24432 }
24433 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24434 {
24435 PyThreadState* __tstate = wxPyBeginAllowThreads();
24436 result = (int)((wxMouseEvent const *)arg1)->GetY();
24437 wxPyEndAllowThreads(__tstate);
24438 if (PyErr_Occurred()) SWIG_fail;
24439 }
24440 resultobj = SWIG_From_int(static_cast< int >(result));
24441 return resultobj;
24442 fail:
24443 return NULL;
24444 }
24445
24446
24447 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24448 PyObject *resultobj = 0;
24449 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24450 int result;
24451 void *argp1 = 0 ;
24452 int res1 = 0 ;
24453 PyObject *swig_obj[1] ;
24454
24455 if (!args) SWIG_fail;
24456 swig_obj[0] = args;
24457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24458 if (!SWIG_IsOK(res1)) {
24459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24460 }
24461 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24462 {
24463 PyThreadState* __tstate = wxPyBeginAllowThreads();
24464 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
24465 wxPyEndAllowThreads(__tstate);
24466 if (PyErr_Occurred()) SWIG_fail;
24467 }
24468 resultobj = SWIG_From_int(static_cast< int >(result));
24469 return resultobj;
24470 fail:
24471 return NULL;
24472 }
24473
24474
24475 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24476 PyObject *resultobj = 0;
24477 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24478 int result;
24479 void *argp1 = 0 ;
24480 int res1 = 0 ;
24481 PyObject *swig_obj[1] ;
24482
24483 if (!args) SWIG_fail;
24484 swig_obj[0] = args;
24485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24486 if (!SWIG_IsOK(res1)) {
24487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24488 }
24489 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24490 {
24491 PyThreadState* __tstate = wxPyBeginAllowThreads();
24492 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
24493 wxPyEndAllowThreads(__tstate);
24494 if (PyErr_Occurred()) SWIG_fail;
24495 }
24496 resultobj = SWIG_From_int(static_cast< int >(result));
24497 return resultobj;
24498 fail:
24499 return NULL;
24500 }
24501
24502
24503 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelAxis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24504 PyObject *resultobj = 0;
24505 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24506 int result;
24507 void *argp1 = 0 ;
24508 int res1 = 0 ;
24509 PyObject *swig_obj[1] ;
24510
24511 if (!args) SWIG_fail;
24512 swig_obj[0] = args;
24513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24514 if (!SWIG_IsOK(res1)) {
24515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelAxis" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24516 }
24517 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24518 {
24519 PyThreadState* __tstate = wxPyBeginAllowThreads();
24520 result = (int)((wxMouseEvent const *)arg1)->GetWheelAxis();
24521 wxPyEndAllowThreads(__tstate);
24522 if (PyErr_Occurred()) SWIG_fail;
24523 }
24524 resultobj = SWIG_From_int(static_cast< int >(result));
24525 return resultobj;
24526 fail:
24527 return NULL;
24528 }
24529
24530
24531 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24532 PyObject *resultobj = 0;
24533 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24534 int result;
24535 void *argp1 = 0 ;
24536 int res1 = 0 ;
24537 PyObject *swig_obj[1] ;
24538
24539 if (!args) SWIG_fail;
24540 swig_obj[0] = args;
24541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24542 if (!SWIG_IsOK(res1)) {
24543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24544 }
24545 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24546 {
24547 PyThreadState* __tstate = wxPyBeginAllowThreads();
24548 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
24549 wxPyEndAllowThreads(__tstate);
24550 if (PyErr_Occurred()) SWIG_fail;
24551 }
24552 resultobj = SWIG_From_int(static_cast< int >(result));
24553 return resultobj;
24554 fail:
24555 return NULL;
24556 }
24557
24558
24559 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24560 PyObject *resultobj = 0;
24561 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24562 bool result;
24563 void *argp1 = 0 ;
24564 int res1 = 0 ;
24565 PyObject *swig_obj[1] ;
24566
24567 if (!args) SWIG_fail;
24568 swig_obj[0] = args;
24569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24570 if (!SWIG_IsOK(res1)) {
24571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24572 }
24573 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24574 {
24575 PyThreadState* __tstate = wxPyBeginAllowThreads();
24576 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
24577 wxPyEndAllowThreads(__tstate);
24578 if (PyErr_Occurred()) SWIG_fail;
24579 }
24580 {
24581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24582 }
24583 return resultobj;
24584 fail:
24585 return NULL;
24586 }
24587
24588
24589 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24590 PyObject *resultobj = 0;
24591 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24592 int arg2 ;
24593 void *argp1 = 0 ;
24594 int res1 = 0 ;
24595 int val2 ;
24596 int ecode2 = 0 ;
24597 PyObject *swig_obj[2] ;
24598
24599 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
24600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24601 if (!SWIG_IsOK(res1)) {
24602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24603 }
24604 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24605 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24606 if (!SWIG_IsOK(ecode2)) {
24607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
24608 }
24609 arg2 = static_cast< int >(val2);
24610 if (arg1) (arg1)->m_x = arg2;
24611
24612 resultobj = SWIG_Py_Void();
24613 return resultobj;
24614 fail:
24615 return NULL;
24616 }
24617
24618
24619 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24620 PyObject *resultobj = 0;
24621 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24622 int result;
24623 void *argp1 = 0 ;
24624 int res1 = 0 ;
24625 PyObject *swig_obj[1] ;
24626
24627 if (!args) SWIG_fail;
24628 swig_obj[0] = args;
24629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24630 if (!SWIG_IsOK(res1)) {
24631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24632 }
24633 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24634 result = (int) ((arg1)->m_x);
24635 resultobj = SWIG_From_int(static_cast< int >(result));
24636 return resultobj;
24637 fail:
24638 return NULL;
24639 }
24640
24641
24642 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24643 PyObject *resultobj = 0;
24644 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24645 int arg2 ;
24646 void *argp1 = 0 ;
24647 int res1 = 0 ;
24648 int val2 ;
24649 int ecode2 = 0 ;
24650 PyObject *swig_obj[2] ;
24651
24652 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
24653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24654 if (!SWIG_IsOK(res1)) {
24655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24656 }
24657 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24658 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24659 if (!SWIG_IsOK(ecode2)) {
24660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
24661 }
24662 arg2 = static_cast< int >(val2);
24663 if (arg1) (arg1)->m_y = arg2;
24664
24665 resultobj = SWIG_Py_Void();
24666 return resultobj;
24667 fail:
24668 return NULL;
24669 }
24670
24671
24672 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24673 PyObject *resultobj = 0;
24674 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24675 int result;
24676 void *argp1 = 0 ;
24677 int res1 = 0 ;
24678 PyObject *swig_obj[1] ;
24679
24680 if (!args) SWIG_fail;
24681 swig_obj[0] = args;
24682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24683 if (!SWIG_IsOK(res1)) {
24684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24685 }
24686 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24687 result = (int) ((arg1)->m_y);
24688 resultobj = SWIG_From_int(static_cast< int >(result));
24689 return resultobj;
24690 fail:
24691 return NULL;
24692 }
24693
24694
24695 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24696 PyObject *resultobj = 0;
24697 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24698 bool arg2 ;
24699 void *argp1 = 0 ;
24700 int res1 = 0 ;
24701 bool val2 ;
24702 int ecode2 = 0 ;
24703 PyObject *swig_obj[2] ;
24704
24705 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
24706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24707 if (!SWIG_IsOK(res1)) {
24708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24709 }
24710 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24711 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24712 if (!SWIG_IsOK(ecode2)) {
24713 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
24714 }
24715 arg2 = static_cast< bool >(val2);
24716 if (arg1) (arg1)->m_leftDown = arg2;
24717
24718 resultobj = SWIG_Py_Void();
24719 return resultobj;
24720 fail:
24721 return NULL;
24722 }
24723
24724
24725 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24726 PyObject *resultobj = 0;
24727 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24728 bool result;
24729 void *argp1 = 0 ;
24730 int res1 = 0 ;
24731 PyObject *swig_obj[1] ;
24732
24733 if (!args) SWIG_fail;
24734 swig_obj[0] = args;
24735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24736 if (!SWIG_IsOK(res1)) {
24737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24738 }
24739 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24740 result = (bool) ((arg1)->m_leftDown);
24741 {
24742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24743 }
24744 return resultobj;
24745 fail:
24746 return NULL;
24747 }
24748
24749
24750 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24751 PyObject *resultobj = 0;
24752 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24753 bool arg2 ;
24754 void *argp1 = 0 ;
24755 int res1 = 0 ;
24756 bool val2 ;
24757 int ecode2 = 0 ;
24758 PyObject *swig_obj[2] ;
24759
24760 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
24761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24762 if (!SWIG_IsOK(res1)) {
24763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24764 }
24765 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24766 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24767 if (!SWIG_IsOK(ecode2)) {
24768 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
24769 }
24770 arg2 = static_cast< bool >(val2);
24771 if (arg1) (arg1)->m_middleDown = arg2;
24772
24773 resultobj = SWIG_Py_Void();
24774 return resultobj;
24775 fail:
24776 return NULL;
24777 }
24778
24779
24780 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24781 PyObject *resultobj = 0;
24782 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24783 bool result;
24784 void *argp1 = 0 ;
24785 int res1 = 0 ;
24786 PyObject *swig_obj[1] ;
24787
24788 if (!args) SWIG_fail;
24789 swig_obj[0] = args;
24790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24791 if (!SWIG_IsOK(res1)) {
24792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24793 }
24794 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24795 result = (bool) ((arg1)->m_middleDown);
24796 {
24797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24798 }
24799 return resultobj;
24800 fail:
24801 return NULL;
24802 }
24803
24804
24805 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24806 PyObject *resultobj = 0;
24807 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24808 bool arg2 ;
24809 void *argp1 = 0 ;
24810 int res1 = 0 ;
24811 bool val2 ;
24812 int ecode2 = 0 ;
24813 PyObject *swig_obj[2] ;
24814
24815 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
24816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24817 if (!SWIG_IsOK(res1)) {
24818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24819 }
24820 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24821 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24822 if (!SWIG_IsOK(ecode2)) {
24823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
24824 }
24825 arg2 = static_cast< bool >(val2);
24826 if (arg1) (arg1)->m_rightDown = arg2;
24827
24828 resultobj = SWIG_Py_Void();
24829 return resultobj;
24830 fail:
24831 return NULL;
24832 }
24833
24834
24835 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24836 PyObject *resultobj = 0;
24837 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24838 bool result;
24839 void *argp1 = 0 ;
24840 int res1 = 0 ;
24841 PyObject *swig_obj[1] ;
24842
24843 if (!args) SWIG_fail;
24844 swig_obj[0] = args;
24845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24846 if (!SWIG_IsOK(res1)) {
24847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24848 }
24849 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24850 result = (bool) ((arg1)->m_rightDown);
24851 {
24852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24853 }
24854 return resultobj;
24855 fail:
24856 return NULL;
24857 }
24858
24859
24860 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24861 PyObject *resultobj = 0;
24862 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24863 bool arg2 ;
24864 void *argp1 = 0 ;
24865 int res1 = 0 ;
24866 bool val2 ;
24867 int ecode2 = 0 ;
24868 PyObject *swig_obj[2] ;
24869
24870 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
24871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24872 if (!SWIG_IsOK(res1)) {
24873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24874 }
24875 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24876 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24877 if (!SWIG_IsOK(ecode2)) {
24878 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
24879 }
24880 arg2 = static_cast< bool >(val2);
24881 if (arg1) (arg1)->m_controlDown = arg2;
24882
24883 resultobj = SWIG_Py_Void();
24884 return resultobj;
24885 fail:
24886 return NULL;
24887 }
24888
24889
24890 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24891 PyObject *resultobj = 0;
24892 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24893 bool result;
24894 void *argp1 = 0 ;
24895 int res1 = 0 ;
24896 PyObject *swig_obj[1] ;
24897
24898 if (!args) SWIG_fail;
24899 swig_obj[0] = args;
24900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24901 if (!SWIG_IsOK(res1)) {
24902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24903 }
24904 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24905 result = (bool) ((arg1)->m_controlDown);
24906 {
24907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24908 }
24909 return resultobj;
24910 fail:
24911 return NULL;
24912 }
24913
24914
24915 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24916 PyObject *resultobj = 0;
24917 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24918 bool arg2 ;
24919 void *argp1 = 0 ;
24920 int res1 = 0 ;
24921 bool val2 ;
24922 int ecode2 = 0 ;
24923 PyObject *swig_obj[2] ;
24924
24925 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
24926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24927 if (!SWIG_IsOK(res1)) {
24928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24929 }
24930 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24931 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24932 if (!SWIG_IsOK(ecode2)) {
24933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
24934 }
24935 arg2 = static_cast< bool >(val2);
24936 if (arg1) (arg1)->m_shiftDown = arg2;
24937
24938 resultobj = SWIG_Py_Void();
24939 return resultobj;
24940 fail:
24941 return NULL;
24942 }
24943
24944
24945 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24946 PyObject *resultobj = 0;
24947 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24948 bool result;
24949 void *argp1 = 0 ;
24950 int res1 = 0 ;
24951 PyObject *swig_obj[1] ;
24952
24953 if (!args) SWIG_fail;
24954 swig_obj[0] = args;
24955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24956 if (!SWIG_IsOK(res1)) {
24957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24958 }
24959 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24960 result = (bool) ((arg1)->m_shiftDown);
24961 {
24962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24963 }
24964 return resultobj;
24965 fail:
24966 return NULL;
24967 }
24968
24969
24970 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24971 PyObject *resultobj = 0;
24972 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24973 bool arg2 ;
24974 void *argp1 = 0 ;
24975 int res1 = 0 ;
24976 bool val2 ;
24977 int ecode2 = 0 ;
24978 PyObject *swig_obj[2] ;
24979
24980 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
24981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24982 if (!SWIG_IsOK(res1)) {
24983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24984 }
24985 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24986 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24987 if (!SWIG_IsOK(ecode2)) {
24988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
24989 }
24990 arg2 = static_cast< bool >(val2);
24991 if (arg1) (arg1)->m_altDown = arg2;
24992
24993 resultobj = SWIG_Py_Void();
24994 return resultobj;
24995 fail:
24996 return NULL;
24997 }
24998
24999
25000 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25001 PyObject *resultobj = 0;
25002 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25003 bool result;
25004 void *argp1 = 0 ;
25005 int res1 = 0 ;
25006 PyObject *swig_obj[1] ;
25007
25008 if (!args) SWIG_fail;
25009 swig_obj[0] = args;
25010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
25011 if (!SWIG_IsOK(res1)) {
25012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25013 }
25014 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25015 result = (bool) ((arg1)->m_altDown);
25016 {
25017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25018 }
25019 return resultobj;
25020 fail:
25021 return NULL;
25022 }
25023
25024
25025 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25026 PyObject *resultobj = 0;
25027 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25028 bool arg2 ;
25029 void *argp1 = 0 ;
25030 int res1 = 0 ;
25031 bool val2 ;
25032 int ecode2 = 0 ;
25033 PyObject *swig_obj[2] ;
25034
25035 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
25036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
25037 if (!SWIG_IsOK(res1)) {
25038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25039 }
25040 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25041 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25042 if (!SWIG_IsOK(ecode2)) {
25043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
25044 }
25045 arg2 = static_cast< bool >(val2);
25046 if (arg1) (arg1)->m_metaDown = arg2;
25047
25048 resultobj = SWIG_Py_Void();
25049 return resultobj;
25050 fail:
25051 return NULL;
25052 }
25053
25054
25055 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25056 PyObject *resultobj = 0;
25057 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25058 bool result;
25059 void *argp1 = 0 ;
25060 int res1 = 0 ;
25061 PyObject *swig_obj[1] ;
25062
25063 if (!args) SWIG_fail;
25064 swig_obj[0] = args;
25065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
25066 if (!SWIG_IsOK(res1)) {
25067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25068 }
25069 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25070 result = (bool) ((arg1)->m_metaDown);
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_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25081 PyObject *resultobj = 0;
25082 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25083 int arg2 ;
25084 void *argp1 = 0 ;
25085 int res1 = 0 ;
25086 int val2 ;
25087 int ecode2 = 0 ;
25088 PyObject *swig_obj[2] ;
25089
25090 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
25091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
25092 if (!SWIG_IsOK(res1)) {
25093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25094 }
25095 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25096 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25097 if (!SWIG_IsOK(ecode2)) {
25098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
25099 }
25100 arg2 = static_cast< int >(val2);
25101 if (arg1) (arg1)->m_wheelRotation = arg2;
25102
25103 resultobj = SWIG_Py_Void();
25104 return resultobj;
25105 fail:
25106 return NULL;
25107 }
25108
25109
25110 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25111 PyObject *resultobj = 0;
25112 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25113 int 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_wxMouseEvent, 0 | 0 );
25121 if (!SWIG_IsOK(res1)) {
25122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25123 }
25124 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25125 result = (int) ((arg1)->m_wheelRotation);
25126 resultobj = SWIG_From_int(static_cast< int >(result));
25127 return resultobj;
25128 fail:
25129 return NULL;
25130 }
25131
25132
25133 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25134 PyObject *resultobj = 0;
25135 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25136 int arg2 ;
25137 void *argp1 = 0 ;
25138 int res1 = 0 ;
25139 int val2 ;
25140 int ecode2 = 0 ;
25141 PyObject *swig_obj[2] ;
25142
25143 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
25144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
25145 if (!SWIG_IsOK(res1)) {
25146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25147 }
25148 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25149 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25150 if (!SWIG_IsOK(ecode2)) {
25151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
25152 }
25153 arg2 = static_cast< int >(val2);
25154 if (arg1) (arg1)->m_wheelDelta = arg2;
25155
25156 resultobj = SWIG_Py_Void();
25157 return resultobj;
25158 fail:
25159 return NULL;
25160 }
25161
25162
25163 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25164 PyObject *resultobj = 0;
25165 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25166 int result;
25167 void *argp1 = 0 ;
25168 int res1 = 0 ;
25169 PyObject *swig_obj[1] ;
25170
25171 if (!args) SWIG_fail;
25172 swig_obj[0] = args;
25173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
25174 if (!SWIG_IsOK(res1)) {
25175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25176 }
25177 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25178 result = (int) ((arg1)->m_wheelDelta);
25179 resultobj = SWIG_From_int(static_cast< int >(result));
25180 return resultobj;
25181 fail:
25182 return NULL;
25183 }
25184
25185
25186 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25187 PyObject *resultobj = 0;
25188 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25189 int arg2 ;
25190 void *argp1 = 0 ;
25191 int res1 = 0 ;
25192 int val2 ;
25193 int ecode2 = 0 ;
25194 PyObject *swig_obj[2] ;
25195
25196 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
25197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
25198 if (!SWIG_IsOK(res1)) {
25199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25200 }
25201 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25202 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25203 if (!SWIG_IsOK(ecode2)) {
25204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
25205 }
25206 arg2 = static_cast< int >(val2);
25207 if (arg1) (arg1)->m_linesPerAction = arg2;
25208
25209 resultobj = SWIG_Py_Void();
25210 return resultobj;
25211 fail:
25212 return NULL;
25213 }
25214
25215
25216 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25217 PyObject *resultobj = 0;
25218 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25219 int result;
25220 void *argp1 = 0 ;
25221 int res1 = 0 ;
25222 PyObject *swig_obj[1] ;
25223
25224 if (!args) SWIG_fail;
25225 swig_obj[0] = args;
25226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
25227 if (!SWIG_IsOK(res1)) {
25228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25229 }
25230 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25231 result = (int) ((arg1)->m_linesPerAction);
25232 resultobj = SWIG_From_int(static_cast< int >(result));
25233 return resultobj;
25234 fail:
25235 return NULL;
25236 }
25237
25238
25239 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25240 PyObject *obj;
25241 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25242 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
25243 return SWIG_Py_Void();
25244 }
25245
25246 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25247 return SWIG_Python_InitShadowInstance(args);
25248 }
25249
25250 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25251 PyObject *resultobj = 0;
25252 int arg1 = (int) 0 ;
25253 int arg2 = (int) 0 ;
25254 wxSetCursorEvent *result = 0 ;
25255 int val1 ;
25256 int ecode1 = 0 ;
25257 int val2 ;
25258 int ecode2 = 0 ;
25259 PyObject * obj0 = 0 ;
25260 PyObject * obj1 = 0 ;
25261 char * kwnames[] = {
25262 (char *) "x",(char *) "y", NULL
25263 };
25264
25265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25266 if (obj0) {
25267 ecode1 = SWIG_AsVal_int(obj0, &val1);
25268 if (!SWIG_IsOK(ecode1)) {
25269 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
25270 }
25271 arg1 = static_cast< int >(val1);
25272 }
25273 if (obj1) {
25274 ecode2 = SWIG_AsVal_int(obj1, &val2);
25275 if (!SWIG_IsOK(ecode2)) {
25276 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
25277 }
25278 arg2 = static_cast< int >(val2);
25279 }
25280 {
25281 PyThreadState* __tstate = wxPyBeginAllowThreads();
25282 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
25283 wxPyEndAllowThreads(__tstate);
25284 if (PyErr_Occurred()) SWIG_fail;
25285 }
25286 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
25287 return resultobj;
25288 fail:
25289 return NULL;
25290 }
25291
25292
25293 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25294 PyObject *resultobj = 0;
25295 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
25296 int result;
25297 void *argp1 = 0 ;
25298 int res1 = 0 ;
25299 PyObject *swig_obj[1] ;
25300
25301 if (!args) SWIG_fail;
25302 swig_obj[0] = args;
25303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
25304 if (!SWIG_IsOK(res1)) {
25305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
25306 }
25307 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
25308 {
25309 PyThreadState* __tstate = wxPyBeginAllowThreads();
25310 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
25311 wxPyEndAllowThreads(__tstate);
25312 if (PyErr_Occurred()) SWIG_fail;
25313 }
25314 resultobj = SWIG_From_int(static_cast< int >(result));
25315 return resultobj;
25316 fail:
25317 return NULL;
25318 }
25319
25320
25321 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25322 PyObject *resultobj = 0;
25323 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
25324 int result;
25325 void *argp1 = 0 ;
25326 int res1 = 0 ;
25327 PyObject *swig_obj[1] ;
25328
25329 if (!args) SWIG_fail;
25330 swig_obj[0] = args;
25331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
25332 if (!SWIG_IsOK(res1)) {
25333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
25334 }
25335 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
25336 {
25337 PyThreadState* __tstate = wxPyBeginAllowThreads();
25338 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
25339 wxPyEndAllowThreads(__tstate);
25340 if (PyErr_Occurred()) SWIG_fail;
25341 }
25342 resultobj = SWIG_From_int(static_cast< int >(result));
25343 return resultobj;
25344 fail:
25345 return NULL;
25346 }
25347
25348
25349 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25350 PyObject *resultobj = 0;
25351 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
25352 wxCursor *arg2 = 0 ;
25353 void *argp1 = 0 ;
25354 int res1 = 0 ;
25355 void *argp2 = 0 ;
25356 int res2 = 0 ;
25357 PyObject * obj0 = 0 ;
25358 PyObject * obj1 = 0 ;
25359 char * kwnames[] = {
25360 (char *) "self",(char *) "cursor", NULL
25361 };
25362
25363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
25364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
25365 if (!SWIG_IsOK(res1)) {
25366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
25367 }
25368 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
25369 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
25370 if (!SWIG_IsOK(res2)) {
25371 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
25372 }
25373 if (!argp2) {
25374 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
25375 }
25376 arg2 = reinterpret_cast< wxCursor * >(argp2);
25377 {
25378 PyThreadState* __tstate = wxPyBeginAllowThreads();
25379 (arg1)->SetCursor((wxCursor const &)*arg2);
25380 wxPyEndAllowThreads(__tstate);
25381 if (PyErr_Occurred()) SWIG_fail;
25382 }
25383 resultobj = SWIG_Py_Void();
25384 return resultobj;
25385 fail:
25386 return NULL;
25387 }
25388
25389
25390 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25391 PyObject *resultobj = 0;
25392 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
25393 wxCursor *result = 0 ;
25394 void *argp1 = 0 ;
25395 int res1 = 0 ;
25396 PyObject *swig_obj[1] ;
25397
25398 if (!args) SWIG_fail;
25399 swig_obj[0] = args;
25400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
25401 if (!SWIG_IsOK(res1)) {
25402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
25403 }
25404 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
25405 {
25406 PyThreadState* __tstate = wxPyBeginAllowThreads();
25407 {
25408 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
25409 result = (wxCursor *) &_result_ref;
25410 }
25411 wxPyEndAllowThreads(__tstate);
25412 if (PyErr_Occurred()) SWIG_fail;
25413 }
25414 {
25415 wxCursor* resultptr = new wxCursor(*result);
25416 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
25417 }
25418 return resultobj;
25419 fail:
25420 return NULL;
25421 }
25422
25423
25424 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25425 PyObject *resultobj = 0;
25426 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
25427 bool result;
25428 void *argp1 = 0 ;
25429 int res1 = 0 ;
25430 PyObject *swig_obj[1] ;
25431
25432 if (!args) SWIG_fail;
25433 swig_obj[0] = args;
25434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
25435 if (!SWIG_IsOK(res1)) {
25436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
25437 }
25438 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
25439 {
25440 PyThreadState* __tstate = wxPyBeginAllowThreads();
25441 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
25442 wxPyEndAllowThreads(__tstate);
25443 if (PyErr_Occurred()) SWIG_fail;
25444 }
25445 {
25446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25447 }
25448 return resultobj;
25449 fail:
25450 return NULL;
25451 }
25452
25453
25454 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25455 PyObject *obj;
25456 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25457 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
25458 return SWIG_Py_Void();
25459 }
25460
25461 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25462 return SWIG_Python_InitShadowInstance(args);
25463 }
25464
25465 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25466 PyObject *resultobj = 0;
25467 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
25468 wxKeyEvent *result = 0 ;
25469 int val1 ;
25470 int ecode1 = 0 ;
25471 PyObject * obj0 = 0 ;
25472 char * kwnames[] = {
25473 (char *) "eventType", NULL
25474 };
25475
25476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
25477 if (obj0) {
25478 ecode1 = SWIG_AsVal_int(obj0, &val1);
25479 if (!SWIG_IsOK(ecode1)) {
25480 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
25481 }
25482 arg1 = static_cast< wxEventType >(val1);
25483 }
25484 {
25485 PyThreadState* __tstate = wxPyBeginAllowThreads();
25486 result = (wxKeyEvent *)new wxKeyEvent(arg1);
25487 wxPyEndAllowThreads(__tstate);
25488 if (PyErr_Occurred()) SWIG_fail;
25489 }
25490 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
25491 return resultobj;
25492 fail:
25493 return NULL;
25494 }
25495
25496
25497 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25498 PyObject *resultobj = 0;
25499 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25500 int result;
25501 void *argp1 = 0 ;
25502 int res1 = 0 ;
25503 PyObject *swig_obj[1] ;
25504
25505 if (!args) SWIG_fail;
25506 swig_obj[0] = args;
25507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25508 if (!SWIG_IsOK(res1)) {
25509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25510 }
25511 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25512 {
25513 PyThreadState* __tstate = wxPyBeginAllowThreads();
25514 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
25515 wxPyEndAllowThreads(__tstate);
25516 if (PyErr_Occurred()) SWIG_fail;
25517 }
25518 resultobj = SWIG_From_int(static_cast< int >(result));
25519 return resultobj;
25520 fail:
25521 return NULL;
25522 }
25523
25524
25525 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25526 PyObject *resultobj = 0;
25527 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25528 bool result;
25529 void *argp1 = 0 ;
25530 int res1 = 0 ;
25531 PyObject *swig_obj[1] ;
25532
25533 if (!args) SWIG_fail;
25534 swig_obj[0] = args;
25535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25536 if (!SWIG_IsOK(res1)) {
25537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25538 }
25539 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25540 {
25541 PyThreadState* __tstate = wxPyBeginAllowThreads();
25542 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
25543 wxPyEndAllowThreads(__tstate);
25544 if (PyErr_Occurred()) SWIG_fail;
25545 }
25546 {
25547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25548 }
25549 return resultobj;
25550 fail:
25551 return NULL;
25552 }
25553
25554
25555 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25556 PyObject *resultobj = 0;
25557 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25558 bool result;
25559 void *argp1 = 0 ;
25560 int res1 = 0 ;
25561 PyObject *swig_obj[1] ;
25562
25563 if (!args) SWIG_fail;
25564 swig_obj[0] = args;
25565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25566 if (!SWIG_IsOK(res1)) {
25567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25568 }
25569 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25570 {
25571 PyThreadState* __tstate = wxPyBeginAllowThreads();
25572 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
25573 wxPyEndAllowThreads(__tstate);
25574 if (PyErr_Occurred()) SWIG_fail;
25575 }
25576 {
25577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25578 }
25579 return resultobj;
25580 fail:
25581 return NULL;
25582 }
25583
25584
25585 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25586 PyObject *resultobj = 0;
25587 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25588 bool result;
25589 void *argp1 = 0 ;
25590 int res1 = 0 ;
25591 PyObject *swig_obj[1] ;
25592
25593 if (!args) SWIG_fail;
25594 swig_obj[0] = args;
25595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25596 if (!SWIG_IsOK(res1)) {
25597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25598 }
25599 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25600 {
25601 PyThreadState* __tstate = wxPyBeginAllowThreads();
25602 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
25603 wxPyEndAllowThreads(__tstate);
25604 if (PyErr_Occurred()) SWIG_fail;
25605 }
25606 {
25607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25608 }
25609 return resultobj;
25610 fail:
25611 return NULL;
25612 }
25613
25614
25615 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25616 PyObject *resultobj = 0;
25617 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25618 bool result;
25619 void *argp1 = 0 ;
25620 int res1 = 0 ;
25621 PyObject *swig_obj[1] ;
25622
25623 if (!args) SWIG_fail;
25624 swig_obj[0] = args;
25625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25626 if (!SWIG_IsOK(res1)) {
25627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25628 }
25629 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25630 {
25631 PyThreadState* __tstate = wxPyBeginAllowThreads();
25632 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
25633 wxPyEndAllowThreads(__tstate);
25634 if (PyErr_Occurred()) SWIG_fail;
25635 }
25636 {
25637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25638 }
25639 return resultobj;
25640 fail:
25641 return NULL;
25642 }
25643
25644
25645 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25646 PyObject *resultobj = 0;
25647 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25648 bool result;
25649 void *argp1 = 0 ;
25650 int res1 = 0 ;
25651 PyObject *swig_obj[1] ;
25652
25653 if (!args) SWIG_fail;
25654 swig_obj[0] = args;
25655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25656 if (!SWIG_IsOK(res1)) {
25657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25658 }
25659 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25660 {
25661 PyThreadState* __tstate = wxPyBeginAllowThreads();
25662 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
25663 wxPyEndAllowThreads(__tstate);
25664 if (PyErr_Occurred()) SWIG_fail;
25665 }
25666 {
25667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25668 }
25669 return resultobj;
25670 fail:
25671 return NULL;
25672 }
25673
25674
25675 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25676 PyObject *resultobj = 0;
25677 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25678 bool result;
25679 void *argp1 = 0 ;
25680 int res1 = 0 ;
25681 PyObject *swig_obj[1] ;
25682
25683 if (!args) SWIG_fail;
25684 swig_obj[0] = args;
25685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25686 if (!SWIG_IsOK(res1)) {
25687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25688 }
25689 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25690 {
25691 PyThreadState* __tstate = wxPyBeginAllowThreads();
25692 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
25693 wxPyEndAllowThreads(__tstate);
25694 if (PyErr_Occurred()) SWIG_fail;
25695 }
25696 {
25697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25698 }
25699 return resultobj;
25700 fail:
25701 return NULL;
25702 }
25703
25704
25705 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25706 PyObject *resultobj = 0;
25707 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25708 int result;
25709 void *argp1 = 0 ;
25710 int res1 = 0 ;
25711 PyObject *swig_obj[1] ;
25712
25713 if (!args) SWIG_fail;
25714 swig_obj[0] = args;
25715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25716 if (!SWIG_IsOK(res1)) {
25717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25718 }
25719 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25720 {
25721 PyThreadState* __tstate = wxPyBeginAllowThreads();
25722 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
25723 wxPyEndAllowThreads(__tstate);
25724 if (PyErr_Occurred()) SWIG_fail;
25725 }
25726 resultobj = SWIG_From_int(static_cast< int >(result));
25727 return resultobj;
25728 fail:
25729 return NULL;
25730 }
25731
25732
25733 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25734 PyObject *resultobj = 0;
25735 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25736 int result;
25737 void *argp1 = 0 ;
25738 int res1 = 0 ;
25739 PyObject *swig_obj[1] ;
25740
25741 if (!args) SWIG_fail;
25742 swig_obj[0] = args;
25743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25744 if (!SWIG_IsOK(res1)) {
25745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25746 }
25747 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25748 {
25749 PyThreadState* __tstate = wxPyBeginAllowThreads();
25750 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
25751 wxPyEndAllowThreads(__tstate);
25752 if (PyErr_Occurred()) SWIG_fail;
25753 }
25754 resultobj = SWIG_From_int(static_cast< int >(result));
25755 return resultobj;
25756 fail:
25757 return NULL;
25758 }
25759
25760
25761 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25762 PyObject *resultobj = 0;
25763 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25764 int arg2 ;
25765 void *argp1 = 0 ;
25766 int res1 = 0 ;
25767 int val2 ;
25768 int ecode2 = 0 ;
25769 PyObject * obj0 = 0 ;
25770 PyObject * obj1 = 0 ;
25771 char * kwnames[] = {
25772 (char *) "self",(char *) "uniChar", NULL
25773 };
25774
25775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
25776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25777 if (!SWIG_IsOK(res1)) {
25778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25779 }
25780 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25781 ecode2 = SWIG_AsVal_int(obj1, &val2);
25782 if (!SWIG_IsOK(ecode2)) {
25783 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
25784 }
25785 arg2 = static_cast< int >(val2);
25786 {
25787 PyThreadState* __tstate = wxPyBeginAllowThreads();
25788 wxKeyEvent_SetUnicodeKey(arg1,arg2);
25789 wxPyEndAllowThreads(__tstate);
25790 if (PyErr_Occurred()) SWIG_fail;
25791 }
25792 resultobj = SWIG_Py_Void();
25793 return resultobj;
25794 fail:
25795 return NULL;
25796 }
25797
25798
25799 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25800 PyObject *resultobj = 0;
25801 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25802 unsigned int result;
25803 void *argp1 = 0 ;
25804 int res1 = 0 ;
25805 PyObject *swig_obj[1] ;
25806
25807 if (!args) SWIG_fail;
25808 swig_obj[0] = args;
25809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25810 if (!SWIG_IsOK(res1)) {
25811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25812 }
25813 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25814 {
25815 PyThreadState* __tstate = wxPyBeginAllowThreads();
25816 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
25817 wxPyEndAllowThreads(__tstate);
25818 if (PyErr_Occurred()) SWIG_fail;
25819 }
25820 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25821 return resultobj;
25822 fail:
25823 return NULL;
25824 }
25825
25826
25827 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25828 PyObject *resultobj = 0;
25829 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25830 unsigned int result;
25831 void *argp1 = 0 ;
25832 int res1 = 0 ;
25833 PyObject *swig_obj[1] ;
25834
25835 if (!args) SWIG_fail;
25836 swig_obj[0] = args;
25837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25838 if (!SWIG_IsOK(res1)) {
25839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25840 }
25841 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25842 {
25843 PyThreadState* __tstate = wxPyBeginAllowThreads();
25844 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
25845 wxPyEndAllowThreads(__tstate);
25846 if (PyErr_Occurred()) SWIG_fail;
25847 }
25848 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25849 return resultobj;
25850 fail:
25851 return NULL;
25852 }
25853
25854
25855 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25856 PyObject *resultobj = 0;
25857 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25858 wxPoint result;
25859 void *argp1 = 0 ;
25860 int res1 = 0 ;
25861 PyObject *swig_obj[1] ;
25862
25863 if (!args) SWIG_fail;
25864 swig_obj[0] = args;
25865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25866 if (!SWIG_IsOK(res1)) {
25867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25868 }
25869 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25870 {
25871 PyThreadState* __tstate = wxPyBeginAllowThreads();
25872 result = (arg1)->GetPosition();
25873 wxPyEndAllowThreads(__tstate);
25874 if (PyErr_Occurred()) SWIG_fail;
25875 }
25876 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25877 return resultobj;
25878 fail:
25879 return NULL;
25880 }
25881
25882
25883 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25884 PyObject *resultobj = 0;
25885 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25886 long *arg2 = (long *) 0 ;
25887 long *arg3 = (long *) 0 ;
25888 void *argp1 = 0 ;
25889 int res1 = 0 ;
25890 long temp2 ;
25891 int res2 = SWIG_TMPOBJ ;
25892 long temp3 ;
25893 int res3 = SWIG_TMPOBJ ;
25894 PyObject *swig_obj[1] ;
25895
25896 arg2 = &temp2;
25897 arg3 = &temp3;
25898 if (!args) SWIG_fail;
25899 swig_obj[0] = args;
25900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25901 if (!SWIG_IsOK(res1)) {
25902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25903 }
25904 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25905 {
25906 PyThreadState* __tstate = wxPyBeginAllowThreads();
25907 (arg1)->GetPosition(arg2,arg3);
25908 wxPyEndAllowThreads(__tstate);
25909 if (PyErr_Occurred()) SWIG_fail;
25910 }
25911 resultobj = SWIG_Py_Void();
25912 if (SWIG_IsTmpObj(res2)) {
25913 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
25914 } else {
25915 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25916 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
25917 }
25918 if (SWIG_IsTmpObj(res3)) {
25919 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
25920 } else {
25921 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25922 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
25923 }
25924 return resultobj;
25925 fail:
25926 return NULL;
25927 }
25928
25929
25930 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25931 PyObject *resultobj = 0;
25932 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25933 int result;
25934 void *argp1 = 0 ;
25935 int res1 = 0 ;
25936 PyObject *swig_obj[1] ;
25937
25938 if (!args) SWIG_fail;
25939 swig_obj[0] = args;
25940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25941 if (!SWIG_IsOK(res1)) {
25942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25943 }
25944 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25945 {
25946 PyThreadState* __tstate = wxPyBeginAllowThreads();
25947 result = (int)((wxKeyEvent const *)arg1)->GetX();
25948 wxPyEndAllowThreads(__tstate);
25949 if (PyErr_Occurred()) SWIG_fail;
25950 }
25951 resultobj = SWIG_From_int(static_cast< int >(result));
25952 return resultobj;
25953 fail:
25954 return NULL;
25955 }
25956
25957
25958 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25959 PyObject *resultobj = 0;
25960 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25961 int result;
25962 void *argp1 = 0 ;
25963 int res1 = 0 ;
25964 PyObject *swig_obj[1] ;
25965
25966 if (!args) SWIG_fail;
25967 swig_obj[0] = args;
25968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25969 if (!SWIG_IsOK(res1)) {
25970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25971 }
25972 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25973 {
25974 PyThreadState* __tstate = wxPyBeginAllowThreads();
25975 result = (int)((wxKeyEvent const *)arg1)->GetY();
25976 wxPyEndAllowThreads(__tstate);
25977 if (PyErr_Occurred()) SWIG_fail;
25978 }
25979 resultobj = SWIG_From_int(static_cast< int >(result));
25980 return resultobj;
25981 fail:
25982 return NULL;
25983 }
25984
25985
25986 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25987 PyObject *resultobj = 0;
25988 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25989 int arg2 ;
25990 void *argp1 = 0 ;
25991 int res1 = 0 ;
25992 int val2 ;
25993 int ecode2 = 0 ;
25994 PyObject *swig_obj[2] ;
25995
25996 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
25997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25998 if (!SWIG_IsOK(res1)) {
25999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26000 }
26001 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26002 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
26003 if (!SWIG_IsOK(ecode2)) {
26004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
26005 }
26006 arg2 = static_cast< int >(val2);
26007 if (arg1) (arg1)->m_x = arg2;
26008
26009 resultobj = SWIG_Py_Void();
26010 return resultobj;
26011 fail:
26012 return NULL;
26013 }
26014
26015
26016 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26017 PyObject *resultobj = 0;
26018 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26019 int result;
26020 void *argp1 = 0 ;
26021 int res1 = 0 ;
26022 PyObject *swig_obj[1] ;
26023
26024 if (!args) SWIG_fail;
26025 swig_obj[0] = args;
26026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26027 if (!SWIG_IsOK(res1)) {
26028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26029 }
26030 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26031 result = (int) ((arg1)->m_x);
26032 resultobj = SWIG_From_int(static_cast< int >(result));
26033 return resultobj;
26034 fail:
26035 return NULL;
26036 }
26037
26038
26039 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26040 PyObject *resultobj = 0;
26041 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26042 int arg2 ;
26043 void *argp1 = 0 ;
26044 int res1 = 0 ;
26045 int val2 ;
26046 int ecode2 = 0 ;
26047 PyObject *swig_obj[2] ;
26048
26049 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
26050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26051 if (!SWIG_IsOK(res1)) {
26052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26053 }
26054 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26055 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
26056 if (!SWIG_IsOK(ecode2)) {
26057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
26058 }
26059 arg2 = static_cast< int >(val2);
26060 if (arg1) (arg1)->m_y = arg2;
26061
26062 resultobj = SWIG_Py_Void();
26063 return resultobj;
26064 fail:
26065 return NULL;
26066 }
26067
26068
26069 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26070 PyObject *resultobj = 0;
26071 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26072 int result;
26073 void *argp1 = 0 ;
26074 int res1 = 0 ;
26075 PyObject *swig_obj[1] ;
26076
26077 if (!args) SWIG_fail;
26078 swig_obj[0] = args;
26079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26080 if (!SWIG_IsOK(res1)) {
26081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26082 }
26083 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26084 result = (int) ((arg1)->m_y);
26085 resultobj = SWIG_From_int(static_cast< int >(result));
26086 return resultobj;
26087 fail:
26088 return NULL;
26089 }
26090
26091
26092 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26093 PyObject *resultobj = 0;
26094 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26095 long arg2 ;
26096 void *argp1 = 0 ;
26097 int res1 = 0 ;
26098 long val2 ;
26099 int ecode2 = 0 ;
26100 PyObject *swig_obj[2] ;
26101
26102 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
26103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26104 if (!SWIG_IsOK(res1)) {
26105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26106 }
26107 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26108 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
26109 if (!SWIG_IsOK(ecode2)) {
26110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
26111 }
26112 arg2 = static_cast< long >(val2);
26113 if (arg1) (arg1)->m_keyCode = arg2;
26114
26115 resultobj = SWIG_Py_Void();
26116 return resultobj;
26117 fail:
26118 return NULL;
26119 }
26120
26121
26122 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26123 PyObject *resultobj = 0;
26124 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26125 long result;
26126 void *argp1 = 0 ;
26127 int res1 = 0 ;
26128 PyObject *swig_obj[1] ;
26129
26130 if (!args) SWIG_fail;
26131 swig_obj[0] = args;
26132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26133 if (!SWIG_IsOK(res1)) {
26134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26135 }
26136 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26137 result = (long) ((arg1)->m_keyCode);
26138 resultobj = SWIG_From_long(static_cast< long >(result));
26139 return resultobj;
26140 fail:
26141 return NULL;
26142 }
26143
26144
26145 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26146 PyObject *resultobj = 0;
26147 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26148 bool arg2 ;
26149 void *argp1 = 0 ;
26150 int res1 = 0 ;
26151 bool val2 ;
26152 int ecode2 = 0 ;
26153 PyObject *swig_obj[2] ;
26154
26155 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
26156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26157 if (!SWIG_IsOK(res1)) {
26158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26159 }
26160 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26161 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
26162 if (!SWIG_IsOK(ecode2)) {
26163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
26164 }
26165 arg2 = static_cast< bool >(val2);
26166 if (arg1) (arg1)->m_controlDown = arg2;
26167
26168 resultobj = SWIG_Py_Void();
26169 return resultobj;
26170 fail:
26171 return NULL;
26172 }
26173
26174
26175 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26176 PyObject *resultobj = 0;
26177 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26178 bool result;
26179 void *argp1 = 0 ;
26180 int res1 = 0 ;
26181 PyObject *swig_obj[1] ;
26182
26183 if (!args) SWIG_fail;
26184 swig_obj[0] = args;
26185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26186 if (!SWIG_IsOK(res1)) {
26187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26188 }
26189 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26190 result = (bool) ((arg1)->m_controlDown);
26191 {
26192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26193 }
26194 return resultobj;
26195 fail:
26196 return NULL;
26197 }
26198
26199
26200 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26201 PyObject *resultobj = 0;
26202 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26203 bool arg2 ;
26204 void *argp1 = 0 ;
26205 int res1 = 0 ;
26206 bool val2 ;
26207 int ecode2 = 0 ;
26208 PyObject *swig_obj[2] ;
26209
26210 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
26211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26212 if (!SWIG_IsOK(res1)) {
26213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26214 }
26215 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26216 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
26217 if (!SWIG_IsOK(ecode2)) {
26218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
26219 }
26220 arg2 = static_cast< bool >(val2);
26221 if (arg1) (arg1)->m_shiftDown = arg2;
26222
26223 resultobj = SWIG_Py_Void();
26224 return resultobj;
26225 fail:
26226 return NULL;
26227 }
26228
26229
26230 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26231 PyObject *resultobj = 0;
26232 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26233 bool result;
26234 void *argp1 = 0 ;
26235 int res1 = 0 ;
26236 PyObject *swig_obj[1] ;
26237
26238 if (!args) SWIG_fail;
26239 swig_obj[0] = args;
26240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26241 if (!SWIG_IsOK(res1)) {
26242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26243 }
26244 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26245 result = (bool) ((arg1)->m_shiftDown);
26246 {
26247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26248 }
26249 return resultobj;
26250 fail:
26251 return NULL;
26252 }
26253
26254
26255 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26256 PyObject *resultobj = 0;
26257 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26258 bool arg2 ;
26259 void *argp1 = 0 ;
26260 int res1 = 0 ;
26261 bool val2 ;
26262 int ecode2 = 0 ;
26263 PyObject *swig_obj[2] ;
26264
26265 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
26266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26267 if (!SWIG_IsOK(res1)) {
26268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26269 }
26270 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26271 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
26272 if (!SWIG_IsOK(ecode2)) {
26273 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
26274 }
26275 arg2 = static_cast< bool >(val2);
26276 if (arg1) (arg1)->m_altDown = arg2;
26277
26278 resultobj = SWIG_Py_Void();
26279 return resultobj;
26280 fail:
26281 return NULL;
26282 }
26283
26284
26285 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26286 PyObject *resultobj = 0;
26287 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26288 bool result;
26289 void *argp1 = 0 ;
26290 int res1 = 0 ;
26291 PyObject *swig_obj[1] ;
26292
26293 if (!args) SWIG_fail;
26294 swig_obj[0] = args;
26295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26296 if (!SWIG_IsOK(res1)) {
26297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26298 }
26299 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26300 result = (bool) ((arg1)->m_altDown);
26301 {
26302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26303 }
26304 return resultobj;
26305 fail:
26306 return NULL;
26307 }
26308
26309
26310 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26311 PyObject *resultobj = 0;
26312 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26313 bool arg2 ;
26314 void *argp1 = 0 ;
26315 int res1 = 0 ;
26316 bool val2 ;
26317 int ecode2 = 0 ;
26318 PyObject *swig_obj[2] ;
26319
26320 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
26321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26322 if (!SWIG_IsOK(res1)) {
26323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26324 }
26325 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26326 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
26327 if (!SWIG_IsOK(ecode2)) {
26328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
26329 }
26330 arg2 = static_cast< bool >(val2);
26331 if (arg1) (arg1)->m_metaDown = arg2;
26332
26333 resultobj = SWIG_Py_Void();
26334 return resultobj;
26335 fail:
26336 return NULL;
26337 }
26338
26339
26340 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26341 PyObject *resultobj = 0;
26342 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26343 bool result;
26344 void *argp1 = 0 ;
26345 int res1 = 0 ;
26346 PyObject *swig_obj[1] ;
26347
26348 if (!args) SWIG_fail;
26349 swig_obj[0] = args;
26350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26351 if (!SWIG_IsOK(res1)) {
26352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26353 }
26354 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26355 result = (bool) ((arg1)->m_metaDown);
26356 {
26357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26358 }
26359 return resultobj;
26360 fail:
26361 return NULL;
26362 }
26363
26364
26365 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26366 PyObject *resultobj = 0;
26367 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26368 bool arg2 ;
26369 void *argp1 = 0 ;
26370 int res1 = 0 ;
26371 bool val2 ;
26372 int ecode2 = 0 ;
26373 PyObject *swig_obj[2] ;
26374
26375 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
26376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26377 if (!SWIG_IsOK(res1)) {
26378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26379 }
26380 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26381 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
26382 if (!SWIG_IsOK(ecode2)) {
26383 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
26384 }
26385 arg2 = static_cast< bool >(val2);
26386 if (arg1) (arg1)->m_scanCode = arg2;
26387
26388 resultobj = SWIG_Py_Void();
26389 return resultobj;
26390 fail:
26391 return NULL;
26392 }
26393
26394
26395 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26396 PyObject *resultobj = 0;
26397 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26398 bool result;
26399 void *argp1 = 0 ;
26400 int res1 = 0 ;
26401 PyObject *swig_obj[1] ;
26402
26403 if (!args) SWIG_fail;
26404 swig_obj[0] = args;
26405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26406 if (!SWIG_IsOK(res1)) {
26407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26408 }
26409 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26410 result = (bool) ((arg1)->m_scanCode);
26411 {
26412 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26413 }
26414 return resultobj;
26415 fail:
26416 return NULL;
26417 }
26418
26419
26420 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26421 PyObject *resultobj = 0;
26422 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26423 unsigned int arg2 ;
26424 void *argp1 = 0 ;
26425 int res1 = 0 ;
26426 unsigned int val2 ;
26427 int ecode2 = 0 ;
26428 PyObject *swig_obj[2] ;
26429
26430 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
26431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26432 if (!SWIG_IsOK(res1)) {
26433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26434 }
26435 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26436 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
26437 if (!SWIG_IsOK(ecode2)) {
26438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
26439 }
26440 arg2 = static_cast< unsigned int >(val2);
26441 if (arg1) (arg1)->m_rawCode = arg2;
26442
26443 resultobj = SWIG_Py_Void();
26444 return resultobj;
26445 fail:
26446 return NULL;
26447 }
26448
26449
26450 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26451 PyObject *resultobj = 0;
26452 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26453 unsigned int result;
26454 void *argp1 = 0 ;
26455 int res1 = 0 ;
26456 PyObject *swig_obj[1] ;
26457
26458 if (!args) SWIG_fail;
26459 swig_obj[0] = args;
26460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26461 if (!SWIG_IsOK(res1)) {
26462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26463 }
26464 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26465 result = (unsigned int) ((arg1)->m_rawCode);
26466 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
26467 return resultobj;
26468 fail:
26469 return NULL;
26470 }
26471
26472
26473 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26474 PyObject *resultobj = 0;
26475 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26476 unsigned int arg2 ;
26477 void *argp1 = 0 ;
26478 int res1 = 0 ;
26479 unsigned int val2 ;
26480 int ecode2 = 0 ;
26481 PyObject *swig_obj[2] ;
26482
26483 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
26484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26485 if (!SWIG_IsOK(res1)) {
26486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26487 }
26488 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26489 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
26490 if (!SWIG_IsOK(ecode2)) {
26491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
26492 }
26493 arg2 = static_cast< unsigned int >(val2);
26494 if (arg1) (arg1)->m_rawFlags = arg2;
26495
26496 resultobj = SWIG_Py_Void();
26497 return resultobj;
26498 fail:
26499 return NULL;
26500 }
26501
26502
26503 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26504 PyObject *resultobj = 0;
26505 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26506 unsigned int result;
26507 void *argp1 = 0 ;
26508 int res1 = 0 ;
26509 PyObject *swig_obj[1] ;
26510
26511 if (!args) SWIG_fail;
26512 swig_obj[0] = args;
26513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26514 if (!SWIG_IsOK(res1)) {
26515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26516 }
26517 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26518 result = (unsigned int) ((arg1)->m_rawFlags);
26519 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
26520 return resultobj;
26521 fail:
26522 return NULL;
26523 }
26524
26525
26526 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26527 PyObject *obj;
26528 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26529 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
26530 return SWIG_Py_Void();
26531 }
26532
26533 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26534 return SWIG_Python_InitShadowInstance(args);
26535 }
26536
26537 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26538 PyObject *resultobj = 0;
26539 wxSize const &arg1_defvalue = wxDefaultSize ;
26540 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
26541 int arg2 = (int) 0 ;
26542 wxSizeEvent *result = 0 ;
26543 wxSize temp1 ;
26544 int val2 ;
26545 int ecode2 = 0 ;
26546 PyObject * obj0 = 0 ;
26547 PyObject * obj1 = 0 ;
26548 char * kwnames[] = {
26549 (char *) "sz",(char *) "winid", NULL
26550 };
26551
26552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26553 if (obj0) {
26554 {
26555 arg1 = &temp1;
26556 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
26557 }
26558 }
26559 if (obj1) {
26560 ecode2 = SWIG_AsVal_int(obj1, &val2);
26561 if (!SWIG_IsOK(ecode2)) {
26562 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
26563 }
26564 arg2 = static_cast< int >(val2);
26565 }
26566 {
26567 PyThreadState* __tstate = wxPyBeginAllowThreads();
26568 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
26569 wxPyEndAllowThreads(__tstate);
26570 if (PyErr_Occurred()) SWIG_fail;
26571 }
26572 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
26573 return resultobj;
26574 fail:
26575 return NULL;
26576 }
26577
26578
26579 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26580 PyObject *resultobj = 0;
26581 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26582 wxSize result;
26583 void *argp1 = 0 ;
26584 int res1 = 0 ;
26585 PyObject *swig_obj[1] ;
26586
26587 if (!args) SWIG_fail;
26588 swig_obj[0] = args;
26589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26590 if (!SWIG_IsOK(res1)) {
26591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
26592 }
26593 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26594 {
26595 PyThreadState* __tstate = wxPyBeginAllowThreads();
26596 result = ((wxSizeEvent const *)arg1)->GetSize();
26597 wxPyEndAllowThreads(__tstate);
26598 if (PyErr_Occurred()) SWIG_fail;
26599 }
26600 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
26601 return resultobj;
26602 fail:
26603 return NULL;
26604 }
26605
26606
26607 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26608 PyObject *resultobj = 0;
26609 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26610 wxRect result;
26611 void *argp1 = 0 ;
26612 int res1 = 0 ;
26613 PyObject *swig_obj[1] ;
26614
26615 if (!args) SWIG_fail;
26616 swig_obj[0] = args;
26617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26618 if (!SWIG_IsOK(res1)) {
26619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
26620 }
26621 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26622 {
26623 PyThreadState* __tstate = wxPyBeginAllowThreads();
26624 result = ((wxSizeEvent const *)arg1)->GetRect();
26625 wxPyEndAllowThreads(__tstate);
26626 if (PyErr_Occurred()) SWIG_fail;
26627 }
26628 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26629 return resultobj;
26630 fail:
26631 return NULL;
26632 }
26633
26634
26635 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26636 PyObject *resultobj = 0;
26637 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26638 wxRect arg2 ;
26639 void *argp1 = 0 ;
26640 int res1 = 0 ;
26641 void *argp2 ;
26642 int res2 = 0 ;
26643 PyObject * obj0 = 0 ;
26644 PyObject * obj1 = 0 ;
26645 char * kwnames[] = {
26646 (char *) "self",(char *) "rect", NULL
26647 };
26648
26649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26651 if (!SWIG_IsOK(res1)) {
26652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26653 }
26654 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26655 {
26656 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
26657 if (!SWIG_IsOK(res2)) {
26658 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26659 }
26660 if (!argp2) {
26661 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26662 } else {
26663 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
26664 arg2 = *temp;
26665 if (SWIG_IsNewObj(res2)) delete temp;
26666 }
26667 }
26668 {
26669 PyThreadState* __tstate = wxPyBeginAllowThreads();
26670 (arg1)->SetRect(arg2);
26671 wxPyEndAllowThreads(__tstate);
26672 if (PyErr_Occurred()) SWIG_fail;
26673 }
26674 resultobj = SWIG_Py_Void();
26675 return resultobj;
26676 fail:
26677 return NULL;
26678 }
26679
26680
26681 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26682 PyObject *resultobj = 0;
26683 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26684 wxSize arg2 ;
26685 void *argp1 = 0 ;
26686 int res1 = 0 ;
26687 void *argp2 ;
26688 int res2 = 0 ;
26689 PyObject * obj0 = 0 ;
26690 PyObject * obj1 = 0 ;
26691 char * kwnames[] = {
26692 (char *) "self",(char *) "size", NULL
26693 };
26694
26695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
26696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26697 if (!SWIG_IsOK(res1)) {
26698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26699 }
26700 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26701 {
26702 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
26703 if (!SWIG_IsOK(res2)) {
26704 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26705 }
26706 if (!argp2) {
26707 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26708 } else {
26709 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
26710 arg2 = *temp;
26711 if (SWIG_IsNewObj(res2)) delete temp;
26712 }
26713 }
26714 {
26715 PyThreadState* __tstate = wxPyBeginAllowThreads();
26716 wxSizeEvent_SetSize(arg1,arg2);
26717 wxPyEndAllowThreads(__tstate);
26718 if (PyErr_Occurred()) SWIG_fail;
26719 }
26720 resultobj = SWIG_Py_Void();
26721 return resultobj;
26722 fail:
26723 return NULL;
26724 }
26725
26726
26727 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26728 PyObject *resultobj = 0;
26729 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26730 wxSize *arg2 = (wxSize *) 0 ;
26731 void *argp1 = 0 ;
26732 int res1 = 0 ;
26733 void *argp2 = 0 ;
26734 int res2 = 0 ;
26735 PyObject *swig_obj[2] ;
26736
26737 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
26738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26739 if (!SWIG_IsOK(res1)) {
26740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26741 }
26742 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26743 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
26744 if (!SWIG_IsOK(res2)) {
26745 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
26746 }
26747 arg2 = reinterpret_cast< wxSize * >(argp2);
26748 if (arg1) (arg1)->m_size = *arg2;
26749
26750 resultobj = SWIG_Py_Void();
26751 return resultobj;
26752 fail:
26753 return NULL;
26754 }
26755
26756
26757 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26758 PyObject *resultobj = 0;
26759 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26760 wxSize *result = 0 ;
26761 void *argp1 = 0 ;
26762 int res1 = 0 ;
26763 PyObject *swig_obj[1] ;
26764
26765 if (!args) SWIG_fail;
26766 swig_obj[0] = args;
26767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26768 if (!SWIG_IsOK(res1)) {
26769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26770 }
26771 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26772 result = (wxSize *)& ((arg1)->m_size);
26773 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
26774 return resultobj;
26775 fail:
26776 return NULL;
26777 }
26778
26779
26780 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26781 PyObject *resultobj = 0;
26782 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26783 wxRect *arg2 = (wxRect *) 0 ;
26784 void *argp1 = 0 ;
26785 int res1 = 0 ;
26786 void *argp2 = 0 ;
26787 int res2 = 0 ;
26788 PyObject *swig_obj[2] ;
26789
26790 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
26791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26792 if (!SWIG_IsOK(res1)) {
26793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26794 }
26795 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26796 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
26797 if (!SWIG_IsOK(res2)) {
26798 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
26799 }
26800 arg2 = reinterpret_cast< wxRect * >(argp2);
26801 if (arg1) (arg1)->m_rect = *arg2;
26802
26803 resultobj = SWIG_Py_Void();
26804 return resultobj;
26805 fail:
26806 return NULL;
26807 }
26808
26809
26810 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26811 PyObject *resultobj = 0;
26812 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26813 wxRect *result = 0 ;
26814 void *argp1 = 0 ;
26815 int res1 = 0 ;
26816 PyObject *swig_obj[1] ;
26817
26818 if (!args) SWIG_fail;
26819 swig_obj[0] = args;
26820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26821 if (!SWIG_IsOK(res1)) {
26822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26823 }
26824 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26825 result = (wxRect *)& ((arg1)->m_rect);
26826 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
26827 return resultobj;
26828 fail:
26829 return NULL;
26830 }
26831
26832
26833 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26834 PyObject *obj;
26835 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26836 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
26837 return SWIG_Py_Void();
26838 }
26839
26840 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26841 return SWIG_Python_InitShadowInstance(args);
26842 }
26843
26844 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26845 PyObject *resultobj = 0;
26846 wxPoint const &arg1_defvalue = wxDefaultPosition ;
26847 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
26848 int arg2 = (int) 0 ;
26849 wxMoveEvent *result = 0 ;
26850 wxPoint temp1 ;
26851 int val2 ;
26852 int ecode2 = 0 ;
26853 PyObject * obj0 = 0 ;
26854 PyObject * obj1 = 0 ;
26855 char * kwnames[] = {
26856 (char *) "pos",(char *) "winid", NULL
26857 };
26858
26859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26860 if (obj0) {
26861 {
26862 arg1 = &temp1;
26863 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
26864 }
26865 }
26866 if (obj1) {
26867 ecode2 = SWIG_AsVal_int(obj1, &val2);
26868 if (!SWIG_IsOK(ecode2)) {
26869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
26870 }
26871 arg2 = static_cast< int >(val2);
26872 }
26873 {
26874 PyThreadState* __tstate = wxPyBeginAllowThreads();
26875 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
26876 wxPyEndAllowThreads(__tstate);
26877 if (PyErr_Occurred()) SWIG_fail;
26878 }
26879 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
26880 return resultobj;
26881 fail:
26882 return NULL;
26883 }
26884
26885
26886 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26887 PyObject *resultobj = 0;
26888 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26889 wxPoint result;
26890 void *argp1 = 0 ;
26891 int res1 = 0 ;
26892 PyObject *swig_obj[1] ;
26893
26894 if (!args) SWIG_fail;
26895 swig_obj[0] = args;
26896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26897 if (!SWIG_IsOK(res1)) {
26898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26899 }
26900 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26901 {
26902 PyThreadState* __tstate = wxPyBeginAllowThreads();
26903 result = ((wxMoveEvent const *)arg1)->GetPosition();
26904 wxPyEndAllowThreads(__tstate);
26905 if (PyErr_Occurred()) SWIG_fail;
26906 }
26907 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
26908 return resultobj;
26909 fail:
26910 return NULL;
26911 }
26912
26913
26914 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26915 PyObject *resultobj = 0;
26916 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26917 wxRect result;
26918 void *argp1 = 0 ;
26919 int res1 = 0 ;
26920 PyObject *swig_obj[1] ;
26921
26922 if (!args) SWIG_fail;
26923 swig_obj[0] = args;
26924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26925 if (!SWIG_IsOK(res1)) {
26926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26927 }
26928 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26929 {
26930 PyThreadState* __tstate = wxPyBeginAllowThreads();
26931 result = ((wxMoveEvent const *)arg1)->GetRect();
26932 wxPyEndAllowThreads(__tstate);
26933 if (PyErr_Occurred()) SWIG_fail;
26934 }
26935 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26936 return resultobj;
26937 fail:
26938 return NULL;
26939 }
26940
26941
26942 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26943 PyObject *resultobj = 0;
26944 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26945 wxRect *arg2 = 0 ;
26946 void *argp1 = 0 ;
26947 int res1 = 0 ;
26948 wxRect temp2 ;
26949 PyObject * obj0 = 0 ;
26950 PyObject * obj1 = 0 ;
26951 char * kwnames[] = {
26952 (char *) "self",(char *) "rect", NULL
26953 };
26954
26955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26957 if (!SWIG_IsOK(res1)) {
26958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26959 }
26960 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26961 {
26962 arg2 = &temp2;
26963 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26964 }
26965 {
26966 PyThreadState* __tstate = wxPyBeginAllowThreads();
26967 (arg1)->SetRect((wxRect const &)*arg2);
26968 wxPyEndAllowThreads(__tstate);
26969 if (PyErr_Occurred()) SWIG_fail;
26970 }
26971 resultobj = SWIG_Py_Void();
26972 return resultobj;
26973 fail:
26974 return NULL;
26975 }
26976
26977
26978 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26979 PyObject *resultobj = 0;
26980 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26981 wxPoint *arg2 = 0 ;
26982 void *argp1 = 0 ;
26983 int res1 = 0 ;
26984 wxPoint temp2 ;
26985 PyObject * obj0 = 0 ;
26986 PyObject * obj1 = 0 ;
26987 char * kwnames[] = {
26988 (char *) "self",(char *) "pos", NULL
26989 };
26990
26991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26993 if (!SWIG_IsOK(res1)) {
26994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26995 }
26996 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26997 {
26998 arg2 = &temp2;
26999 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
27000 }
27001 {
27002 PyThreadState* __tstate = wxPyBeginAllowThreads();
27003 (arg1)->SetPosition((wxPoint const &)*arg2);
27004 wxPyEndAllowThreads(__tstate);
27005 if (PyErr_Occurred()) SWIG_fail;
27006 }
27007 resultobj = SWIG_Py_Void();
27008 return resultobj;
27009 fail:
27010 return NULL;
27011 }
27012
27013
27014 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27015 PyObject *obj;
27016 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27017 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
27018 return SWIG_Py_Void();
27019 }
27020
27021 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27022 return SWIG_Python_InitShadowInstance(args);
27023 }
27024
27025 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27026 PyObject *resultobj = 0;
27027 int arg1 = (int) 0 ;
27028 wxPaintEvent *result = 0 ;
27029 int val1 ;
27030 int ecode1 = 0 ;
27031 PyObject * obj0 = 0 ;
27032 char * kwnames[] = {
27033 (char *) "Id", NULL
27034 };
27035
27036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
27037 if (obj0) {
27038 ecode1 = SWIG_AsVal_int(obj0, &val1);
27039 if (!SWIG_IsOK(ecode1)) {
27040 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
27041 }
27042 arg1 = static_cast< int >(val1);
27043 }
27044 {
27045 PyThreadState* __tstate = wxPyBeginAllowThreads();
27046 result = (wxPaintEvent *)new wxPaintEvent(arg1);
27047 wxPyEndAllowThreads(__tstate);
27048 if (PyErr_Occurred()) SWIG_fail;
27049 }
27050 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
27051 return resultobj;
27052 fail:
27053 return NULL;
27054 }
27055
27056
27057 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27058 PyObject *obj;
27059 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27060 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
27061 return SWIG_Py_Void();
27062 }
27063
27064 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27065 return SWIG_Python_InitShadowInstance(args);
27066 }
27067
27068 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27069 PyObject *resultobj = 0;
27070 int arg1 = (int) 0 ;
27071 wxNcPaintEvent *result = 0 ;
27072 int val1 ;
27073 int ecode1 = 0 ;
27074 PyObject * obj0 = 0 ;
27075 char * kwnames[] = {
27076 (char *) "winid", NULL
27077 };
27078
27079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
27080 if (obj0) {
27081 ecode1 = SWIG_AsVal_int(obj0, &val1);
27082 if (!SWIG_IsOK(ecode1)) {
27083 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
27084 }
27085 arg1 = static_cast< int >(val1);
27086 }
27087 {
27088 PyThreadState* __tstate = wxPyBeginAllowThreads();
27089 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
27090 wxPyEndAllowThreads(__tstate);
27091 if (PyErr_Occurred()) SWIG_fail;
27092 }
27093 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
27094 return resultobj;
27095 fail:
27096 return NULL;
27097 }
27098
27099
27100 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27101 PyObject *obj;
27102 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27103 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
27104 return SWIG_Py_Void();
27105 }
27106
27107 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27108 return SWIG_Python_InitShadowInstance(args);
27109 }
27110
27111 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27112 PyObject *resultobj = 0;
27113 int arg1 = (int) 0 ;
27114 wxDC *arg2 = (wxDC *) NULL ;
27115 wxEraseEvent *result = 0 ;
27116 int val1 ;
27117 int ecode1 = 0 ;
27118 void *argp2 = 0 ;
27119 int res2 = 0 ;
27120 PyObject * obj0 = 0 ;
27121 PyObject * obj1 = 0 ;
27122 char * kwnames[] = {
27123 (char *) "Id",(char *) "dc", NULL
27124 };
27125
27126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27127 if (obj0) {
27128 ecode1 = SWIG_AsVal_int(obj0, &val1);
27129 if (!SWIG_IsOK(ecode1)) {
27130 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
27131 }
27132 arg1 = static_cast< int >(val1);
27133 }
27134 if (obj1) {
27135 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
27136 if (!SWIG_IsOK(res2)) {
27137 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
27138 }
27139 arg2 = reinterpret_cast< wxDC * >(argp2);
27140 }
27141 {
27142 PyThreadState* __tstate = wxPyBeginAllowThreads();
27143 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
27144 wxPyEndAllowThreads(__tstate);
27145 if (PyErr_Occurred()) SWIG_fail;
27146 }
27147 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
27148 return resultobj;
27149 fail:
27150 return NULL;
27151 }
27152
27153
27154 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27155 PyObject *resultobj = 0;
27156 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
27157 wxDC *result = 0 ;
27158 void *argp1 = 0 ;
27159 int res1 = 0 ;
27160 PyObject *swig_obj[1] ;
27161
27162 if (!args) SWIG_fail;
27163 swig_obj[0] = args;
27164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
27165 if (!SWIG_IsOK(res1)) {
27166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
27167 }
27168 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
27169 {
27170 PyThreadState* __tstate = wxPyBeginAllowThreads();
27171 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
27172 wxPyEndAllowThreads(__tstate);
27173 if (PyErr_Occurred()) SWIG_fail;
27174 }
27175 {
27176 resultobj = wxPyMake_wxObject(result, (bool)0);
27177 }
27178 return resultobj;
27179 fail:
27180 return NULL;
27181 }
27182
27183
27184 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27185 PyObject *obj;
27186 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27187 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
27188 return SWIG_Py_Void();
27189 }
27190
27191 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27192 return SWIG_Python_InitShadowInstance(args);
27193 }
27194
27195 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27196 PyObject *resultobj = 0;
27197 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27198 int arg2 = (int) 0 ;
27199 wxFocusEvent *result = 0 ;
27200 int val1 ;
27201 int ecode1 = 0 ;
27202 int val2 ;
27203 int ecode2 = 0 ;
27204 PyObject * obj0 = 0 ;
27205 PyObject * obj1 = 0 ;
27206 char * kwnames[] = {
27207 (char *) "type",(char *) "winid", NULL
27208 };
27209
27210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27211 if (obj0) {
27212 ecode1 = SWIG_AsVal_int(obj0, &val1);
27213 if (!SWIG_IsOK(ecode1)) {
27214 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27215 }
27216 arg1 = static_cast< wxEventType >(val1);
27217 }
27218 if (obj1) {
27219 ecode2 = SWIG_AsVal_int(obj1, &val2);
27220 if (!SWIG_IsOK(ecode2)) {
27221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
27222 }
27223 arg2 = static_cast< int >(val2);
27224 }
27225 {
27226 PyThreadState* __tstate = wxPyBeginAllowThreads();
27227 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
27228 wxPyEndAllowThreads(__tstate);
27229 if (PyErr_Occurred()) SWIG_fail;
27230 }
27231 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
27232 return resultobj;
27233 fail:
27234 return NULL;
27235 }
27236
27237
27238 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27239 PyObject *resultobj = 0;
27240 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
27241 wxWindow *result = 0 ;
27242 void *argp1 = 0 ;
27243 int res1 = 0 ;
27244 PyObject *swig_obj[1] ;
27245
27246 if (!args) SWIG_fail;
27247 swig_obj[0] = args;
27248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
27249 if (!SWIG_IsOK(res1)) {
27250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
27251 }
27252 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
27253 {
27254 PyThreadState* __tstate = wxPyBeginAllowThreads();
27255 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
27256 wxPyEndAllowThreads(__tstate);
27257 if (PyErr_Occurred()) SWIG_fail;
27258 }
27259 {
27260 resultobj = wxPyMake_wxObject(result, (bool)0);
27261 }
27262 return resultobj;
27263 fail:
27264 return NULL;
27265 }
27266
27267
27268 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27269 PyObject *resultobj = 0;
27270 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
27271 wxWindow *arg2 = (wxWindow *) 0 ;
27272 void *argp1 = 0 ;
27273 int res1 = 0 ;
27274 void *argp2 = 0 ;
27275 int res2 = 0 ;
27276 PyObject * obj0 = 0 ;
27277 PyObject * obj1 = 0 ;
27278 char * kwnames[] = {
27279 (char *) "self",(char *) "win", NULL
27280 };
27281
27282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
27284 if (!SWIG_IsOK(res1)) {
27285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
27286 }
27287 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
27288 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27289 if (!SWIG_IsOK(res2)) {
27290 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27291 }
27292 arg2 = reinterpret_cast< wxWindow * >(argp2);
27293 {
27294 PyThreadState* __tstate = wxPyBeginAllowThreads();
27295 (arg1)->SetWindow(arg2);
27296 wxPyEndAllowThreads(__tstate);
27297 if (PyErr_Occurred()) SWIG_fail;
27298 }
27299 resultobj = SWIG_Py_Void();
27300 return resultobj;
27301 fail:
27302 return NULL;
27303 }
27304
27305
27306 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27307 PyObject *obj;
27308 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27309 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
27310 return SWIG_Py_Void();
27311 }
27312
27313 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27314 return SWIG_Python_InitShadowInstance(args);
27315 }
27316
27317 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27318 PyObject *resultobj = 0;
27319 wxWindow *arg1 = (wxWindow *) NULL ;
27320 wxChildFocusEvent *result = 0 ;
27321 void *argp1 = 0 ;
27322 int res1 = 0 ;
27323 PyObject * obj0 = 0 ;
27324 char * kwnames[] = {
27325 (char *) "win", NULL
27326 };
27327
27328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
27329 if (obj0) {
27330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27331 if (!SWIG_IsOK(res1)) {
27332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
27333 }
27334 arg1 = reinterpret_cast< wxWindow * >(argp1);
27335 }
27336 {
27337 PyThreadState* __tstate = wxPyBeginAllowThreads();
27338 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
27339 wxPyEndAllowThreads(__tstate);
27340 if (PyErr_Occurred()) SWIG_fail;
27341 }
27342 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
27343 return resultobj;
27344 fail:
27345 return NULL;
27346 }
27347
27348
27349 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27350 PyObject *resultobj = 0;
27351 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
27352 wxWindow *result = 0 ;
27353 void *argp1 = 0 ;
27354 int res1 = 0 ;
27355 PyObject *swig_obj[1] ;
27356
27357 if (!args) SWIG_fail;
27358 swig_obj[0] = args;
27359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
27360 if (!SWIG_IsOK(res1)) {
27361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
27362 }
27363 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
27364 {
27365 PyThreadState* __tstate = wxPyBeginAllowThreads();
27366 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
27367 wxPyEndAllowThreads(__tstate);
27368 if (PyErr_Occurred()) SWIG_fail;
27369 }
27370 {
27371 resultobj = wxPyMake_wxObject(result, (bool)0);
27372 }
27373 return resultobj;
27374 fail:
27375 return NULL;
27376 }
27377
27378
27379 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27380 PyObject *obj;
27381 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27382 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
27383 return SWIG_Py_Void();
27384 }
27385
27386 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27387 return SWIG_Python_InitShadowInstance(args);
27388 }
27389
27390 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27391 PyObject *resultobj = 0;
27392 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27393 bool arg2 = (bool) true ;
27394 int arg3 = (int) 0 ;
27395 wxActivateEvent *result = 0 ;
27396 int val1 ;
27397 int ecode1 = 0 ;
27398 bool val2 ;
27399 int ecode2 = 0 ;
27400 int val3 ;
27401 int ecode3 = 0 ;
27402 PyObject * obj0 = 0 ;
27403 PyObject * obj1 = 0 ;
27404 PyObject * obj2 = 0 ;
27405 char * kwnames[] = {
27406 (char *) "type",(char *) "active",(char *) "Id", NULL
27407 };
27408
27409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27410 if (obj0) {
27411 ecode1 = SWIG_AsVal_int(obj0, &val1);
27412 if (!SWIG_IsOK(ecode1)) {
27413 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27414 }
27415 arg1 = static_cast< wxEventType >(val1);
27416 }
27417 if (obj1) {
27418 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27419 if (!SWIG_IsOK(ecode2)) {
27420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
27421 }
27422 arg2 = static_cast< bool >(val2);
27423 }
27424 if (obj2) {
27425 ecode3 = SWIG_AsVal_int(obj2, &val3);
27426 if (!SWIG_IsOK(ecode3)) {
27427 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
27428 }
27429 arg3 = static_cast< int >(val3);
27430 }
27431 {
27432 PyThreadState* __tstate = wxPyBeginAllowThreads();
27433 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
27434 wxPyEndAllowThreads(__tstate);
27435 if (PyErr_Occurred()) SWIG_fail;
27436 }
27437 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
27438 return resultobj;
27439 fail:
27440 return NULL;
27441 }
27442
27443
27444 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27445 PyObject *resultobj = 0;
27446 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
27447 bool result;
27448 void *argp1 = 0 ;
27449 int res1 = 0 ;
27450 PyObject *swig_obj[1] ;
27451
27452 if (!args) SWIG_fail;
27453 swig_obj[0] = args;
27454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
27455 if (!SWIG_IsOK(res1)) {
27456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
27457 }
27458 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
27459 {
27460 PyThreadState* __tstate = wxPyBeginAllowThreads();
27461 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
27462 wxPyEndAllowThreads(__tstate);
27463 if (PyErr_Occurred()) SWIG_fail;
27464 }
27465 {
27466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27467 }
27468 return resultobj;
27469 fail:
27470 return NULL;
27471 }
27472
27473
27474 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27475 PyObject *obj;
27476 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27477 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
27478 return SWIG_Py_Void();
27479 }
27480
27481 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27482 return SWIG_Python_InitShadowInstance(args);
27483 }
27484
27485 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27486 PyObject *resultobj = 0;
27487 int arg1 = (int) 0 ;
27488 wxInitDialogEvent *result = 0 ;
27489 int val1 ;
27490 int ecode1 = 0 ;
27491 PyObject * obj0 = 0 ;
27492 char * kwnames[] = {
27493 (char *) "Id", NULL
27494 };
27495
27496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
27497 if (obj0) {
27498 ecode1 = SWIG_AsVal_int(obj0, &val1);
27499 if (!SWIG_IsOK(ecode1)) {
27500 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
27501 }
27502 arg1 = static_cast< int >(val1);
27503 }
27504 {
27505 PyThreadState* __tstate = wxPyBeginAllowThreads();
27506 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
27507 wxPyEndAllowThreads(__tstate);
27508 if (PyErr_Occurred()) SWIG_fail;
27509 }
27510 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
27511 return resultobj;
27512 fail:
27513 return NULL;
27514 }
27515
27516
27517 SWIGINTERN PyObject *InitDialogEvent_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_wxInitDialogEvent, SWIG_NewClientData(obj));
27521 return SWIG_Py_Void();
27522 }
27523
27524 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27525 return SWIG_Python_InitShadowInstance(args);
27526 }
27527
27528 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27529 PyObject *resultobj = 0;
27530 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27531 int arg2 = (int) 0 ;
27532 wxMenu *arg3 = (wxMenu *) NULL ;
27533 wxMenuEvent *result = 0 ;
27534 int val1 ;
27535 int ecode1 = 0 ;
27536 int val2 ;
27537 int ecode2 = 0 ;
27538 void *argp3 = 0 ;
27539 int res3 = 0 ;
27540 PyObject * obj0 = 0 ;
27541 PyObject * obj1 = 0 ;
27542 PyObject * obj2 = 0 ;
27543 char * kwnames[] = {
27544 (char *) "type",(char *) "winid",(char *) "menu", NULL
27545 };
27546
27547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27548 if (obj0) {
27549 ecode1 = SWIG_AsVal_int(obj0, &val1);
27550 if (!SWIG_IsOK(ecode1)) {
27551 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27552 }
27553 arg1 = static_cast< wxEventType >(val1);
27554 }
27555 if (obj1) {
27556 ecode2 = SWIG_AsVal_int(obj1, &val2);
27557 if (!SWIG_IsOK(ecode2)) {
27558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
27559 }
27560 arg2 = static_cast< int >(val2);
27561 }
27562 if (obj2) {
27563 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
27564 if (!SWIG_IsOK(res3)) {
27565 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
27566 }
27567 arg3 = reinterpret_cast< wxMenu * >(argp3);
27568 }
27569 {
27570 PyThreadState* __tstate = wxPyBeginAllowThreads();
27571 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
27572 wxPyEndAllowThreads(__tstate);
27573 if (PyErr_Occurred()) SWIG_fail;
27574 }
27575 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
27576 return resultobj;
27577 fail:
27578 return NULL;
27579 }
27580
27581
27582 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27583 PyObject *resultobj = 0;
27584 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27585 int result;
27586 void *argp1 = 0 ;
27587 int res1 = 0 ;
27588 PyObject *swig_obj[1] ;
27589
27590 if (!args) SWIG_fail;
27591 swig_obj[0] = args;
27592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27593 if (!SWIG_IsOK(res1)) {
27594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27595 }
27596 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27597 {
27598 PyThreadState* __tstate = wxPyBeginAllowThreads();
27599 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
27600 wxPyEndAllowThreads(__tstate);
27601 if (PyErr_Occurred()) SWIG_fail;
27602 }
27603 resultobj = SWIG_From_int(static_cast< int >(result));
27604 return resultobj;
27605 fail:
27606 return NULL;
27607 }
27608
27609
27610 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27611 PyObject *resultobj = 0;
27612 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27613 bool result;
27614 void *argp1 = 0 ;
27615 int res1 = 0 ;
27616 PyObject *swig_obj[1] ;
27617
27618 if (!args) SWIG_fail;
27619 swig_obj[0] = args;
27620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27621 if (!SWIG_IsOK(res1)) {
27622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27623 }
27624 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27625 {
27626 PyThreadState* __tstate = wxPyBeginAllowThreads();
27627 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
27628 wxPyEndAllowThreads(__tstate);
27629 if (PyErr_Occurred()) SWIG_fail;
27630 }
27631 {
27632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27633 }
27634 return resultobj;
27635 fail:
27636 return NULL;
27637 }
27638
27639
27640 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27641 PyObject *resultobj = 0;
27642 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27643 wxMenu *result = 0 ;
27644 void *argp1 = 0 ;
27645 int res1 = 0 ;
27646 PyObject *swig_obj[1] ;
27647
27648 if (!args) SWIG_fail;
27649 swig_obj[0] = args;
27650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27651 if (!SWIG_IsOK(res1)) {
27652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27653 }
27654 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27655 {
27656 PyThreadState* __tstate = wxPyBeginAllowThreads();
27657 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
27658 wxPyEndAllowThreads(__tstate);
27659 if (PyErr_Occurred()) SWIG_fail;
27660 }
27661 {
27662 resultobj = wxPyMake_wxObject(result, (bool)0);
27663 }
27664 return resultobj;
27665 fail:
27666 return NULL;
27667 }
27668
27669
27670 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27671 PyObject *obj;
27672 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27673 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
27674 return SWIG_Py_Void();
27675 }
27676
27677 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27678 return SWIG_Python_InitShadowInstance(args);
27679 }
27680
27681 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27682 PyObject *resultobj = 0;
27683 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27684 int arg2 = (int) 0 ;
27685 wxCloseEvent *result = 0 ;
27686 int val1 ;
27687 int ecode1 = 0 ;
27688 int val2 ;
27689 int ecode2 = 0 ;
27690 PyObject * obj0 = 0 ;
27691 PyObject * obj1 = 0 ;
27692 char * kwnames[] = {
27693 (char *) "type",(char *) "winid", NULL
27694 };
27695
27696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27697 if (obj0) {
27698 ecode1 = SWIG_AsVal_int(obj0, &val1);
27699 if (!SWIG_IsOK(ecode1)) {
27700 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27701 }
27702 arg1 = static_cast< wxEventType >(val1);
27703 }
27704 if (obj1) {
27705 ecode2 = SWIG_AsVal_int(obj1, &val2);
27706 if (!SWIG_IsOK(ecode2)) {
27707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
27708 }
27709 arg2 = static_cast< int >(val2);
27710 }
27711 {
27712 PyThreadState* __tstate = wxPyBeginAllowThreads();
27713 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
27714 wxPyEndAllowThreads(__tstate);
27715 if (PyErr_Occurred()) SWIG_fail;
27716 }
27717 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
27718 return resultobj;
27719 fail:
27720 return NULL;
27721 }
27722
27723
27724 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27725 PyObject *resultobj = 0;
27726 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27727 bool arg2 ;
27728 void *argp1 = 0 ;
27729 int res1 = 0 ;
27730 bool val2 ;
27731 int ecode2 = 0 ;
27732 PyObject * obj0 = 0 ;
27733 PyObject * obj1 = 0 ;
27734 char * kwnames[] = {
27735 (char *) "self",(char *) "logOff", NULL
27736 };
27737
27738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
27739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27740 if (!SWIG_IsOK(res1)) {
27741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27742 }
27743 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27744 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27745 if (!SWIG_IsOK(ecode2)) {
27746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
27747 }
27748 arg2 = static_cast< bool >(val2);
27749 {
27750 PyThreadState* __tstate = wxPyBeginAllowThreads();
27751 (arg1)->SetLoggingOff(arg2);
27752 wxPyEndAllowThreads(__tstate);
27753 if (PyErr_Occurred()) SWIG_fail;
27754 }
27755 resultobj = SWIG_Py_Void();
27756 return resultobj;
27757 fail:
27758 return NULL;
27759 }
27760
27761
27762 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27763 PyObject *resultobj = 0;
27764 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27765 bool result;
27766 void *argp1 = 0 ;
27767 int res1 = 0 ;
27768 PyObject *swig_obj[1] ;
27769
27770 if (!args) SWIG_fail;
27771 swig_obj[0] = args;
27772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27773 if (!SWIG_IsOK(res1)) {
27774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27775 }
27776 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27777 {
27778 PyThreadState* __tstate = wxPyBeginAllowThreads();
27779 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
27780 wxPyEndAllowThreads(__tstate);
27781 if (PyErr_Occurred()) SWIG_fail;
27782 }
27783 {
27784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27785 }
27786 return resultobj;
27787 fail:
27788 return NULL;
27789 }
27790
27791
27792 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27793 PyObject *resultobj = 0;
27794 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27795 bool arg2 = (bool) true ;
27796 void *argp1 = 0 ;
27797 int res1 = 0 ;
27798 bool val2 ;
27799 int ecode2 = 0 ;
27800 PyObject * obj0 = 0 ;
27801 PyObject * obj1 = 0 ;
27802 char * kwnames[] = {
27803 (char *) "self",(char *) "veto", NULL
27804 };
27805
27806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
27807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27808 if (!SWIG_IsOK(res1)) {
27809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27810 }
27811 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27812 if (obj1) {
27813 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27814 if (!SWIG_IsOK(ecode2)) {
27815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
27816 }
27817 arg2 = static_cast< bool >(val2);
27818 }
27819 {
27820 PyThreadState* __tstate = wxPyBeginAllowThreads();
27821 (arg1)->Veto(arg2);
27822 wxPyEndAllowThreads(__tstate);
27823 if (PyErr_Occurred()) SWIG_fail;
27824 }
27825 resultobj = SWIG_Py_Void();
27826 return resultobj;
27827 fail:
27828 return NULL;
27829 }
27830
27831
27832 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27833 PyObject *resultobj = 0;
27834 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27835 bool result;
27836 void *argp1 = 0 ;
27837 int res1 = 0 ;
27838 PyObject *swig_obj[1] ;
27839
27840 if (!args) SWIG_fail;
27841 swig_obj[0] = args;
27842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27843 if (!SWIG_IsOK(res1)) {
27844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27845 }
27846 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27847 {
27848 PyThreadState* __tstate = wxPyBeginAllowThreads();
27849 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
27850 wxPyEndAllowThreads(__tstate);
27851 if (PyErr_Occurred()) SWIG_fail;
27852 }
27853 {
27854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27855 }
27856 return resultobj;
27857 fail:
27858 return NULL;
27859 }
27860
27861
27862 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27863 PyObject *resultobj = 0;
27864 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27865 bool arg2 ;
27866 void *argp1 = 0 ;
27867 int res1 = 0 ;
27868 bool val2 ;
27869 int ecode2 = 0 ;
27870 PyObject * obj0 = 0 ;
27871 PyObject * obj1 = 0 ;
27872 char * kwnames[] = {
27873 (char *) "self",(char *) "canVeto", NULL
27874 };
27875
27876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
27877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27878 if (!SWIG_IsOK(res1)) {
27879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27880 }
27881 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27882 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27883 if (!SWIG_IsOK(ecode2)) {
27884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
27885 }
27886 arg2 = static_cast< bool >(val2);
27887 {
27888 PyThreadState* __tstate = wxPyBeginAllowThreads();
27889 (arg1)->SetCanVeto(arg2);
27890 wxPyEndAllowThreads(__tstate);
27891 if (PyErr_Occurred()) SWIG_fail;
27892 }
27893 resultobj = SWIG_Py_Void();
27894 return resultobj;
27895 fail:
27896 return NULL;
27897 }
27898
27899
27900 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27901 PyObject *resultobj = 0;
27902 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27903 bool result;
27904 void *argp1 = 0 ;
27905 int res1 = 0 ;
27906 PyObject *swig_obj[1] ;
27907
27908 if (!args) SWIG_fail;
27909 swig_obj[0] = args;
27910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27911 if (!SWIG_IsOK(res1)) {
27912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27913 }
27914 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27915 {
27916 PyThreadState* __tstate = wxPyBeginAllowThreads();
27917 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
27918 wxPyEndAllowThreads(__tstate);
27919 if (PyErr_Occurred()) SWIG_fail;
27920 }
27921 {
27922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27923 }
27924 return resultobj;
27925 fail:
27926 return NULL;
27927 }
27928
27929
27930 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27931 PyObject *obj;
27932 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27933 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
27934 return SWIG_Py_Void();
27935 }
27936
27937 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27938 return SWIG_Python_InitShadowInstance(args);
27939 }
27940
27941 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27942 PyObject *resultobj = 0;
27943 int arg1 = (int) 0 ;
27944 bool arg2 = (bool) false ;
27945 wxShowEvent *result = 0 ;
27946 int val1 ;
27947 int ecode1 = 0 ;
27948 bool val2 ;
27949 int ecode2 = 0 ;
27950 PyObject * obj0 = 0 ;
27951 PyObject * obj1 = 0 ;
27952 char * kwnames[] = {
27953 (char *) "winid",(char *) "show", NULL
27954 };
27955
27956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27957 if (obj0) {
27958 ecode1 = SWIG_AsVal_int(obj0, &val1);
27959 if (!SWIG_IsOK(ecode1)) {
27960 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
27961 }
27962 arg1 = static_cast< int >(val1);
27963 }
27964 if (obj1) {
27965 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27966 if (!SWIG_IsOK(ecode2)) {
27967 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
27968 }
27969 arg2 = static_cast< bool >(val2);
27970 }
27971 {
27972 PyThreadState* __tstate = wxPyBeginAllowThreads();
27973 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
27974 wxPyEndAllowThreads(__tstate);
27975 if (PyErr_Occurred()) SWIG_fail;
27976 }
27977 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
27978 return resultobj;
27979 fail:
27980 return NULL;
27981 }
27982
27983
27984 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27985 PyObject *resultobj = 0;
27986 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27987 bool arg2 ;
27988 void *argp1 = 0 ;
27989 int res1 = 0 ;
27990 bool val2 ;
27991 int ecode2 = 0 ;
27992 PyObject * obj0 = 0 ;
27993 PyObject * obj1 = 0 ;
27994 char * kwnames[] = {
27995 (char *) "self",(char *) "show", NULL
27996 };
27997
27998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
27999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
28000 if (!SWIG_IsOK(res1)) {
28001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
28002 }
28003 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
28004 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28005 if (!SWIG_IsOK(ecode2)) {
28006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
28007 }
28008 arg2 = static_cast< bool >(val2);
28009 {
28010 PyThreadState* __tstate = wxPyBeginAllowThreads();
28011 (arg1)->SetShow(arg2);
28012 wxPyEndAllowThreads(__tstate);
28013 if (PyErr_Occurred()) SWIG_fail;
28014 }
28015 resultobj = SWIG_Py_Void();
28016 return resultobj;
28017 fail:
28018 return NULL;
28019 }
28020
28021
28022 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28023 PyObject *resultobj = 0;
28024 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
28025 bool result;
28026 void *argp1 = 0 ;
28027 int res1 = 0 ;
28028 PyObject *swig_obj[1] ;
28029
28030 if (!args) SWIG_fail;
28031 swig_obj[0] = args;
28032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
28033 if (!SWIG_IsOK(res1)) {
28034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
28035 }
28036 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
28037 {
28038 PyThreadState* __tstate = wxPyBeginAllowThreads();
28039 result = (bool)((wxShowEvent const *)arg1)->GetShow();
28040 wxPyEndAllowThreads(__tstate);
28041 if (PyErr_Occurred()) SWIG_fail;
28042 }
28043 {
28044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28045 }
28046 return resultobj;
28047 fail:
28048 return NULL;
28049 }
28050
28051
28052 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28053 PyObject *obj;
28054 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28055 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
28056 return SWIG_Py_Void();
28057 }
28058
28059 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28060 return SWIG_Python_InitShadowInstance(args);
28061 }
28062
28063 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28064 PyObject *resultobj = 0;
28065 int arg1 = (int) 0 ;
28066 bool arg2 = (bool) true ;
28067 wxIconizeEvent *result = 0 ;
28068 int val1 ;
28069 int ecode1 = 0 ;
28070 bool val2 ;
28071 int ecode2 = 0 ;
28072 PyObject * obj0 = 0 ;
28073 PyObject * obj1 = 0 ;
28074 char * kwnames[] = {
28075 (char *) "id",(char *) "iconized", NULL
28076 };
28077
28078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28079 if (obj0) {
28080 ecode1 = SWIG_AsVal_int(obj0, &val1);
28081 if (!SWIG_IsOK(ecode1)) {
28082 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
28083 }
28084 arg1 = static_cast< int >(val1);
28085 }
28086 if (obj1) {
28087 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28088 if (!SWIG_IsOK(ecode2)) {
28089 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
28090 }
28091 arg2 = static_cast< bool >(val2);
28092 }
28093 {
28094 PyThreadState* __tstate = wxPyBeginAllowThreads();
28095 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
28096 wxPyEndAllowThreads(__tstate);
28097 if (PyErr_Occurred()) SWIG_fail;
28098 }
28099 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
28100 return resultobj;
28101 fail:
28102 return NULL;
28103 }
28104
28105
28106 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28107 PyObject *resultobj = 0;
28108 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
28109 bool result;
28110 void *argp1 = 0 ;
28111 int res1 = 0 ;
28112 PyObject *swig_obj[1] ;
28113
28114 if (!args) SWIG_fail;
28115 swig_obj[0] = args;
28116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
28117 if (!SWIG_IsOK(res1)) {
28118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
28119 }
28120 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
28121 {
28122 PyThreadState* __tstate = wxPyBeginAllowThreads();
28123 result = (bool)(arg1)->Iconized();
28124 wxPyEndAllowThreads(__tstate);
28125 if (PyErr_Occurred()) SWIG_fail;
28126 }
28127 {
28128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28129 }
28130 return resultobj;
28131 fail:
28132 return NULL;
28133 }
28134
28135
28136 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28137 PyObject *obj;
28138 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28139 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
28140 return SWIG_Py_Void();
28141 }
28142
28143 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28144 return SWIG_Python_InitShadowInstance(args);
28145 }
28146
28147 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28148 PyObject *resultobj = 0;
28149 int arg1 = (int) 0 ;
28150 wxMaximizeEvent *result = 0 ;
28151 int val1 ;
28152 int ecode1 = 0 ;
28153 PyObject * obj0 = 0 ;
28154 char * kwnames[] = {
28155 (char *) "id", NULL
28156 };
28157
28158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
28159 if (obj0) {
28160 ecode1 = SWIG_AsVal_int(obj0, &val1);
28161 if (!SWIG_IsOK(ecode1)) {
28162 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
28163 }
28164 arg1 = static_cast< int >(val1);
28165 }
28166 {
28167 PyThreadState* __tstate = wxPyBeginAllowThreads();
28168 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
28169 wxPyEndAllowThreads(__tstate);
28170 if (PyErr_Occurred()) SWIG_fail;
28171 }
28172 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
28173 return resultobj;
28174 fail:
28175 return NULL;
28176 }
28177
28178
28179 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28180 PyObject *obj;
28181 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28182 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
28183 return SWIG_Py_Void();
28184 }
28185
28186 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28187 return SWIG_Python_InitShadowInstance(args);
28188 }
28189
28190 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28191 PyObject *resultobj = 0;
28192 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
28193 wxPoint result;
28194 void *argp1 = 0 ;
28195 int res1 = 0 ;
28196 PyObject *swig_obj[1] ;
28197
28198 if (!args) SWIG_fail;
28199 swig_obj[0] = args;
28200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
28201 if (!SWIG_IsOK(res1)) {
28202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
28203 }
28204 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
28205 {
28206 PyThreadState* __tstate = wxPyBeginAllowThreads();
28207 result = (arg1)->GetPosition();
28208 wxPyEndAllowThreads(__tstate);
28209 if (PyErr_Occurred()) SWIG_fail;
28210 }
28211 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
28212 return resultobj;
28213 fail:
28214 return NULL;
28215 }
28216
28217
28218 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28219 PyObject *resultobj = 0;
28220 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
28221 int result;
28222 void *argp1 = 0 ;
28223 int res1 = 0 ;
28224 PyObject *swig_obj[1] ;
28225
28226 if (!args) SWIG_fail;
28227 swig_obj[0] = args;
28228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
28229 if (!SWIG_IsOK(res1)) {
28230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
28231 }
28232 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
28233 {
28234 PyThreadState* __tstate = wxPyBeginAllowThreads();
28235 result = (int)(arg1)->GetNumberOfFiles();
28236 wxPyEndAllowThreads(__tstate);
28237 if (PyErr_Occurred()) SWIG_fail;
28238 }
28239 resultobj = SWIG_From_int(static_cast< int >(result));
28240 return resultobj;
28241 fail:
28242 return NULL;
28243 }
28244
28245
28246 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28247 PyObject *resultobj = 0;
28248 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
28249 PyObject *result = 0 ;
28250 void *argp1 = 0 ;
28251 int res1 = 0 ;
28252 PyObject *swig_obj[1] ;
28253
28254 if (!args) SWIG_fail;
28255 swig_obj[0] = args;
28256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
28257 if (!SWIG_IsOK(res1)) {
28258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
28259 }
28260 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
28261 {
28262 PyThreadState* __tstate = wxPyBeginAllowThreads();
28263 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
28264 wxPyEndAllowThreads(__tstate);
28265 if (PyErr_Occurred()) SWIG_fail;
28266 }
28267 resultobj = result;
28268 return resultobj;
28269 fail:
28270 return NULL;
28271 }
28272
28273
28274 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28275 PyObject *obj;
28276 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28277 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
28278 return SWIG_Py_Void();
28279 }
28280
28281 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28282 PyObject *resultobj = 0;
28283 int arg1 = (int) 0 ;
28284 wxUpdateUIEvent *result = 0 ;
28285 int val1 ;
28286 int ecode1 = 0 ;
28287 PyObject * obj0 = 0 ;
28288 char * kwnames[] = {
28289 (char *) "commandId", NULL
28290 };
28291
28292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
28293 if (obj0) {
28294 ecode1 = SWIG_AsVal_int(obj0, &val1);
28295 if (!SWIG_IsOK(ecode1)) {
28296 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
28297 }
28298 arg1 = static_cast< int >(val1);
28299 }
28300 {
28301 PyThreadState* __tstate = wxPyBeginAllowThreads();
28302 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
28303 wxPyEndAllowThreads(__tstate);
28304 if (PyErr_Occurred()) SWIG_fail;
28305 }
28306 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
28307 return resultobj;
28308 fail:
28309 return NULL;
28310 }
28311
28312
28313 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28314 PyObject *resultobj = 0;
28315 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28316 bool result;
28317 void *argp1 = 0 ;
28318 int res1 = 0 ;
28319 PyObject *swig_obj[1] ;
28320
28321 if (!args) SWIG_fail;
28322 swig_obj[0] = args;
28323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28324 if (!SWIG_IsOK(res1)) {
28325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28326 }
28327 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28328 {
28329 PyThreadState* __tstate = wxPyBeginAllowThreads();
28330 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
28331 wxPyEndAllowThreads(__tstate);
28332 if (PyErr_Occurred()) SWIG_fail;
28333 }
28334 {
28335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28336 }
28337 return resultobj;
28338 fail:
28339 return NULL;
28340 }
28341
28342
28343 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28344 PyObject *resultobj = 0;
28345 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28346 bool result;
28347 void *argp1 = 0 ;
28348 int res1 = 0 ;
28349 PyObject *swig_obj[1] ;
28350
28351 if (!args) SWIG_fail;
28352 swig_obj[0] = args;
28353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28354 if (!SWIG_IsOK(res1)) {
28355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28356 }
28357 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28358 {
28359 PyThreadState* __tstate = wxPyBeginAllowThreads();
28360 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
28361 wxPyEndAllowThreads(__tstate);
28362 if (PyErr_Occurred()) SWIG_fail;
28363 }
28364 {
28365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28366 }
28367 return resultobj;
28368 fail:
28369 return NULL;
28370 }
28371
28372
28373 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28374 PyObject *resultobj = 0;
28375 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28376 bool result;
28377 void *argp1 = 0 ;
28378 int res1 = 0 ;
28379 PyObject *swig_obj[1] ;
28380
28381 if (!args) SWIG_fail;
28382 swig_obj[0] = args;
28383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28384 if (!SWIG_IsOK(res1)) {
28385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28386 }
28387 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28388 {
28389 PyThreadState* __tstate = wxPyBeginAllowThreads();
28390 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
28391 wxPyEndAllowThreads(__tstate);
28392 if (PyErr_Occurred()) SWIG_fail;
28393 }
28394 {
28395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28396 }
28397 return resultobj;
28398 fail:
28399 return NULL;
28400 }
28401
28402
28403 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28404 PyObject *resultobj = 0;
28405 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28406 wxString result;
28407 void *argp1 = 0 ;
28408 int res1 = 0 ;
28409 PyObject *swig_obj[1] ;
28410
28411 if (!args) SWIG_fail;
28412 swig_obj[0] = args;
28413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28414 if (!SWIG_IsOK(res1)) {
28415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28416 }
28417 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28418 {
28419 PyThreadState* __tstate = wxPyBeginAllowThreads();
28420 result = ((wxUpdateUIEvent const *)arg1)->GetText();
28421 wxPyEndAllowThreads(__tstate);
28422 if (PyErr_Occurred()) SWIG_fail;
28423 }
28424 {
28425 #if wxUSE_UNICODE
28426 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28427 #else
28428 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28429 #endif
28430 }
28431 return resultobj;
28432 fail:
28433 return NULL;
28434 }
28435
28436
28437 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28438 PyObject *resultobj = 0;
28439 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28440 bool result;
28441 void *argp1 = 0 ;
28442 int res1 = 0 ;
28443 PyObject *swig_obj[1] ;
28444
28445 if (!args) SWIG_fail;
28446 swig_obj[0] = args;
28447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28448 if (!SWIG_IsOK(res1)) {
28449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28450 }
28451 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28452 {
28453 PyThreadState* __tstate = wxPyBeginAllowThreads();
28454 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
28455 wxPyEndAllowThreads(__tstate);
28456 if (PyErr_Occurred()) SWIG_fail;
28457 }
28458 {
28459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28460 }
28461 return resultobj;
28462 fail:
28463 return NULL;
28464 }
28465
28466
28467 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28468 PyObject *resultobj = 0;
28469 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28470 bool result;
28471 void *argp1 = 0 ;
28472 int res1 = 0 ;
28473 PyObject *swig_obj[1] ;
28474
28475 if (!args) SWIG_fail;
28476 swig_obj[0] = args;
28477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28478 if (!SWIG_IsOK(res1)) {
28479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28480 }
28481 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28482 {
28483 PyThreadState* __tstate = wxPyBeginAllowThreads();
28484 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
28485 wxPyEndAllowThreads(__tstate);
28486 if (PyErr_Occurred()) SWIG_fail;
28487 }
28488 {
28489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28490 }
28491 return resultobj;
28492 fail:
28493 return NULL;
28494 }
28495
28496
28497 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28498 PyObject *resultobj = 0;
28499 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28500 bool result;
28501 void *argp1 = 0 ;
28502 int res1 = 0 ;
28503 PyObject *swig_obj[1] ;
28504
28505 if (!args) SWIG_fail;
28506 swig_obj[0] = args;
28507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28508 if (!SWIG_IsOK(res1)) {
28509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28510 }
28511 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28512 {
28513 PyThreadState* __tstate = wxPyBeginAllowThreads();
28514 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
28515 wxPyEndAllowThreads(__tstate);
28516 if (PyErr_Occurred()) SWIG_fail;
28517 }
28518 {
28519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28520 }
28521 return resultobj;
28522 fail:
28523 return NULL;
28524 }
28525
28526
28527 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28528 PyObject *resultobj = 0;
28529 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28530 bool result;
28531 void *argp1 = 0 ;
28532 int res1 = 0 ;
28533 PyObject *swig_obj[1] ;
28534
28535 if (!args) SWIG_fail;
28536 swig_obj[0] = args;
28537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28538 if (!SWIG_IsOK(res1)) {
28539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28540 }
28541 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28542 {
28543 PyThreadState* __tstate = wxPyBeginAllowThreads();
28544 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
28545 wxPyEndAllowThreads(__tstate);
28546 if (PyErr_Occurred()) SWIG_fail;
28547 }
28548 {
28549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28550 }
28551 return resultobj;
28552 fail:
28553 return NULL;
28554 }
28555
28556
28557 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28558 PyObject *resultobj = 0;
28559 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28560 bool arg2 ;
28561 void *argp1 = 0 ;
28562 int res1 = 0 ;
28563 bool val2 ;
28564 int ecode2 = 0 ;
28565 PyObject * obj0 = 0 ;
28566 PyObject * obj1 = 0 ;
28567 char * kwnames[] = {
28568 (char *) "self",(char *) "check", NULL
28569 };
28570
28571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
28572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28573 if (!SWIG_IsOK(res1)) {
28574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28575 }
28576 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28577 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28578 if (!SWIG_IsOK(ecode2)) {
28579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
28580 }
28581 arg2 = static_cast< bool >(val2);
28582 {
28583 PyThreadState* __tstate = wxPyBeginAllowThreads();
28584 (arg1)->Check(arg2);
28585 wxPyEndAllowThreads(__tstate);
28586 if (PyErr_Occurred()) SWIG_fail;
28587 }
28588 resultobj = SWIG_Py_Void();
28589 return resultobj;
28590 fail:
28591 return NULL;
28592 }
28593
28594
28595 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28596 PyObject *resultobj = 0;
28597 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28598 bool arg2 ;
28599 void *argp1 = 0 ;
28600 int res1 = 0 ;
28601 bool val2 ;
28602 int ecode2 = 0 ;
28603 PyObject * obj0 = 0 ;
28604 PyObject * obj1 = 0 ;
28605 char * kwnames[] = {
28606 (char *) "self",(char *) "enable", NULL
28607 };
28608
28609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
28610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28611 if (!SWIG_IsOK(res1)) {
28612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28613 }
28614 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28615 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28616 if (!SWIG_IsOK(ecode2)) {
28617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
28618 }
28619 arg2 = static_cast< bool >(val2);
28620 {
28621 PyThreadState* __tstate = wxPyBeginAllowThreads();
28622 (arg1)->Enable(arg2);
28623 wxPyEndAllowThreads(__tstate);
28624 if (PyErr_Occurred()) SWIG_fail;
28625 }
28626 resultobj = SWIG_Py_Void();
28627 return resultobj;
28628 fail:
28629 return NULL;
28630 }
28631
28632
28633 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28634 PyObject *resultobj = 0;
28635 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28636 bool arg2 ;
28637 void *argp1 = 0 ;
28638 int res1 = 0 ;
28639 bool val2 ;
28640 int ecode2 = 0 ;
28641 PyObject * obj0 = 0 ;
28642 PyObject * obj1 = 0 ;
28643 char * kwnames[] = {
28644 (char *) "self",(char *) "show", NULL
28645 };
28646
28647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
28648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28649 if (!SWIG_IsOK(res1)) {
28650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28651 }
28652 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28653 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28654 if (!SWIG_IsOK(ecode2)) {
28655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
28656 }
28657 arg2 = static_cast< bool >(val2);
28658 {
28659 PyThreadState* __tstate = wxPyBeginAllowThreads();
28660 (arg1)->Show(arg2);
28661 wxPyEndAllowThreads(__tstate);
28662 if (PyErr_Occurred()) SWIG_fail;
28663 }
28664 resultobj = SWIG_Py_Void();
28665 return resultobj;
28666 fail:
28667 return NULL;
28668 }
28669
28670
28671 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28672 PyObject *resultobj = 0;
28673 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28674 wxString *arg2 = 0 ;
28675 void *argp1 = 0 ;
28676 int res1 = 0 ;
28677 bool temp2 = false ;
28678 PyObject * obj0 = 0 ;
28679 PyObject * obj1 = 0 ;
28680 char * kwnames[] = {
28681 (char *) "self",(char *) "text", NULL
28682 };
28683
28684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
28685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28686 if (!SWIG_IsOK(res1)) {
28687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28688 }
28689 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28690 {
28691 arg2 = wxString_in_helper(obj1);
28692 if (arg2 == NULL) SWIG_fail;
28693 temp2 = true;
28694 }
28695 {
28696 PyThreadState* __tstate = wxPyBeginAllowThreads();
28697 (arg1)->SetText((wxString const &)*arg2);
28698 wxPyEndAllowThreads(__tstate);
28699 if (PyErr_Occurred()) SWIG_fail;
28700 }
28701 resultobj = SWIG_Py_Void();
28702 {
28703 if (temp2)
28704 delete arg2;
28705 }
28706 return resultobj;
28707 fail:
28708 {
28709 if (temp2)
28710 delete arg2;
28711 }
28712 return NULL;
28713 }
28714
28715
28716 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28717 PyObject *resultobj = 0;
28718 long arg1 ;
28719 long val1 ;
28720 int ecode1 = 0 ;
28721 PyObject * obj0 = 0 ;
28722 char * kwnames[] = {
28723 (char *) "updateInterval", NULL
28724 };
28725
28726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
28727 ecode1 = SWIG_AsVal_long(obj0, &val1);
28728 if (!SWIG_IsOK(ecode1)) {
28729 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
28730 }
28731 arg1 = static_cast< long >(val1);
28732 {
28733 PyThreadState* __tstate = wxPyBeginAllowThreads();
28734 wxUpdateUIEvent::SetUpdateInterval(arg1);
28735 wxPyEndAllowThreads(__tstate);
28736 if (PyErr_Occurred()) SWIG_fail;
28737 }
28738 resultobj = SWIG_Py_Void();
28739 return resultobj;
28740 fail:
28741 return NULL;
28742 }
28743
28744
28745 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28746 PyObject *resultobj = 0;
28747 long result;
28748
28749 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
28750 {
28751 PyThreadState* __tstate = wxPyBeginAllowThreads();
28752 result = (long)wxUpdateUIEvent::GetUpdateInterval();
28753 wxPyEndAllowThreads(__tstate);
28754 if (PyErr_Occurred()) SWIG_fail;
28755 }
28756 resultobj = SWIG_From_long(static_cast< long >(result));
28757 return resultobj;
28758 fail:
28759 return NULL;
28760 }
28761
28762
28763 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28764 PyObject *resultobj = 0;
28765 wxWindow *arg1 = (wxWindow *) 0 ;
28766 bool result;
28767 void *argp1 = 0 ;
28768 int res1 = 0 ;
28769 PyObject * obj0 = 0 ;
28770 char * kwnames[] = {
28771 (char *) "win", NULL
28772 };
28773
28774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
28775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28776 if (!SWIG_IsOK(res1)) {
28777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
28778 }
28779 arg1 = reinterpret_cast< wxWindow * >(argp1);
28780 {
28781 PyThreadState* __tstate = wxPyBeginAllowThreads();
28782 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
28783 wxPyEndAllowThreads(__tstate);
28784 if (PyErr_Occurred()) SWIG_fail;
28785 }
28786 {
28787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28788 }
28789 return resultobj;
28790 fail:
28791 return NULL;
28792 }
28793
28794
28795 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28796 PyObject *resultobj = 0;
28797
28798 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
28799 {
28800 PyThreadState* __tstate = wxPyBeginAllowThreads();
28801 wxUpdateUIEvent::ResetUpdateTime();
28802 wxPyEndAllowThreads(__tstate);
28803 if (PyErr_Occurred()) SWIG_fail;
28804 }
28805 resultobj = SWIG_Py_Void();
28806 return resultobj;
28807 fail:
28808 return NULL;
28809 }
28810
28811
28812 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28813 PyObject *resultobj = 0;
28814 wxUpdateUIMode arg1 ;
28815 int val1 ;
28816 int ecode1 = 0 ;
28817 PyObject * obj0 = 0 ;
28818 char * kwnames[] = {
28819 (char *) "mode", NULL
28820 };
28821
28822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
28823 ecode1 = SWIG_AsVal_int(obj0, &val1);
28824 if (!SWIG_IsOK(ecode1)) {
28825 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
28826 }
28827 arg1 = static_cast< wxUpdateUIMode >(val1);
28828 {
28829 PyThreadState* __tstate = wxPyBeginAllowThreads();
28830 wxUpdateUIEvent::SetMode(arg1);
28831 wxPyEndAllowThreads(__tstate);
28832 if (PyErr_Occurred()) SWIG_fail;
28833 }
28834 resultobj = SWIG_Py_Void();
28835 return resultobj;
28836 fail:
28837 return NULL;
28838 }
28839
28840
28841 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28842 PyObject *resultobj = 0;
28843 wxUpdateUIMode result;
28844
28845 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
28846 {
28847 PyThreadState* __tstate = wxPyBeginAllowThreads();
28848 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
28849 wxPyEndAllowThreads(__tstate);
28850 if (PyErr_Occurred()) SWIG_fail;
28851 }
28852 resultobj = SWIG_From_int(static_cast< int >(result));
28853 return resultobj;
28854 fail:
28855 return NULL;
28856 }
28857
28858
28859 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28860 PyObject *obj;
28861 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28862 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
28863 return SWIG_Py_Void();
28864 }
28865
28866 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28867 return SWIG_Python_InitShadowInstance(args);
28868 }
28869
28870 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28871 PyObject *resultobj = 0;
28872 wxSysColourChangedEvent *result = 0 ;
28873
28874 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
28875 {
28876 PyThreadState* __tstate = wxPyBeginAllowThreads();
28877 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
28878 wxPyEndAllowThreads(__tstate);
28879 if (PyErr_Occurred()) SWIG_fail;
28880 }
28881 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
28882 return resultobj;
28883 fail:
28884 return NULL;
28885 }
28886
28887
28888 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28889 PyObject *obj;
28890 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28891 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
28892 return SWIG_Py_Void();
28893 }
28894
28895 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28896 return SWIG_Python_InitShadowInstance(args);
28897 }
28898
28899 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28900 PyObject *resultobj = 0;
28901 int arg1 = (int) 0 ;
28902 wxWindow *arg2 = (wxWindow *) NULL ;
28903 wxMouseCaptureChangedEvent *result = 0 ;
28904 int val1 ;
28905 int ecode1 = 0 ;
28906 void *argp2 = 0 ;
28907 int res2 = 0 ;
28908 PyObject * obj0 = 0 ;
28909 PyObject * obj1 = 0 ;
28910 char * kwnames[] = {
28911 (char *) "winid",(char *) "gainedCapture", NULL
28912 };
28913
28914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28915 if (obj0) {
28916 ecode1 = SWIG_AsVal_int(obj0, &val1);
28917 if (!SWIG_IsOK(ecode1)) {
28918 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
28919 }
28920 arg1 = static_cast< int >(val1);
28921 }
28922 if (obj1) {
28923 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28924 if (!SWIG_IsOK(res2)) {
28925 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
28926 }
28927 arg2 = reinterpret_cast< wxWindow * >(argp2);
28928 }
28929 {
28930 PyThreadState* __tstate = wxPyBeginAllowThreads();
28931 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
28932 wxPyEndAllowThreads(__tstate);
28933 if (PyErr_Occurred()) SWIG_fail;
28934 }
28935 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
28936 return resultobj;
28937 fail:
28938 return NULL;
28939 }
28940
28941
28942 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28943 PyObject *resultobj = 0;
28944 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
28945 wxWindow *result = 0 ;
28946 void *argp1 = 0 ;
28947 int res1 = 0 ;
28948 PyObject *swig_obj[1] ;
28949
28950 if (!args) SWIG_fail;
28951 swig_obj[0] = args;
28952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
28953 if (!SWIG_IsOK(res1)) {
28954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
28955 }
28956 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
28957 {
28958 PyThreadState* __tstate = wxPyBeginAllowThreads();
28959 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
28960 wxPyEndAllowThreads(__tstate);
28961 if (PyErr_Occurred()) SWIG_fail;
28962 }
28963 {
28964 resultobj = wxPyMake_wxObject(result, (bool)0);
28965 }
28966 return resultobj;
28967 fail:
28968 return NULL;
28969 }
28970
28971
28972 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28973 PyObject *obj;
28974 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28975 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
28976 return SWIG_Py_Void();
28977 }
28978
28979 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28980 return SWIG_Python_InitShadowInstance(args);
28981 }
28982
28983 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28984 PyObject *resultobj = 0;
28985 int arg1 = (int) 0 ;
28986 wxMouseCaptureLostEvent *result = 0 ;
28987 int val1 ;
28988 int ecode1 = 0 ;
28989 PyObject * obj0 = 0 ;
28990 char * kwnames[] = {
28991 (char *) "winid", NULL
28992 };
28993
28994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
28995 if (obj0) {
28996 ecode1 = SWIG_AsVal_int(obj0, &val1);
28997 if (!SWIG_IsOK(ecode1)) {
28998 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
28999 }
29000 arg1 = static_cast< int >(val1);
29001 }
29002 {
29003 PyThreadState* __tstate = wxPyBeginAllowThreads();
29004 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
29005 wxPyEndAllowThreads(__tstate);
29006 if (PyErr_Occurred()) SWIG_fail;
29007 }
29008 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
29009 return resultobj;
29010 fail:
29011 return NULL;
29012 }
29013
29014
29015 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29016 PyObject *obj;
29017 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29018 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
29019 return SWIG_Py_Void();
29020 }
29021
29022 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29023 return SWIG_Python_InitShadowInstance(args);
29024 }
29025
29026 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29027 PyObject *resultobj = 0;
29028 wxDisplayChangedEvent *result = 0 ;
29029
29030 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
29031 {
29032 PyThreadState* __tstate = wxPyBeginAllowThreads();
29033 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
29034 wxPyEndAllowThreads(__tstate);
29035 if (PyErr_Occurred()) SWIG_fail;
29036 }
29037 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
29038 return resultobj;
29039 fail:
29040 return NULL;
29041 }
29042
29043
29044 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29045 PyObject *obj;
29046 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29047 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
29048 return SWIG_Py_Void();
29049 }
29050
29051 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29052 return SWIG_Python_InitShadowInstance(args);
29053 }
29054
29055 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29056 PyObject *resultobj = 0;
29057 int arg1 = (int) 0 ;
29058 wxPaletteChangedEvent *result = 0 ;
29059 int val1 ;
29060 int ecode1 = 0 ;
29061 PyObject * obj0 = 0 ;
29062 char * kwnames[] = {
29063 (char *) "id", NULL
29064 };
29065
29066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
29067 if (obj0) {
29068 ecode1 = SWIG_AsVal_int(obj0, &val1);
29069 if (!SWIG_IsOK(ecode1)) {
29070 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
29071 }
29072 arg1 = static_cast< int >(val1);
29073 }
29074 {
29075 PyThreadState* __tstate = wxPyBeginAllowThreads();
29076 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
29077 wxPyEndAllowThreads(__tstate);
29078 if (PyErr_Occurred()) SWIG_fail;
29079 }
29080 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
29081 return resultobj;
29082 fail:
29083 return NULL;
29084 }
29085
29086
29087 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29088 PyObject *resultobj = 0;
29089 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
29090 wxWindow *arg2 = (wxWindow *) 0 ;
29091 void *argp1 = 0 ;
29092 int res1 = 0 ;
29093 void *argp2 = 0 ;
29094 int res2 = 0 ;
29095 PyObject * obj0 = 0 ;
29096 PyObject * obj1 = 0 ;
29097 char * kwnames[] = {
29098 (char *) "self",(char *) "win", NULL
29099 };
29100
29101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
29102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
29103 if (!SWIG_IsOK(res1)) {
29104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
29105 }
29106 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
29107 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29108 if (!SWIG_IsOK(res2)) {
29109 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
29110 }
29111 arg2 = reinterpret_cast< wxWindow * >(argp2);
29112 {
29113 PyThreadState* __tstate = wxPyBeginAllowThreads();
29114 (arg1)->SetChangedWindow(arg2);
29115 wxPyEndAllowThreads(__tstate);
29116 if (PyErr_Occurred()) SWIG_fail;
29117 }
29118 resultobj = SWIG_Py_Void();
29119 return resultobj;
29120 fail:
29121 return NULL;
29122 }
29123
29124
29125 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29126 PyObject *resultobj = 0;
29127 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
29128 wxWindow *result = 0 ;
29129 void *argp1 = 0 ;
29130 int res1 = 0 ;
29131 PyObject *swig_obj[1] ;
29132
29133 if (!args) SWIG_fail;
29134 swig_obj[0] = args;
29135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
29136 if (!SWIG_IsOK(res1)) {
29137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
29138 }
29139 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
29140 {
29141 PyThreadState* __tstate = wxPyBeginAllowThreads();
29142 result = (wxWindow *)(arg1)->GetChangedWindow();
29143 wxPyEndAllowThreads(__tstate);
29144 if (PyErr_Occurred()) SWIG_fail;
29145 }
29146 {
29147 resultobj = wxPyMake_wxObject(result, (bool)0);
29148 }
29149 return resultobj;
29150 fail:
29151 return NULL;
29152 }
29153
29154
29155 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29156 PyObject *obj;
29157 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29158 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
29159 return SWIG_Py_Void();
29160 }
29161
29162 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29163 return SWIG_Python_InitShadowInstance(args);
29164 }
29165
29166 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29167 PyObject *resultobj = 0;
29168 int arg1 = (int) 0 ;
29169 wxQueryNewPaletteEvent *result = 0 ;
29170 int val1 ;
29171 int ecode1 = 0 ;
29172 PyObject * obj0 = 0 ;
29173 char * kwnames[] = {
29174 (char *) "winid", NULL
29175 };
29176
29177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
29178 if (obj0) {
29179 ecode1 = SWIG_AsVal_int(obj0, &val1);
29180 if (!SWIG_IsOK(ecode1)) {
29181 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
29182 }
29183 arg1 = static_cast< int >(val1);
29184 }
29185 {
29186 PyThreadState* __tstate = wxPyBeginAllowThreads();
29187 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
29188 wxPyEndAllowThreads(__tstate);
29189 if (PyErr_Occurred()) SWIG_fail;
29190 }
29191 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
29192 return resultobj;
29193 fail:
29194 return NULL;
29195 }
29196
29197
29198 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29199 PyObject *resultobj = 0;
29200 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
29201 bool arg2 ;
29202 void *argp1 = 0 ;
29203 int res1 = 0 ;
29204 bool val2 ;
29205 int ecode2 = 0 ;
29206 PyObject * obj0 = 0 ;
29207 PyObject * obj1 = 0 ;
29208 char * kwnames[] = {
29209 (char *) "self",(char *) "realized", NULL
29210 };
29211
29212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
29213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
29214 if (!SWIG_IsOK(res1)) {
29215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
29216 }
29217 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
29218 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29219 if (!SWIG_IsOK(ecode2)) {
29220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
29221 }
29222 arg2 = static_cast< bool >(val2);
29223 {
29224 PyThreadState* __tstate = wxPyBeginAllowThreads();
29225 (arg1)->SetPaletteRealized(arg2);
29226 wxPyEndAllowThreads(__tstate);
29227 if (PyErr_Occurred()) SWIG_fail;
29228 }
29229 resultobj = SWIG_Py_Void();
29230 return resultobj;
29231 fail:
29232 return NULL;
29233 }
29234
29235
29236 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29237 PyObject *resultobj = 0;
29238 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
29239 bool result;
29240 void *argp1 = 0 ;
29241 int res1 = 0 ;
29242 PyObject *swig_obj[1] ;
29243
29244 if (!args) SWIG_fail;
29245 swig_obj[0] = args;
29246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
29247 if (!SWIG_IsOK(res1)) {
29248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
29249 }
29250 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
29251 {
29252 PyThreadState* __tstate = wxPyBeginAllowThreads();
29253 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
29254 wxPyEndAllowThreads(__tstate);
29255 if (PyErr_Occurred()) SWIG_fail;
29256 }
29257 {
29258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29259 }
29260 return resultobj;
29261 fail:
29262 return NULL;
29263 }
29264
29265
29266 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29267 PyObject *obj;
29268 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29269 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
29270 return SWIG_Py_Void();
29271 }
29272
29273 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29274 return SWIG_Python_InitShadowInstance(args);
29275 }
29276
29277 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29278 PyObject *resultobj = 0;
29279 wxNavigationKeyEvent *result = 0 ;
29280
29281 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
29282 {
29283 PyThreadState* __tstate = wxPyBeginAllowThreads();
29284 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
29285 wxPyEndAllowThreads(__tstate);
29286 if (PyErr_Occurred()) SWIG_fail;
29287 }
29288 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
29289 return resultobj;
29290 fail:
29291 return NULL;
29292 }
29293
29294
29295 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29296 PyObject *resultobj = 0;
29297 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29298 bool result;
29299 void *argp1 = 0 ;
29300 int res1 = 0 ;
29301 PyObject *swig_obj[1] ;
29302
29303 if (!args) SWIG_fail;
29304 swig_obj[0] = args;
29305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29306 if (!SWIG_IsOK(res1)) {
29307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
29308 }
29309 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29310 {
29311 PyThreadState* __tstate = wxPyBeginAllowThreads();
29312 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
29313 wxPyEndAllowThreads(__tstate);
29314 if (PyErr_Occurred()) SWIG_fail;
29315 }
29316 {
29317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29318 }
29319 return resultobj;
29320 fail:
29321 return NULL;
29322 }
29323
29324
29325 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29326 PyObject *resultobj = 0;
29327 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29328 bool arg2 ;
29329 void *argp1 = 0 ;
29330 int res1 = 0 ;
29331 bool val2 ;
29332 int ecode2 = 0 ;
29333 PyObject * obj0 = 0 ;
29334 PyObject * obj1 = 0 ;
29335 char * kwnames[] = {
29336 (char *) "self",(char *) "forward", NULL
29337 };
29338
29339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
29340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29341 if (!SWIG_IsOK(res1)) {
29342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
29343 }
29344 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29345 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29346 if (!SWIG_IsOK(ecode2)) {
29347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
29348 }
29349 arg2 = static_cast< bool >(val2);
29350 {
29351 PyThreadState* __tstate = wxPyBeginAllowThreads();
29352 (arg1)->SetDirection(arg2);
29353 wxPyEndAllowThreads(__tstate);
29354 if (PyErr_Occurred()) SWIG_fail;
29355 }
29356 resultobj = SWIG_Py_Void();
29357 return resultobj;
29358 fail:
29359 return NULL;
29360 }
29361
29362
29363 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29364 PyObject *resultobj = 0;
29365 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29366 bool result;
29367 void *argp1 = 0 ;
29368 int res1 = 0 ;
29369 PyObject *swig_obj[1] ;
29370
29371 if (!args) SWIG_fail;
29372 swig_obj[0] = args;
29373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29374 if (!SWIG_IsOK(res1)) {
29375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
29376 }
29377 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29378 {
29379 PyThreadState* __tstate = wxPyBeginAllowThreads();
29380 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
29381 wxPyEndAllowThreads(__tstate);
29382 if (PyErr_Occurred()) SWIG_fail;
29383 }
29384 {
29385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29386 }
29387 return resultobj;
29388 fail:
29389 return NULL;
29390 }
29391
29392
29393 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29394 PyObject *resultobj = 0;
29395 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29396 bool arg2 ;
29397 void *argp1 = 0 ;
29398 int res1 = 0 ;
29399 bool val2 ;
29400 int ecode2 = 0 ;
29401 PyObject * obj0 = 0 ;
29402 PyObject * obj1 = 0 ;
29403 char * kwnames[] = {
29404 (char *) "self",(char *) "ischange", NULL
29405 };
29406
29407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
29408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29409 if (!SWIG_IsOK(res1)) {
29410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
29411 }
29412 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29413 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29414 if (!SWIG_IsOK(ecode2)) {
29415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
29416 }
29417 arg2 = static_cast< bool >(val2);
29418 {
29419 PyThreadState* __tstate = wxPyBeginAllowThreads();
29420 (arg1)->SetWindowChange(arg2);
29421 wxPyEndAllowThreads(__tstate);
29422 if (PyErr_Occurred()) SWIG_fail;
29423 }
29424 resultobj = SWIG_Py_Void();
29425 return resultobj;
29426 fail:
29427 return NULL;
29428 }
29429
29430
29431 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29432 PyObject *resultobj = 0;
29433 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29434 bool result;
29435 void *argp1 = 0 ;
29436 int res1 = 0 ;
29437 PyObject *swig_obj[1] ;
29438
29439 if (!args) SWIG_fail;
29440 swig_obj[0] = args;
29441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29442 if (!SWIG_IsOK(res1)) {
29443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
29444 }
29445 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29446 {
29447 PyThreadState* __tstate = wxPyBeginAllowThreads();
29448 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
29449 wxPyEndAllowThreads(__tstate);
29450 if (PyErr_Occurred()) SWIG_fail;
29451 }
29452 {
29453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29454 }
29455 return resultobj;
29456 fail:
29457 return NULL;
29458 }
29459
29460
29461 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29462 PyObject *resultobj = 0;
29463 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29464 bool arg2 ;
29465 void *argp1 = 0 ;
29466 int res1 = 0 ;
29467 bool val2 ;
29468 int ecode2 = 0 ;
29469 PyObject * obj0 = 0 ;
29470 PyObject * obj1 = 0 ;
29471 char * kwnames[] = {
29472 (char *) "self",(char *) "bIs", NULL
29473 };
29474
29475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
29476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29477 if (!SWIG_IsOK(res1)) {
29478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
29479 }
29480 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29481 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29482 if (!SWIG_IsOK(ecode2)) {
29483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
29484 }
29485 arg2 = static_cast< bool >(val2);
29486 {
29487 PyThreadState* __tstate = wxPyBeginAllowThreads();
29488 (arg1)->SetFromTab(arg2);
29489 wxPyEndAllowThreads(__tstate);
29490 if (PyErr_Occurred()) SWIG_fail;
29491 }
29492 resultobj = SWIG_Py_Void();
29493 return resultobj;
29494 fail:
29495 return NULL;
29496 }
29497
29498
29499 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29500 PyObject *resultobj = 0;
29501 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29502 long arg2 ;
29503 void *argp1 = 0 ;
29504 int res1 = 0 ;
29505 long val2 ;
29506 int ecode2 = 0 ;
29507 PyObject * obj0 = 0 ;
29508 PyObject * obj1 = 0 ;
29509 char * kwnames[] = {
29510 (char *) "self",(char *) "flags", NULL
29511 };
29512
29513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
29514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29515 if (!SWIG_IsOK(res1)) {
29516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
29517 }
29518 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29519 ecode2 = SWIG_AsVal_long(obj1, &val2);
29520 if (!SWIG_IsOK(ecode2)) {
29521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
29522 }
29523 arg2 = static_cast< long >(val2);
29524 {
29525 PyThreadState* __tstate = wxPyBeginAllowThreads();
29526 (arg1)->SetFlags(arg2);
29527 wxPyEndAllowThreads(__tstate);
29528 if (PyErr_Occurred()) SWIG_fail;
29529 }
29530 resultobj = SWIG_Py_Void();
29531 return resultobj;
29532 fail:
29533 return NULL;
29534 }
29535
29536
29537 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29538 PyObject *resultobj = 0;
29539 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29540 wxWindow *result = 0 ;
29541 void *argp1 = 0 ;
29542 int res1 = 0 ;
29543 PyObject *swig_obj[1] ;
29544
29545 if (!args) SWIG_fail;
29546 swig_obj[0] = args;
29547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29548 if (!SWIG_IsOK(res1)) {
29549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
29550 }
29551 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29552 {
29553 PyThreadState* __tstate = wxPyBeginAllowThreads();
29554 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
29555 wxPyEndAllowThreads(__tstate);
29556 if (PyErr_Occurred()) SWIG_fail;
29557 }
29558 {
29559 resultobj = wxPyMake_wxObject(result, (bool)0);
29560 }
29561 return resultobj;
29562 fail:
29563 return NULL;
29564 }
29565
29566
29567 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29568 PyObject *resultobj = 0;
29569 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29570 wxWindow *arg2 = (wxWindow *) 0 ;
29571 void *argp1 = 0 ;
29572 int res1 = 0 ;
29573 void *argp2 = 0 ;
29574 int res2 = 0 ;
29575 PyObject * obj0 = 0 ;
29576 PyObject * obj1 = 0 ;
29577 char * kwnames[] = {
29578 (char *) "self",(char *) "win", NULL
29579 };
29580
29581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
29582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29583 if (!SWIG_IsOK(res1)) {
29584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
29585 }
29586 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29587 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29588 if (!SWIG_IsOK(res2)) {
29589 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
29590 }
29591 arg2 = reinterpret_cast< wxWindow * >(argp2);
29592 {
29593 PyThreadState* __tstate = wxPyBeginAllowThreads();
29594 (arg1)->SetCurrentFocus(arg2);
29595 wxPyEndAllowThreads(__tstate);
29596 if (PyErr_Occurred()) SWIG_fail;
29597 }
29598 resultobj = SWIG_Py_Void();
29599 return resultobj;
29600 fail:
29601 return NULL;
29602 }
29603
29604
29605 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29606 PyObject *obj;
29607 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29608 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
29609 return SWIG_Py_Void();
29610 }
29611
29612 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29613 return SWIG_Python_InitShadowInstance(args);
29614 }
29615
29616 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29617 PyObject *resultobj = 0;
29618 wxWindow *arg1 = (wxWindow *) NULL ;
29619 wxWindowCreateEvent *result = 0 ;
29620 void *argp1 = 0 ;
29621 int res1 = 0 ;
29622 PyObject * obj0 = 0 ;
29623 char * kwnames[] = {
29624 (char *) "win", NULL
29625 };
29626
29627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
29628 if (obj0) {
29629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29630 if (!SWIG_IsOK(res1)) {
29631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29632 }
29633 arg1 = reinterpret_cast< wxWindow * >(argp1);
29634 }
29635 {
29636 PyThreadState* __tstate = wxPyBeginAllowThreads();
29637 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
29638 wxPyEndAllowThreads(__tstate);
29639 if (PyErr_Occurred()) SWIG_fail;
29640 }
29641 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
29642 return resultobj;
29643 fail:
29644 return NULL;
29645 }
29646
29647
29648 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29649 PyObject *resultobj = 0;
29650 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
29651 wxWindow *result = 0 ;
29652 void *argp1 = 0 ;
29653 int res1 = 0 ;
29654 PyObject *swig_obj[1] ;
29655
29656 if (!args) SWIG_fail;
29657 swig_obj[0] = args;
29658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
29659 if (!SWIG_IsOK(res1)) {
29660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
29661 }
29662 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
29663 {
29664 PyThreadState* __tstate = wxPyBeginAllowThreads();
29665 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
29666 wxPyEndAllowThreads(__tstate);
29667 if (PyErr_Occurred()) SWIG_fail;
29668 }
29669 {
29670 resultobj = wxPyMake_wxObject(result, (bool)0);
29671 }
29672 return resultobj;
29673 fail:
29674 return NULL;
29675 }
29676
29677
29678 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29679 PyObject *obj;
29680 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29681 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
29682 return SWIG_Py_Void();
29683 }
29684
29685 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29686 return SWIG_Python_InitShadowInstance(args);
29687 }
29688
29689 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29690 PyObject *resultobj = 0;
29691 wxWindow *arg1 = (wxWindow *) NULL ;
29692 wxWindowDestroyEvent *result = 0 ;
29693 void *argp1 = 0 ;
29694 int res1 = 0 ;
29695 PyObject * obj0 = 0 ;
29696 char * kwnames[] = {
29697 (char *) "win", NULL
29698 };
29699
29700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
29701 if (obj0) {
29702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29703 if (!SWIG_IsOK(res1)) {
29704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29705 }
29706 arg1 = reinterpret_cast< wxWindow * >(argp1);
29707 }
29708 {
29709 PyThreadState* __tstate = wxPyBeginAllowThreads();
29710 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
29711 wxPyEndAllowThreads(__tstate);
29712 if (PyErr_Occurred()) SWIG_fail;
29713 }
29714 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
29715 return resultobj;
29716 fail:
29717 return NULL;
29718 }
29719
29720
29721 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29722 PyObject *resultobj = 0;
29723 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
29724 wxWindow *result = 0 ;
29725 void *argp1 = 0 ;
29726 int res1 = 0 ;
29727 PyObject *swig_obj[1] ;
29728
29729 if (!args) SWIG_fail;
29730 swig_obj[0] = args;
29731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
29732 if (!SWIG_IsOK(res1)) {
29733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
29734 }
29735 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
29736 {
29737 PyThreadState* __tstate = wxPyBeginAllowThreads();
29738 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
29739 wxPyEndAllowThreads(__tstate);
29740 if (PyErr_Occurred()) SWIG_fail;
29741 }
29742 {
29743 resultobj = wxPyMake_wxObject(result, (bool)0);
29744 }
29745 return resultobj;
29746 fail:
29747 return NULL;
29748 }
29749
29750
29751 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29752 PyObject *obj;
29753 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29754 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
29755 return SWIG_Py_Void();
29756 }
29757
29758 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29759 return SWIG_Python_InitShadowInstance(args);
29760 }
29761
29762 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29763 PyObject *resultobj = 0;
29764 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29765 int arg2 = (int) 0 ;
29766 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29767 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29768 wxContextMenuEvent *result = 0 ;
29769 int val1 ;
29770 int ecode1 = 0 ;
29771 int val2 ;
29772 int ecode2 = 0 ;
29773 wxPoint temp3 ;
29774 PyObject * obj0 = 0 ;
29775 PyObject * obj1 = 0 ;
29776 PyObject * obj2 = 0 ;
29777 char * kwnames[] = {
29778 (char *) "type",(char *) "winid",(char *) "pt", NULL
29779 };
29780
29781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29782 if (obj0) {
29783 ecode1 = SWIG_AsVal_int(obj0, &val1);
29784 if (!SWIG_IsOK(ecode1)) {
29785 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29786 }
29787 arg1 = static_cast< wxEventType >(val1);
29788 }
29789 if (obj1) {
29790 ecode2 = SWIG_AsVal_int(obj1, &val2);
29791 if (!SWIG_IsOK(ecode2)) {
29792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
29793 }
29794 arg2 = static_cast< int >(val2);
29795 }
29796 if (obj2) {
29797 {
29798 arg3 = &temp3;
29799 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29800 }
29801 }
29802 {
29803 PyThreadState* __tstate = wxPyBeginAllowThreads();
29804 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
29805 wxPyEndAllowThreads(__tstate);
29806 if (PyErr_Occurred()) SWIG_fail;
29807 }
29808 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
29809 return resultobj;
29810 fail:
29811 return NULL;
29812 }
29813
29814
29815 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29816 PyObject *resultobj = 0;
29817 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29818 wxPoint *result = 0 ;
29819 void *argp1 = 0 ;
29820 int res1 = 0 ;
29821 PyObject *swig_obj[1] ;
29822
29823 if (!args) SWIG_fail;
29824 swig_obj[0] = args;
29825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29826 if (!SWIG_IsOK(res1)) {
29827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
29828 }
29829 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29830 {
29831 PyThreadState* __tstate = wxPyBeginAllowThreads();
29832 {
29833 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
29834 result = (wxPoint *) &_result_ref;
29835 }
29836 wxPyEndAllowThreads(__tstate);
29837 if (PyErr_Occurred()) SWIG_fail;
29838 }
29839 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
29840 return resultobj;
29841 fail:
29842 return NULL;
29843 }
29844
29845
29846 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29847 PyObject *resultobj = 0;
29848 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29849 wxPoint *arg2 = 0 ;
29850 void *argp1 = 0 ;
29851 int res1 = 0 ;
29852 wxPoint temp2 ;
29853 PyObject * obj0 = 0 ;
29854 PyObject * obj1 = 0 ;
29855 char * kwnames[] = {
29856 (char *) "self",(char *) "pos", NULL
29857 };
29858
29859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
29860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29861 if (!SWIG_IsOK(res1)) {
29862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
29863 }
29864 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29865 {
29866 arg2 = &temp2;
29867 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29868 }
29869 {
29870 PyThreadState* __tstate = wxPyBeginAllowThreads();
29871 (arg1)->SetPosition((wxPoint const &)*arg2);
29872 wxPyEndAllowThreads(__tstate);
29873 if (PyErr_Occurred()) SWIG_fail;
29874 }
29875 resultobj = SWIG_Py_Void();
29876 return resultobj;
29877 fail:
29878 return NULL;
29879 }
29880
29881
29882 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29883 PyObject *obj;
29884 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29885 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
29886 return SWIG_Py_Void();
29887 }
29888
29889 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29890 return SWIG_Python_InitShadowInstance(args);
29891 }
29892
29893 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29894 PyObject *resultobj = 0;
29895 wxIdleEvent *result = 0 ;
29896
29897 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
29898 {
29899 PyThreadState* __tstate = wxPyBeginAllowThreads();
29900 result = (wxIdleEvent *)new wxIdleEvent();
29901 wxPyEndAllowThreads(__tstate);
29902 if (PyErr_Occurred()) SWIG_fail;
29903 }
29904 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
29905 return resultobj;
29906 fail:
29907 return NULL;
29908 }
29909
29910
29911 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29912 PyObject *resultobj = 0;
29913 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29914 bool arg2 = (bool) true ;
29915 void *argp1 = 0 ;
29916 int res1 = 0 ;
29917 bool val2 ;
29918 int ecode2 = 0 ;
29919 PyObject * obj0 = 0 ;
29920 PyObject * obj1 = 0 ;
29921 char * kwnames[] = {
29922 (char *) "self",(char *) "needMore", NULL
29923 };
29924
29925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
29926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29927 if (!SWIG_IsOK(res1)) {
29928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
29929 }
29930 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29931 if (obj1) {
29932 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29933 if (!SWIG_IsOK(ecode2)) {
29934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
29935 }
29936 arg2 = static_cast< bool >(val2);
29937 }
29938 {
29939 PyThreadState* __tstate = wxPyBeginAllowThreads();
29940 (arg1)->RequestMore(arg2);
29941 wxPyEndAllowThreads(__tstate);
29942 if (PyErr_Occurred()) SWIG_fail;
29943 }
29944 resultobj = SWIG_Py_Void();
29945 return resultobj;
29946 fail:
29947 return NULL;
29948 }
29949
29950
29951 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29952 PyObject *resultobj = 0;
29953 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29954 bool result;
29955 void *argp1 = 0 ;
29956 int res1 = 0 ;
29957 PyObject *swig_obj[1] ;
29958
29959 if (!args) SWIG_fail;
29960 swig_obj[0] = args;
29961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29962 if (!SWIG_IsOK(res1)) {
29963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
29964 }
29965 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29966 {
29967 PyThreadState* __tstate = wxPyBeginAllowThreads();
29968 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
29969 wxPyEndAllowThreads(__tstate);
29970 if (PyErr_Occurred()) SWIG_fail;
29971 }
29972 {
29973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29974 }
29975 return resultobj;
29976 fail:
29977 return NULL;
29978 }
29979
29980
29981 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29982 PyObject *resultobj = 0;
29983 wxIdleMode arg1 ;
29984 int val1 ;
29985 int ecode1 = 0 ;
29986 PyObject * obj0 = 0 ;
29987 char * kwnames[] = {
29988 (char *) "mode", NULL
29989 };
29990
29991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
29992 ecode1 = SWIG_AsVal_int(obj0, &val1);
29993 if (!SWIG_IsOK(ecode1)) {
29994 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
29995 }
29996 arg1 = static_cast< wxIdleMode >(val1);
29997 {
29998 PyThreadState* __tstate = wxPyBeginAllowThreads();
29999 wxIdleEvent::SetMode(arg1);
30000 wxPyEndAllowThreads(__tstate);
30001 if (PyErr_Occurred()) SWIG_fail;
30002 }
30003 resultobj = SWIG_Py_Void();
30004 return resultobj;
30005 fail:
30006 return NULL;
30007 }
30008
30009
30010 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30011 PyObject *resultobj = 0;
30012 wxIdleMode result;
30013
30014 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
30015 {
30016 PyThreadState* __tstate = wxPyBeginAllowThreads();
30017 result = (wxIdleMode)wxIdleEvent::GetMode();
30018 wxPyEndAllowThreads(__tstate);
30019 if (PyErr_Occurred()) SWIG_fail;
30020 }
30021 resultobj = SWIG_From_int(static_cast< int >(result));
30022 return resultobj;
30023 fail:
30024 return NULL;
30025 }
30026
30027
30028 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30029 PyObject *resultobj = 0;
30030 wxWindow *arg1 = (wxWindow *) 0 ;
30031 bool result;
30032 void *argp1 = 0 ;
30033 int res1 = 0 ;
30034 PyObject * obj0 = 0 ;
30035 char * kwnames[] = {
30036 (char *) "win", NULL
30037 };
30038
30039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
30040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30041 if (!SWIG_IsOK(res1)) {
30042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
30043 }
30044 arg1 = reinterpret_cast< wxWindow * >(argp1);
30045 {
30046 PyThreadState* __tstate = wxPyBeginAllowThreads();
30047 result = (bool)wxIdleEvent::CanSend(arg1);
30048 wxPyEndAllowThreads(__tstate);
30049 if (PyErr_Occurred()) SWIG_fail;
30050 }
30051 {
30052 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30053 }
30054 return resultobj;
30055 fail:
30056 return NULL;
30057 }
30058
30059
30060 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30061 PyObject *obj;
30062 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30063 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
30064 return SWIG_Py_Void();
30065 }
30066
30067 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30068 return SWIG_Python_InitShadowInstance(args);
30069 }
30070
30071 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30072 PyObject *resultobj = 0;
30073 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
30074 int arg2 = (int) 0 ;
30075 wxClipboardTextEvent *result = 0 ;
30076 int val1 ;
30077 int ecode1 = 0 ;
30078 int val2 ;
30079 int ecode2 = 0 ;
30080 PyObject * obj0 = 0 ;
30081 PyObject * obj1 = 0 ;
30082 char * kwnames[] = {
30083 (char *) "type",(char *) "winid", NULL
30084 };
30085
30086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
30087 if (obj0) {
30088 ecode1 = SWIG_AsVal_int(obj0, &val1);
30089 if (!SWIG_IsOK(ecode1)) {
30090 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
30091 }
30092 arg1 = static_cast< wxEventType >(val1);
30093 }
30094 if (obj1) {
30095 ecode2 = SWIG_AsVal_int(obj1, &val2);
30096 if (!SWIG_IsOK(ecode2)) {
30097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
30098 }
30099 arg2 = static_cast< int >(val2);
30100 }
30101 {
30102 PyThreadState* __tstate = wxPyBeginAllowThreads();
30103 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
30104 wxPyEndAllowThreads(__tstate);
30105 if (PyErr_Occurred()) SWIG_fail;
30106 }
30107 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
30108 return resultobj;
30109 fail:
30110 return NULL;
30111 }
30112
30113
30114 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30115 PyObject *obj;
30116 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30117 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
30118 return SWIG_Py_Void();
30119 }
30120
30121 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30122 return SWIG_Python_InitShadowInstance(args);
30123 }
30124
30125 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30126 PyObject *resultobj = 0;
30127 int arg1 = (int) 0 ;
30128 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
30129 wxPyEvent *result = 0 ;
30130 int val1 ;
30131 int ecode1 = 0 ;
30132 int val2 ;
30133 int ecode2 = 0 ;
30134 PyObject * obj0 = 0 ;
30135 PyObject * obj1 = 0 ;
30136 char * kwnames[] = {
30137 (char *) "winid",(char *) "eventType", NULL
30138 };
30139
30140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
30141 if (obj0) {
30142 ecode1 = SWIG_AsVal_int(obj0, &val1);
30143 if (!SWIG_IsOK(ecode1)) {
30144 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
30145 }
30146 arg1 = static_cast< int >(val1);
30147 }
30148 if (obj1) {
30149 ecode2 = SWIG_AsVal_int(obj1, &val2);
30150 if (!SWIG_IsOK(ecode2)) {
30151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
30152 }
30153 arg2 = static_cast< wxEventType >(val2);
30154 }
30155 {
30156 PyThreadState* __tstate = wxPyBeginAllowThreads();
30157 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
30158 wxPyEndAllowThreads(__tstate);
30159 if (PyErr_Occurred()) SWIG_fail;
30160 }
30161 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
30162 return resultobj;
30163 fail:
30164 return NULL;
30165 }
30166
30167
30168 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30169 PyObject *resultobj = 0;
30170 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
30171 void *argp1 = 0 ;
30172 int res1 = 0 ;
30173 PyObject *swig_obj[1] ;
30174
30175 if (!args) SWIG_fail;
30176 swig_obj[0] = args;
30177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
30178 if (!SWIG_IsOK(res1)) {
30179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
30180 }
30181 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
30182 {
30183 PyThreadState* __tstate = wxPyBeginAllowThreads();
30184 delete arg1;
30185
30186 wxPyEndAllowThreads(__tstate);
30187 if (PyErr_Occurred()) SWIG_fail;
30188 }
30189 resultobj = SWIG_Py_Void();
30190 return resultobj;
30191 fail:
30192 return NULL;
30193 }
30194
30195
30196 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30197 PyObject *resultobj = 0;
30198 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
30199 PyObject *arg2 = (PyObject *) 0 ;
30200 void *argp1 = 0 ;
30201 int res1 = 0 ;
30202 PyObject * obj0 = 0 ;
30203 PyObject * obj1 = 0 ;
30204 char * kwnames[] = {
30205 (char *) "self",(char *) "self", NULL
30206 };
30207
30208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
30209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
30210 if (!SWIG_IsOK(res1)) {
30211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
30212 }
30213 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
30214 arg2 = obj1;
30215 {
30216 PyThreadState* __tstate = wxPyBeginAllowThreads();
30217 (arg1)->SetSelf(arg2);
30218 wxPyEndAllowThreads(__tstate);
30219 if (PyErr_Occurred()) SWIG_fail;
30220 }
30221 resultobj = SWIG_Py_Void();
30222 return resultobj;
30223 fail:
30224 return NULL;
30225 }
30226
30227
30228 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30229 PyObject *resultobj = 0;
30230 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
30231 PyObject *result = 0 ;
30232 void *argp1 = 0 ;
30233 int res1 = 0 ;
30234 PyObject *swig_obj[1] ;
30235
30236 if (!args) SWIG_fail;
30237 swig_obj[0] = args;
30238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
30239 if (!SWIG_IsOK(res1)) {
30240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
30241 }
30242 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
30243 {
30244 PyThreadState* __tstate = wxPyBeginAllowThreads();
30245 result = (PyObject *)(arg1)->GetSelf();
30246 wxPyEndAllowThreads(__tstate);
30247 if (PyErr_Occurred()) SWIG_fail;
30248 }
30249 resultobj = result;
30250 return resultobj;
30251 fail:
30252 return NULL;
30253 }
30254
30255
30256 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30257 PyObject *obj;
30258 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30259 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
30260 return SWIG_Py_Void();
30261 }
30262
30263 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30264 return SWIG_Python_InitShadowInstance(args);
30265 }
30266
30267 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30268 PyObject *resultobj = 0;
30269 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
30270 int arg2 = (int) 0 ;
30271 wxPyCommandEvent *result = 0 ;
30272 int val1 ;
30273 int ecode1 = 0 ;
30274 int val2 ;
30275 int ecode2 = 0 ;
30276 PyObject * obj0 = 0 ;
30277 PyObject * obj1 = 0 ;
30278 char * kwnames[] = {
30279 (char *) "eventType",(char *) "id", NULL
30280 };
30281
30282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
30283 if (obj0) {
30284 ecode1 = SWIG_AsVal_int(obj0, &val1);
30285 if (!SWIG_IsOK(ecode1)) {
30286 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
30287 }
30288 arg1 = static_cast< wxEventType >(val1);
30289 }
30290 if (obj1) {
30291 ecode2 = SWIG_AsVal_int(obj1, &val2);
30292 if (!SWIG_IsOK(ecode2)) {
30293 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
30294 }
30295 arg2 = static_cast< int >(val2);
30296 }
30297 {
30298 PyThreadState* __tstate = wxPyBeginAllowThreads();
30299 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
30300 wxPyEndAllowThreads(__tstate);
30301 if (PyErr_Occurred()) SWIG_fail;
30302 }
30303 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
30304 return resultobj;
30305 fail:
30306 return NULL;
30307 }
30308
30309
30310 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30311 PyObject *resultobj = 0;
30312 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
30313 void *argp1 = 0 ;
30314 int res1 = 0 ;
30315 PyObject *swig_obj[1] ;
30316
30317 if (!args) SWIG_fail;
30318 swig_obj[0] = args;
30319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
30320 if (!SWIG_IsOK(res1)) {
30321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
30322 }
30323 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
30324 {
30325 PyThreadState* __tstate = wxPyBeginAllowThreads();
30326 delete arg1;
30327
30328 wxPyEndAllowThreads(__tstate);
30329 if (PyErr_Occurred()) SWIG_fail;
30330 }
30331 resultobj = SWIG_Py_Void();
30332 return resultobj;
30333 fail:
30334 return NULL;
30335 }
30336
30337
30338 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30339 PyObject *resultobj = 0;
30340 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
30341 PyObject *arg2 = (PyObject *) 0 ;
30342 void *argp1 = 0 ;
30343 int res1 = 0 ;
30344 PyObject * obj0 = 0 ;
30345 PyObject * obj1 = 0 ;
30346 char * kwnames[] = {
30347 (char *) "self",(char *) "self", NULL
30348 };
30349
30350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
30351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
30352 if (!SWIG_IsOK(res1)) {
30353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
30354 }
30355 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
30356 arg2 = obj1;
30357 {
30358 PyThreadState* __tstate = wxPyBeginAllowThreads();
30359 (arg1)->SetSelf(arg2);
30360 wxPyEndAllowThreads(__tstate);
30361 if (PyErr_Occurred()) SWIG_fail;
30362 }
30363 resultobj = SWIG_Py_Void();
30364 return resultobj;
30365 fail:
30366 return NULL;
30367 }
30368
30369
30370 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30371 PyObject *resultobj = 0;
30372 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
30373 PyObject *result = 0 ;
30374 void *argp1 = 0 ;
30375 int res1 = 0 ;
30376 PyObject *swig_obj[1] ;
30377
30378 if (!args) SWIG_fail;
30379 swig_obj[0] = args;
30380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
30381 if (!SWIG_IsOK(res1)) {
30382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
30383 }
30384 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
30385 {
30386 PyThreadState* __tstate = wxPyBeginAllowThreads();
30387 result = (PyObject *)(arg1)->GetSelf();
30388 wxPyEndAllowThreads(__tstate);
30389 if (PyErr_Occurred()) SWIG_fail;
30390 }
30391 resultobj = result;
30392 return resultobj;
30393 fail:
30394 return NULL;
30395 }
30396
30397
30398 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30399 PyObject *obj;
30400 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30401 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
30402 return SWIG_Py_Void();
30403 }
30404
30405 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30406 return SWIG_Python_InitShadowInstance(args);
30407 }
30408
30409 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30410 PyObject *resultobj = 0;
30411 wxWindow *arg1 = (wxWindow *) 0 ;
30412 wxDateTime *arg2 = 0 ;
30413 wxEventType arg3 ;
30414 wxDateEvent *result = 0 ;
30415 void *argp1 = 0 ;
30416 int res1 = 0 ;
30417 void *argp2 = 0 ;
30418 int res2 = 0 ;
30419 int val3 ;
30420 int ecode3 = 0 ;
30421 PyObject * obj0 = 0 ;
30422 PyObject * obj1 = 0 ;
30423 PyObject * obj2 = 0 ;
30424 char * kwnames[] = {
30425 (char *) "win",(char *) "dt",(char *) "type", NULL
30426 };
30427
30428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30430 if (!SWIG_IsOK(res1)) {
30431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
30432 }
30433 arg1 = reinterpret_cast< wxWindow * >(argp1);
30434 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
30435 if (!SWIG_IsOK(res2)) {
30436 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
30437 }
30438 if (!argp2) {
30439 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
30440 }
30441 arg2 = reinterpret_cast< wxDateTime * >(argp2);
30442 ecode3 = SWIG_AsVal_int(obj2, &val3);
30443 if (!SWIG_IsOK(ecode3)) {
30444 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
30445 }
30446 arg3 = static_cast< wxEventType >(val3);
30447 {
30448 PyThreadState* __tstate = wxPyBeginAllowThreads();
30449 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
30450 wxPyEndAllowThreads(__tstate);
30451 if (PyErr_Occurred()) SWIG_fail;
30452 }
30453 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
30454 return resultobj;
30455 fail:
30456 return NULL;
30457 }
30458
30459
30460 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30461 PyObject *resultobj = 0;
30462 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
30463 wxDateTime *result = 0 ;
30464 void *argp1 = 0 ;
30465 int res1 = 0 ;
30466 PyObject *swig_obj[1] ;
30467
30468 if (!args) SWIG_fail;
30469 swig_obj[0] = args;
30470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
30471 if (!SWIG_IsOK(res1)) {
30472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
30473 }
30474 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
30475 {
30476 PyThreadState* __tstate = wxPyBeginAllowThreads();
30477 {
30478 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
30479 result = (wxDateTime *) &_result_ref;
30480 }
30481 wxPyEndAllowThreads(__tstate);
30482 if (PyErr_Occurred()) SWIG_fail;
30483 }
30484 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
30485 return resultobj;
30486 fail:
30487 return NULL;
30488 }
30489
30490
30491 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30492 PyObject *resultobj = 0;
30493 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
30494 wxDateTime *arg2 = 0 ;
30495 void *argp1 = 0 ;
30496 int res1 = 0 ;
30497 void *argp2 = 0 ;
30498 int res2 = 0 ;
30499 PyObject * obj0 = 0 ;
30500 PyObject * obj1 = 0 ;
30501 char * kwnames[] = {
30502 (char *) "self",(char *) "date", NULL
30503 };
30504
30505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
30506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
30507 if (!SWIG_IsOK(res1)) {
30508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
30509 }
30510 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
30511 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
30512 if (!SWIG_IsOK(res2)) {
30513 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
30514 }
30515 if (!argp2) {
30516 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
30517 }
30518 arg2 = reinterpret_cast< wxDateTime * >(argp2);
30519 {
30520 PyThreadState* __tstate = wxPyBeginAllowThreads();
30521 (arg1)->SetDate((wxDateTime const &)*arg2);
30522 wxPyEndAllowThreads(__tstate);
30523 if (PyErr_Occurred()) SWIG_fail;
30524 }
30525 resultobj = SWIG_Py_Void();
30526 return resultobj;
30527 fail:
30528 return NULL;
30529 }
30530
30531
30532 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30533 PyObject *obj;
30534 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30535 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
30536 return SWIG_Py_Void();
30537 }
30538
30539 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30540 return SWIG_Python_InitShadowInstance(args);
30541 }
30542
30543 SWIGINTERN PyObject *_wrap_new_EventBlocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30544 PyObject *resultobj = 0;
30545 wxWindow *arg1 = (wxWindow *) 0 ;
30546 wxEventType arg2 = (wxEventType) wxEVT_ANY ;
30547 wxEventBlocker *result = 0 ;
30548 void *argp1 = 0 ;
30549 int res1 = 0 ;
30550 int val2 ;
30551 int ecode2 = 0 ;
30552 PyObject * obj0 = 0 ;
30553 PyObject * obj1 = 0 ;
30554 char * kwnames[] = {
30555 (char *) "win",(char *) "type", NULL
30556 };
30557
30558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_EventBlocker",kwnames,&obj0,&obj1)) SWIG_fail;
30559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30560 if (!SWIG_IsOK(res1)) {
30561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventBlocker" "', expected argument " "1"" of type '" "wxWindow *""'");
30562 }
30563 arg1 = reinterpret_cast< wxWindow * >(argp1);
30564 if (obj1) {
30565 ecode2 = SWIG_AsVal_int(obj1, &val2);
30566 if (!SWIG_IsOK(ecode2)) {
30567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EventBlocker" "', expected argument " "2"" of type '" "wxEventType""'");
30568 }
30569 arg2 = static_cast< wxEventType >(val2);
30570 }
30571 {
30572 PyThreadState* __tstate = wxPyBeginAllowThreads();
30573 result = (wxEventBlocker *)new wxEventBlocker(arg1,arg2);
30574 wxPyEndAllowThreads(__tstate);
30575 if (PyErr_Occurred()) SWIG_fail;
30576 }
30577 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventBlocker, SWIG_POINTER_NEW | 0 );
30578 return resultobj;
30579 fail:
30580 return NULL;
30581 }
30582
30583
30584 SWIGINTERN PyObject *_wrap_delete_EventBlocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30585 PyObject *resultobj = 0;
30586 wxEventBlocker *arg1 = (wxEventBlocker *) 0 ;
30587 void *argp1 = 0 ;
30588 int res1 = 0 ;
30589 PyObject *swig_obj[1] ;
30590
30591 if (!args) SWIG_fail;
30592 swig_obj[0] = args;
30593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventBlocker, SWIG_POINTER_DISOWN | 0 );
30594 if (!SWIG_IsOK(res1)) {
30595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventBlocker" "', expected argument " "1"" of type '" "wxEventBlocker *""'");
30596 }
30597 arg1 = reinterpret_cast< wxEventBlocker * >(argp1);
30598 {
30599 PyThreadState* __tstate = wxPyBeginAllowThreads();
30600 delete arg1;
30601
30602 wxPyEndAllowThreads(__tstate);
30603 if (PyErr_Occurred()) SWIG_fail;
30604 }
30605 resultobj = SWIG_Py_Void();
30606 return resultobj;
30607 fail:
30608 return NULL;
30609 }
30610
30611
30612 SWIGINTERN PyObject *_wrap_EventBlocker_Block(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30613 PyObject *resultobj = 0;
30614 wxEventBlocker *arg1 = (wxEventBlocker *) 0 ;
30615 wxEventType arg2 ;
30616 void *argp1 = 0 ;
30617 int res1 = 0 ;
30618 int val2 ;
30619 int ecode2 = 0 ;
30620 PyObject * obj0 = 0 ;
30621 PyObject * obj1 = 0 ;
30622 char * kwnames[] = {
30623 (char *) "self",(char *) "type", NULL
30624 };
30625
30626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EventBlocker_Block",kwnames,&obj0,&obj1)) SWIG_fail;
30627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventBlocker, 0 | 0 );
30628 if (!SWIG_IsOK(res1)) {
30629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventBlocker_Block" "', expected argument " "1"" of type '" "wxEventBlocker *""'");
30630 }
30631 arg1 = reinterpret_cast< wxEventBlocker * >(argp1);
30632 ecode2 = SWIG_AsVal_int(obj1, &val2);
30633 if (!SWIG_IsOK(ecode2)) {
30634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventBlocker_Block" "', expected argument " "2"" of type '" "wxEventType""'");
30635 }
30636 arg2 = static_cast< wxEventType >(val2);
30637 {
30638 PyThreadState* __tstate = wxPyBeginAllowThreads();
30639 (arg1)->Block(arg2);
30640 wxPyEndAllowThreads(__tstate);
30641 if (PyErr_Occurred()) SWIG_fail;
30642 }
30643 resultobj = SWIG_Py_Void();
30644 return resultobj;
30645 fail:
30646 return NULL;
30647 }
30648
30649
30650 SWIGINTERN PyObject *EventBlocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30651 PyObject *obj;
30652 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30653 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventBlocker, SWIG_NewClientData(obj));
30654 return SWIG_Py_Void();
30655 }
30656
30657 SWIGINTERN PyObject *EventBlocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30658 return SWIG_Python_InitShadowInstance(args);
30659 }
30660
30661 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30662 PyObject *resultobj = 0;
30663 wxPyApp *result = 0 ;
30664
30665 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
30666 {
30667 PyThreadState* __tstate = wxPyBeginAllowThreads();
30668 result = (wxPyApp *)new_wxPyApp();
30669 wxPyEndAllowThreads(__tstate);
30670 if (PyErr_Occurred()) SWIG_fail;
30671 }
30672 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
30673 return resultobj;
30674 fail:
30675 return NULL;
30676 }
30677
30678
30679 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30680 PyObject *resultobj = 0;
30681 wxPyApp *arg1 = (wxPyApp *) 0 ;
30682 void *argp1 = 0 ;
30683 int res1 = 0 ;
30684 PyObject *swig_obj[1] ;
30685
30686 if (!args) SWIG_fail;
30687 swig_obj[0] = args;
30688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
30689 if (!SWIG_IsOK(res1)) {
30690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
30691 }
30692 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30693 {
30694 PyThreadState* __tstate = wxPyBeginAllowThreads();
30695 delete arg1;
30696
30697 wxPyEndAllowThreads(__tstate);
30698 if (PyErr_Occurred()) SWIG_fail;
30699 }
30700 resultobj = SWIG_Py_Void();
30701 return resultobj;
30702 fail:
30703 return NULL;
30704 }
30705
30706
30707 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30708 PyObject *resultobj = 0;
30709 wxPyApp *arg1 = (wxPyApp *) 0 ;
30710 PyObject *arg2 = (PyObject *) 0 ;
30711 PyObject *arg3 = (PyObject *) 0 ;
30712 bool arg4 = (bool) false ;
30713 void *argp1 = 0 ;
30714 int res1 = 0 ;
30715 bool val4 ;
30716 int ecode4 = 0 ;
30717 PyObject * obj0 = 0 ;
30718 PyObject * obj1 = 0 ;
30719 PyObject * obj2 = 0 ;
30720 PyObject * obj3 = 0 ;
30721 char * kwnames[] = {
30722 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
30723 };
30724
30725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30727 if (!SWIG_IsOK(res1)) {
30728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
30729 }
30730 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30731 arg2 = obj1;
30732 arg3 = obj2;
30733 if (obj3) {
30734 ecode4 = SWIG_AsVal_bool(obj3, &val4);
30735 if (!SWIG_IsOK(ecode4)) {
30736 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
30737 }
30738 arg4 = static_cast< bool >(val4);
30739 }
30740 {
30741 PyThreadState* __tstate = wxPyBeginAllowThreads();
30742 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
30743 wxPyEndAllowThreads(__tstate);
30744 if (PyErr_Occurred()) SWIG_fail;
30745 }
30746 resultobj = SWIG_Py_Void();
30747 return resultobj;
30748 fail:
30749 return NULL;
30750 }
30751
30752
30753 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30754 PyObject *resultobj = 0;
30755 wxPyApp *arg1 = (wxPyApp *) 0 ;
30756 wxString result;
30757 void *argp1 = 0 ;
30758 int res1 = 0 ;
30759 PyObject *swig_obj[1] ;
30760
30761 if (!args) SWIG_fail;
30762 swig_obj[0] = args;
30763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30764 if (!SWIG_IsOK(res1)) {
30765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30766 }
30767 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30768 {
30769 PyThreadState* __tstate = wxPyBeginAllowThreads();
30770 result = ((wxPyApp const *)arg1)->GetAppName();
30771 wxPyEndAllowThreads(__tstate);
30772 if (PyErr_Occurred()) SWIG_fail;
30773 }
30774 {
30775 #if wxUSE_UNICODE
30776 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30777 #else
30778 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30779 #endif
30780 }
30781 return resultobj;
30782 fail:
30783 return NULL;
30784 }
30785
30786
30787 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30788 PyObject *resultobj = 0;
30789 wxPyApp *arg1 = (wxPyApp *) 0 ;
30790 wxString *arg2 = 0 ;
30791 void *argp1 = 0 ;
30792 int res1 = 0 ;
30793 bool temp2 = false ;
30794 PyObject * obj0 = 0 ;
30795 PyObject * obj1 = 0 ;
30796 char * kwnames[] = {
30797 (char *) "self",(char *) "name", NULL
30798 };
30799
30800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
30801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30802 if (!SWIG_IsOK(res1)) {
30803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30804 }
30805 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30806 {
30807 arg2 = wxString_in_helper(obj1);
30808 if (arg2 == NULL) SWIG_fail;
30809 temp2 = true;
30810 }
30811 {
30812 PyThreadState* __tstate = wxPyBeginAllowThreads();
30813 (arg1)->SetAppName((wxString const &)*arg2);
30814 wxPyEndAllowThreads(__tstate);
30815 if (PyErr_Occurred()) SWIG_fail;
30816 }
30817 resultobj = SWIG_Py_Void();
30818 {
30819 if (temp2)
30820 delete arg2;
30821 }
30822 return resultobj;
30823 fail:
30824 {
30825 if (temp2)
30826 delete arg2;
30827 }
30828 return NULL;
30829 }
30830
30831
30832 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30833 PyObject *resultobj = 0;
30834 wxPyApp *arg1 = (wxPyApp *) 0 ;
30835 wxString result;
30836 void *argp1 = 0 ;
30837 int res1 = 0 ;
30838 PyObject *swig_obj[1] ;
30839
30840 if (!args) SWIG_fail;
30841 swig_obj[0] = args;
30842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30843 if (!SWIG_IsOK(res1)) {
30844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30845 }
30846 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30847 {
30848 PyThreadState* __tstate = wxPyBeginAllowThreads();
30849 result = ((wxPyApp const *)arg1)->GetClassName();
30850 wxPyEndAllowThreads(__tstate);
30851 if (PyErr_Occurred()) SWIG_fail;
30852 }
30853 {
30854 #if wxUSE_UNICODE
30855 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30856 #else
30857 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30858 #endif
30859 }
30860 return resultobj;
30861 fail:
30862 return NULL;
30863 }
30864
30865
30866 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30867 PyObject *resultobj = 0;
30868 wxPyApp *arg1 = (wxPyApp *) 0 ;
30869 wxString *arg2 = 0 ;
30870 void *argp1 = 0 ;
30871 int res1 = 0 ;
30872 bool temp2 = false ;
30873 PyObject * obj0 = 0 ;
30874 PyObject * obj1 = 0 ;
30875 char * kwnames[] = {
30876 (char *) "self",(char *) "name", NULL
30877 };
30878
30879 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
30880 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30881 if (!SWIG_IsOK(res1)) {
30882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30883 }
30884 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30885 {
30886 arg2 = wxString_in_helper(obj1);
30887 if (arg2 == NULL) SWIG_fail;
30888 temp2 = true;
30889 }
30890 {
30891 PyThreadState* __tstate = wxPyBeginAllowThreads();
30892 (arg1)->SetClassName((wxString const &)*arg2);
30893 wxPyEndAllowThreads(__tstate);
30894 if (PyErr_Occurred()) SWIG_fail;
30895 }
30896 resultobj = SWIG_Py_Void();
30897 {
30898 if (temp2)
30899 delete arg2;
30900 }
30901 return resultobj;
30902 fail:
30903 {
30904 if (temp2)
30905 delete arg2;
30906 }
30907 return NULL;
30908 }
30909
30910
30911 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30912 PyObject *resultobj = 0;
30913 wxPyApp *arg1 = (wxPyApp *) 0 ;
30914 wxString *result = 0 ;
30915 void *argp1 = 0 ;
30916 int res1 = 0 ;
30917 PyObject *swig_obj[1] ;
30918
30919 if (!args) SWIG_fail;
30920 swig_obj[0] = args;
30921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30922 if (!SWIG_IsOK(res1)) {
30923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30924 }
30925 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30926 {
30927 PyThreadState* __tstate = wxPyBeginAllowThreads();
30928 {
30929 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
30930 result = (wxString *) &_result_ref;
30931 }
30932 wxPyEndAllowThreads(__tstate);
30933 if (PyErr_Occurred()) SWIG_fail;
30934 }
30935 {
30936 #if wxUSE_UNICODE
30937 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
30938 #else
30939 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
30940 #endif
30941 }
30942 return resultobj;
30943 fail:
30944 return NULL;
30945 }
30946
30947
30948 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30949 PyObject *resultobj = 0;
30950 wxPyApp *arg1 = (wxPyApp *) 0 ;
30951 wxString *arg2 = 0 ;
30952 void *argp1 = 0 ;
30953 int res1 = 0 ;
30954 bool temp2 = false ;
30955 PyObject * obj0 = 0 ;
30956 PyObject * obj1 = 0 ;
30957 char * kwnames[] = {
30958 (char *) "self",(char *) "name", NULL
30959 };
30960
30961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
30962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30963 if (!SWIG_IsOK(res1)) {
30964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30965 }
30966 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30967 {
30968 arg2 = wxString_in_helper(obj1);
30969 if (arg2 == NULL) SWIG_fail;
30970 temp2 = true;
30971 }
30972 {
30973 PyThreadState* __tstate = wxPyBeginAllowThreads();
30974 (arg1)->SetVendorName((wxString const &)*arg2);
30975 wxPyEndAllowThreads(__tstate);
30976 if (PyErr_Occurred()) SWIG_fail;
30977 }
30978 resultobj = SWIG_Py_Void();
30979 {
30980 if (temp2)
30981 delete arg2;
30982 }
30983 return resultobj;
30984 fail:
30985 {
30986 if (temp2)
30987 delete arg2;
30988 }
30989 return NULL;
30990 }
30991
30992
30993 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30994 PyObject *resultobj = 0;
30995 wxPyApp *arg1 = (wxPyApp *) 0 ;
30996 wxAppTraits *result = 0 ;
30997 void *argp1 = 0 ;
30998 int res1 = 0 ;
30999 PyObject *swig_obj[1] ;
31000
31001 if (!args) SWIG_fail;
31002 swig_obj[0] = args;
31003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31004 if (!SWIG_IsOK(res1)) {
31005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
31006 }
31007 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31008 {
31009 PyThreadState* __tstate = wxPyBeginAllowThreads();
31010 result = (wxAppTraits *)(arg1)->GetTraits();
31011 wxPyEndAllowThreads(__tstate);
31012 if (PyErr_Occurred()) SWIG_fail;
31013 }
31014 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
31015 return resultobj;
31016 fail:
31017 return NULL;
31018 }
31019
31020
31021 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31022 PyObject *resultobj = 0;
31023 wxPyApp *arg1 = (wxPyApp *) 0 ;
31024 void *argp1 = 0 ;
31025 int res1 = 0 ;
31026 PyObject *swig_obj[1] ;
31027
31028 if (!args) SWIG_fail;
31029 swig_obj[0] = args;
31030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31031 if (!SWIG_IsOK(res1)) {
31032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
31033 }
31034 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31035 {
31036 PyThreadState* __tstate = wxPyBeginAllowThreads();
31037 (arg1)->ProcessPendingEvents();
31038 wxPyEndAllowThreads(__tstate);
31039 if (PyErr_Occurred()) SWIG_fail;
31040 }
31041 resultobj = SWIG_Py_Void();
31042 return resultobj;
31043 fail:
31044 return NULL;
31045 }
31046
31047
31048 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31049 PyObject *resultobj = 0;
31050 wxPyApp *arg1 = (wxPyApp *) 0 ;
31051 bool arg2 = (bool) false ;
31052 bool result;
31053 void *argp1 = 0 ;
31054 int res1 = 0 ;
31055 bool val2 ;
31056 int ecode2 = 0 ;
31057 PyObject * obj0 = 0 ;
31058 PyObject * obj1 = 0 ;
31059 char * kwnames[] = {
31060 (char *) "self",(char *) "onlyIfNeeded", NULL
31061 };
31062
31063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
31064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31065 if (!SWIG_IsOK(res1)) {
31066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
31067 }
31068 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31069 if (obj1) {
31070 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31071 if (!SWIG_IsOK(ecode2)) {
31072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
31073 }
31074 arg2 = static_cast< bool >(val2);
31075 }
31076 {
31077 PyThreadState* __tstate = wxPyBeginAllowThreads();
31078 result = (bool)(arg1)->Yield(arg2);
31079 wxPyEndAllowThreads(__tstate);
31080 if (PyErr_Occurred()) SWIG_fail;
31081 }
31082 {
31083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31084 }
31085 return resultobj;
31086 fail:
31087 return NULL;
31088 }
31089
31090
31091 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31092 PyObject *resultobj = 0;
31093 wxPyApp *arg1 = (wxPyApp *) 0 ;
31094 void *argp1 = 0 ;
31095 int res1 = 0 ;
31096 PyObject *swig_obj[1] ;
31097
31098 if (!args) SWIG_fail;
31099 swig_obj[0] = args;
31100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31101 if (!SWIG_IsOK(res1)) {
31102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
31103 }
31104 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31105 {
31106 PyThreadState* __tstate = wxPyBeginAllowThreads();
31107 (arg1)->WakeUpIdle();
31108 wxPyEndAllowThreads(__tstate);
31109 if (PyErr_Occurred()) SWIG_fail;
31110 }
31111 resultobj = SWIG_Py_Void();
31112 return resultobj;
31113 fail:
31114 return NULL;
31115 }
31116
31117
31118 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31119 PyObject *resultobj = 0;
31120 bool result;
31121
31122 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
31123 {
31124 PyThreadState* __tstate = wxPyBeginAllowThreads();
31125 result = (bool)wxPyApp::IsMainLoopRunning();
31126 wxPyEndAllowThreads(__tstate);
31127 if (PyErr_Occurred()) SWIG_fail;
31128 }
31129 {
31130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31131 }
31132 return resultobj;
31133 fail:
31134 return NULL;
31135 }
31136
31137
31138 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31139 PyObject *resultobj = 0;
31140 wxPyApp *arg1 = (wxPyApp *) 0 ;
31141 int result;
31142 void *argp1 = 0 ;
31143 int res1 = 0 ;
31144 PyObject *swig_obj[1] ;
31145
31146 if (!args) SWIG_fail;
31147 swig_obj[0] = args;
31148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31149 if (!SWIG_IsOK(res1)) {
31150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
31151 }
31152 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31153 {
31154 PyThreadState* __tstate = wxPyBeginAllowThreads();
31155 result = (int)(arg1)->MainLoop();
31156 wxPyEndAllowThreads(__tstate);
31157 if (PyErr_Occurred()) SWIG_fail;
31158 }
31159 resultobj = SWIG_From_int(static_cast< int >(result));
31160 return resultobj;
31161 fail:
31162 return NULL;
31163 }
31164
31165
31166 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31167 PyObject *resultobj = 0;
31168 wxPyApp *arg1 = (wxPyApp *) 0 ;
31169 void *argp1 = 0 ;
31170 int res1 = 0 ;
31171 PyObject *swig_obj[1] ;
31172
31173 if (!args) SWIG_fail;
31174 swig_obj[0] = args;
31175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31176 if (!SWIG_IsOK(res1)) {
31177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
31178 }
31179 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31180 {
31181 PyThreadState* __tstate = wxPyBeginAllowThreads();
31182 (arg1)->Exit();
31183 wxPyEndAllowThreads(__tstate);
31184 if (PyErr_Occurred()) SWIG_fail;
31185 }
31186 resultobj = SWIG_Py_Void();
31187 return resultobj;
31188 fail:
31189 return NULL;
31190 }
31191
31192
31193 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31194 PyObject *resultobj = 0;
31195 wxPyApp *arg1 = (wxPyApp *) 0 ;
31196 wxLayoutDirection result;
31197 void *argp1 = 0 ;
31198 int res1 = 0 ;
31199 PyObject *swig_obj[1] ;
31200
31201 if (!args) SWIG_fail;
31202 swig_obj[0] = args;
31203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31204 if (!SWIG_IsOK(res1)) {
31205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31206 }
31207 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31208 {
31209 PyThreadState* __tstate = wxPyBeginAllowThreads();
31210 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
31211 wxPyEndAllowThreads(__tstate);
31212 if (PyErr_Occurred()) SWIG_fail;
31213 }
31214 resultobj = SWIG_From_int(static_cast< int >(result));
31215 return resultobj;
31216 fail:
31217 return NULL;
31218 }
31219
31220
31221 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31222 PyObject *resultobj = 0;
31223 wxPyApp *arg1 = (wxPyApp *) 0 ;
31224 void *argp1 = 0 ;
31225 int res1 = 0 ;
31226 PyObject *swig_obj[1] ;
31227
31228 if (!args) SWIG_fail;
31229 swig_obj[0] = args;
31230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31231 if (!SWIG_IsOK(res1)) {
31232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
31233 }
31234 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31235 {
31236 PyThreadState* __tstate = wxPyBeginAllowThreads();
31237 (arg1)->ExitMainLoop();
31238 wxPyEndAllowThreads(__tstate);
31239 if (PyErr_Occurred()) SWIG_fail;
31240 }
31241 resultobj = SWIG_Py_Void();
31242 return resultobj;
31243 fail:
31244 return NULL;
31245 }
31246
31247
31248 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31249 PyObject *resultobj = 0;
31250 wxPyApp *arg1 = (wxPyApp *) 0 ;
31251 bool result;
31252 void *argp1 = 0 ;
31253 int res1 = 0 ;
31254 PyObject *swig_obj[1] ;
31255
31256 if (!args) SWIG_fail;
31257 swig_obj[0] = args;
31258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31259 if (!SWIG_IsOK(res1)) {
31260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
31261 }
31262 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31263 {
31264 PyThreadState* __tstate = wxPyBeginAllowThreads();
31265 result = (bool)(arg1)->Pending();
31266 wxPyEndAllowThreads(__tstate);
31267 if (PyErr_Occurred()) SWIG_fail;
31268 }
31269 {
31270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31271 }
31272 return resultobj;
31273 fail:
31274 return NULL;
31275 }
31276
31277
31278 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31279 PyObject *resultobj = 0;
31280 wxPyApp *arg1 = (wxPyApp *) 0 ;
31281 bool result;
31282 void *argp1 = 0 ;
31283 int res1 = 0 ;
31284 PyObject *swig_obj[1] ;
31285
31286 if (!args) SWIG_fail;
31287 swig_obj[0] = args;
31288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31289 if (!SWIG_IsOK(res1)) {
31290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
31291 }
31292 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31293 {
31294 PyThreadState* __tstate = wxPyBeginAllowThreads();
31295 result = (bool)(arg1)->Dispatch();
31296 wxPyEndAllowThreads(__tstate);
31297 if (PyErr_Occurred()) SWIG_fail;
31298 }
31299 {
31300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31301 }
31302 return resultobj;
31303 fail:
31304 return NULL;
31305 }
31306
31307
31308 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31309 PyObject *resultobj = 0;
31310 wxPyApp *arg1 = (wxPyApp *) 0 ;
31311 bool result;
31312 void *argp1 = 0 ;
31313 int res1 = 0 ;
31314 PyObject *swig_obj[1] ;
31315
31316 if (!args) SWIG_fail;
31317 swig_obj[0] = args;
31318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31319 if (!SWIG_IsOK(res1)) {
31320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
31321 }
31322 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31323 {
31324 PyThreadState* __tstate = wxPyBeginAllowThreads();
31325 result = (bool)(arg1)->ProcessIdle();
31326 wxPyEndAllowThreads(__tstate);
31327 if (PyErr_Occurred()) SWIG_fail;
31328 }
31329 {
31330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31331 }
31332 return resultobj;
31333 fail:
31334 return NULL;
31335 }
31336
31337
31338 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31339 PyObject *resultobj = 0;
31340 wxPyApp *arg1 = (wxPyApp *) 0 ;
31341 wxWindow *arg2 = (wxWindow *) 0 ;
31342 wxIdleEvent *arg3 = 0 ;
31343 bool result;
31344 void *argp1 = 0 ;
31345 int res1 = 0 ;
31346 void *argp2 = 0 ;
31347 int res2 = 0 ;
31348 void *argp3 = 0 ;
31349 int res3 = 0 ;
31350 PyObject * obj0 = 0 ;
31351 PyObject * obj1 = 0 ;
31352 PyObject * obj2 = 0 ;
31353 char * kwnames[] = {
31354 (char *) "self",(char *) "win",(char *) "event", NULL
31355 };
31356
31357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31359 if (!SWIG_IsOK(res1)) {
31360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
31361 }
31362 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31363 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
31364 if (!SWIG_IsOK(res2)) {
31365 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
31366 }
31367 arg2 = reinterpret_cast< wxWindow * >(argp2);
31368 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
31369 if (!SWIG_IsOK(res3)) {
31370 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
31371 }
31372 if (!argp3) {
31373 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
31374 }
31375 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
31376 {
31377 PyThreadState* __tstate = wxPyBeginAllowThreads();
31378 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
31379 wxPyEndAllowThreads(__tstate);
31380 if (PyErr_Occurred()) SWIG_fail;
31381 }
31382 {
31383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31384 }
31385 return resultobj;
31386 fail:
31387 return NULL;
31388 }
31389
31390
31391 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31392 PyObject *resultobj = 0;
31393 wxPyApp *arg1 = (wxPyApp *) 0 ;
31394 bool result;
31395 void *argp1 = 0 ;
31396 int res1 = 0 ;
31397 PyObject *swig_obj[1] ;
31398
31399 if (!args) SWIG_fail;
31400 swig_obj[0] = args;
31401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31402 if (!SWIG_IsOK(res1)) {
31403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31404 }
31405 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31406 {
31407 PyThreadState* __tstate = wxPyBeginAllowThreads();
31408 result = (bool)((wxPyApp const *)arg1)->IsActive();
31409 wxPyEndAllowThreads(__tstate);
31410 if (PyErr_Occurred()) SWIG_fail;
31411 }
31412 {
31413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31414 }
31415 return resultobj;
31416 fail:
31417 return NULL;
31418 }
31419
31420
31421 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31422 PyObject *resultobj = 0;
31423 wxPyApp *arg1 = (wxPyApp *) 0 ;
31424 wxWindow *arg2 = (wxWindow *) 0 ;
31425 void *argp1 = 0 ;
31426 int res1 = 0 ;
31427 void *argp2 = 0 ;
31428 int res2 = 0 ;
31429 PyObject * obj0 = 0 ;
31430 PyObject * obj1 = 0 ;
31431 char * kwnames[] = {
31432 (char *) "self",(char *) "win", NULL
31433 };
31434
31435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
31436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31437 if (!SWIG_IsOK(res1)) {
31438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
31439 }
31440 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31441 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
31442 if (!SWIG_IsOK(res2)) {
31443 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
31444 }
31445 arg2 = reinterpret_cast< wxWindow * >(argp2);
31446 {
31447 PyThreadState* __tstate = wxPyBeginAllowThreads();
31448 (arg1)->SetTopWindow(arg2);
31449 wxPyEndAllowThreads(__tstate);
31450 if (PyErr_Occurred()) SWIG_fail;
31451 }
31452 resultobj = SWIG_Py_Void();
31453 return resultobj;
31454 fail:
31455 return NULL;
31456 }
31457
31458
31459 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31460 PyObject *resultobj = 0;
31461 wxPyApp *arg1 = (wxPyApp *) 0 ;
31462 wxWindow *result = 0 ;
31463 void *argp1 = 0 ;
31464 int res1 = 0 ;
31465 PyObject *swig_obj[1] ;
31466
31467 if (!args) SWIG_fail;
31468 swig_obj[0] = args;
31469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31470 if (!SWIG_IsOK(res1)) {
31471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31472 }
31473 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31474 {
31475 PyThreadState* __tstate = wxPyBeginAllowThreads();
31476 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
31477 wxPyEndAllowThreads(__tstate);
31478 if (PyErr_Occurred()) SWIG_fail;
31479 }
31480 {
31481 resultobj = wxPyMake_wxObject(result, (bool)0);
31482 }
31483 return resultobj;
31484 fail:
31485 return NULL;
31486 }
31487
31488
31489 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31490 PyObject *resultobj = 0;
31491 wxPyApp *arg1 = (wxPyApp *) 0 ;
31492 bool arg2 ;
31493 void *argp1 = 0 ;
31494 int res1 = 0 ;
31495 bool val2 ;
31496 int ecode2 = 0 ;
31497 PyObject * obj0 = 0 ;
31498 PyObject * obj1 = 0 ;
31499 char * kwnames[] = {
31500 (char *) "self",(char *) "flag", NULL
31501 };
31502
31503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
31504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31505 if (!SWIG_IsOK(res1)) {
31506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
31507 }
31508 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31509 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31510 if (!SWIG_IsOK(ecode2)) {
31511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
31512 }
31513 arg2 = static_cast< bool >(val2);
31514 {
31515 PyThreadState* __tstate = wxPyBeginAllowThreads();
31516 (arg1)->SetExitOnFrameDelete(arg2);
31517 wxPyEndAllowThreads(__tstate);
31518 if (PyErr_Occurred()) SWIG_fail;
31519 }
31520 resultobj = SWIG_Py_Void();
31521 return resultobj;
31522 fail:
31523 return NULL;
31524 }
31525
31526
31527 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31528 PyObject *resultobj = 0;
31529 wxPyApp *arg1 = (wxPyApp *) 0 ;
31530 bool result;
31531 void *argp1 = 0 ;
31532 int res1 = 0 ;
31533 PyObject *swig_obj[1] ;
31534
31535 if (!args) SWIG_fail;
31536 swig_obj[0] = args;
31537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31538 if (!SWIG_IsOK(res1)) {
31539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31540 }
31541 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31542 {
31543 PyThreadState* __tstate = wxPyBeginAllowThreads();
31544 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
31545 wxPyEndAllowThreads(__tstate);
31546 if (PyErr_Occurred()) SWIG_fail;
31547 }
31548 {
31549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31550 }
31551 return resultobj;
31552 fail:
31553 return NULL;
31554 }
31555
31556
31557 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31558 PyObject *resultobj = 0;
31559 wxPyApp *arg1 = (wxPyApp *) 0 ;
31560 bool arg2 ;
31561 bool arg3 = (bool) false ;
31562 void *argp1 = 0 ;
31563 int res1 = 0 ;
31564 bool val2 ;
31565 int ecode2 = 0 ;
31566 bool val3 ;
31567 int ecode3 = 0 ;
31568 PyObject * obj0 = 0 ;
31569 PyObject * obj1 = 0 ;
31570 PyObject * obj2 = 0 ;
31571 char * kwnames[] = {
31572 (char *) "self",(char *) "flag",(char *) "forceTrueColour", NULL
31573 };
31574
31575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31577 if (!SWIG_IsOK(res1)) {
31578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
31579 }
31580 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31581 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31582 if (!SWIG_IsOK(ecode2)) {
31583 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
31584 }
31585 arg2 = static_cast< bool >(val2);
31586 if (obj2) {
31587 ecode3 = SWIG_AsVal_bool(obj2, &val3);
31588 if (!SWIG_IsOK(ecode3)) {
31589 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "3"" of type '" "bool""'");
31590 }
31591 arg3 = static_cast< bool >(val3);
31592 }
31593 {
31594 PyThreadState* __tstate = wxPyBeginAllowThreads();
31595 (arg1)->SetUseBestVisual(arg2,arg3);
31596 wxPyEndAllowThreads(__tstate);
31597 if (PyErr_Occurred()) SWIG_fail;
31598 }
31599 resultobj = SWIG_Py_Void();
31600 return resultobj;
31601 fail:
31602 return NULL;
31603 }
31604
31605
31606 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31607 PyObject *resultobj = 0;
31608 wxPyApp *arg1 = (wxPyApp *) 0 ;
31609 bool result;
31610 void *argp1 = 0 ;
31611 int res1 = 0 ;
31612 PyObject *swig_obj[1] ;
31613
31614 if (!args) SWIG_fail;
31615 swig_obj[0] = args;
31616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31617 if (!SWIG_IsOK(res1)) {
31618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31619 }
31620 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31621 {
31622 PyThreadState* __tstate = wxPyBeginAllowThreads();
31623 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
31624 wxPyEndAllowThreads(__tstate);
31625 if (PyErr_Occurred()) SWIG_fail;
31626 }
31627 {
31628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31629 }
31630 return resultobj;
31631 fail:
31632 return NULL;
31633 }
31634
31635
31636 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31637 PyObject *resultobj = 0;
31638 wxPyApp *arg1 = (wxPyApp *) 0 ;
31639 int arg2 ;
31640 void *argp1 = 0 ;
31641 int res1 = 0 ;
31642 int val2 ;
31643 int ecode2 = 0 ;
31644 PyObject * obj0 = 0 ;
31645 PyObject * obj1 = 0 ;
31646 char * kwnames[] = {
31647 (char *) "self",(char *) "mode", NULL
31648 };
31649
31650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
31651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31652 if (!SWIG_IsOK(res1)) {
31653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31654 }
31655 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31656 ecode2 = SWIG_AsVal_int(obj1, &val2);
31657 if (!SWIG_IsOK(ecode2)) {
31658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
31659 }
31660 arg2 = static_cast< int >(val2);
31661 {
31662 PyThreadState* __tstate = wxPyBeginAllowThreads();
31663 (arg1)->SetPrintMode(arg2);
31664 wxPyEndAllowThreads(__tstate);
31665 if (PyErr_Occurred()) SWIG_fail;
31666 }
31667 resultobj = SWIG_Py_Void();
31668 return resultobj;
31669 fail:
31670 return NULL;
31671 }
31672
31673
31674 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31675 PyObject *resultobj = 0;
31676 wxPyApp *arg1 = (wxPyApp *) 0 ;
31677 int result;
31678 void *argp1 = 0 ;
31679 int res1 = 0 ;
31680 PyObject *swig_obj[1] ;
31681
31682 if (!args) SWIG_fail;
31683 swig_obj[0] = args;
31684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31685 if (!SWIG_IsOK(res1)) {
31686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31687 }
31688 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31689 {
31690 PyThreadState* __tstate = wxPyBeginAllowThreads();
31691 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
31692 wxPyEndAllowThreads(__tstate);
31693 if (PyErr_Occurred()) SWIG_fail;
31694 }
31695 resultobj = SWIG_From_int(static_cast< int >(result));
31696 return resultobj;
31697 fail:
31698 return NULL;
31699 }
31700
31701
31702 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31703 PyObject *resultobj = 0;
31704 wxPyApp *arg1 = (wxPyApp *) 0 ;
31705 int arg2 ;
31706 void *argp1 = 0 ;
31707 int res1 = 0 ;
31708 int val2 ;
31709 int ecode2 = 0 ;
31710 PyObject * obj0 = 0 ;
31711 PyObject * obj1 = 0 ;
31712 char * kwnames[] = {
31713 (char *) "self",(char *) "mode", NULL
31714 };
31715
31716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
31717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31718 if (!SWIG_IsOK(res1)) {
31719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31720 }
31721 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31722 ecode2 = SWIG_AsVal_int(obj1, &val2);
31723 if (!SWIG_IsOK(ecode2)) {
31724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
31725 }
31726 arg2 = static_cast< int >(val2);
31727 {
31728 PyThreadState* __tstate = wxPyBeginAllowThreads();
31729 (arg1)->SetAssertMode(arg2);
31730 wxPyEndAllowThreads(__tstate);
31731 if (PyErr_Occurred()) SWIG_fail;
31732 }
31733 resultobj = SWIG_Py_Void();
31734 return resultobj;
31735 fail:
31736 return NULL;
31737 }
31738
31739
31740 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31741 PyObject *resultobj = 0;
31742 wxPyApp *arg1 = (wxPyApp *) 0 ;
31743 int result;
31744 void *argp1 = 0 ;
31745 int res1 = 0 ;
31746 PyObject *swig_obj[1] ;
31747
31748 if (!args) SWIG_fail;
31749 swig_obj[0] = args;
31750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31751 if (!SWIG_IsOK(res1)) {
31752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31753 }
31754 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31755 {
31756 PyThreadState* __tstate = wxPyBeginAllowThreads();
31757 result = (int)(arg1)->GetAssertMode();
31758 wxPyEndAllowThreads(__tstate);
31759 if (PyErr_Occurred()) SWIG_fail;
31760 }
31761 resultobj = SWIG_From_int(static_cast< int >(result));
31762 return resultobj;
31763 fail:
31764 return NULL;
31765 }
31766
31767
31768 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31769 PyObject *resultobj = 0;
31770 bool result;
31771
31772 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
31773 {
31774 PyThreadState* __tstate = wxPyBeginAllowThreads();
31775 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
31776 wxPyEndAllowThreads(__tstate);
31777 if (PyErr_Occurred()) SWIG_fail;
31778 }
31779 {
31780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31781 }
31782 return resultobj;
31783 fail:
31784 return NULL;
31785 }
31786
31787
31788 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31789 PyObject *resultobj = 0;
31790 long result;
31791
31792 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
31793 {
31794 PyThreadState* __tstate = wxPyBeginAllowThreads();
31795 result = (long)wxPyApp::GetMacAboutMenuItemId();
31796 wxPyEndAllowThreads(__tstate);
31797 if (PyErr_Occurred()) SWIG_fail;
31798 }
31799 resultobj = SWIG_From_long(static_cast< long >(result));
31800 return resultobj;
31801 fail:
31802 return NULL;
31803 }
31804
31805
31806 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31807 PyObject *resultobj = 0;
31808 long result;
31809
31810 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
31811 {
31812 PyThreadState* __tstate = wxPyBeginAllowThreads();
31813 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
31814 wxPyEndAllowThreads(__tstate);
31815 if (PyErr_Occurred()) SWIG_fail;
31816 }
31817 resultobj = SWIG_From_long(static_cast< long >(result));
31818 return resultobj;
31819 fail:
31820 return NULL;
31821 }
31822
31823
31824 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31825 PyObject *resultobj = 0;
31826 long result;
31827
31828 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
31829 {
31830 PyThreadState* __tstate = wxPyBeginAllowThreads();
31831 result = (long)wxPyApp::GetMacExitMenuItemId();
31832 wxPyEndAllowThreads(__tstate);
31833 if (PyErr_Occurred()) SWIG_fail;
31834 }
31835 resultobj = SWIG_From_long(static_cast< long >(result));
31836 return resultobj;
31837 fail:
31838 return NULL;
31839 }
31840
31841
31842 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31843 PyObject *resultobj = 0;
31844 wxString result;
31845
31846 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
31847 {
31848 PyThreadState* __tstate = wxPyBeginAllowThreads();
31849 result = wxPyApp::GetMacHelpMenuTitleName();
31850 wxPyEndAllowThreads(__tstate);
31851 if (PyErr_Occurred()) SWIG_fail;
31852 }
31853 {
31854 #if wxUSE_UNICODE
31855 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31856 #else
31857 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31858 #endif
31859 }
31860 return resultobj;
31861 fail:
31862 return NULL;
31863 }
31864
31865
31866 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31867 PyObject *resultobj = 0;
31868 bool arg1 ;
31869 bool val1 ;
31870 int ecode1 = 0 ;
31871 PyObject * obj0 = 0 ;
31872 char * kwnames[] = {
31873 (char *) "val", NULL
31874 };
31875
31876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
31877 ecode1 = SWIG_AsVal_bool(obj0, &val1);
31878 if (!SWIG_IsOK(ecode1)) {
31879 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
31880 }
31881 arg1 = static_cast< bool >(val1);
31882 {
31883 PyThreadState* __tstate = wxPyBeginAllowThreads();
31884 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
31885 wxPyEndAllowThreads(__tstate);
31886 if (PyErr_Occurred()) SWIG_fail;
31887 }
31888 resultobj = SWIG_Py_Void();
31889 return resultobj;
31890 fail:
31891 return NULL;
31892 }
31893
31894
31895 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31896 PyObject *resultobj = 0;
31897 long arg1 ;
31898 long val1 ;
31899 int ecode1 = 0 ;
31900 PyObject * obj0 = 0 ;
31901 char * kwnames[] = {
31902 (char *) "val", NULL
31903 };
31904
31905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
31906 ecode1 = SWIG_AsVal_long(obj0, &val1);
31907 if (!SWIG_IsOK(ecode1)) {
31908 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
31909 }
31910 arg1 = static_cast< long >(val1);
31911 {
31912 PyThreadState* __tstate = wxPyBeginAllowThreads();
31913 wxPyApp::SetMacAboutMenuItemId(arg1);
31914 wxPyEndAllowThreads(__tstate);
31915 if (PyErr_Occurred()) SWIG_fail;
31916 }
31917 resultobj = SWIG_Py_Void();
31918 return resultobj;
31919 fail:
31920 return NULL;
31921 }
31922
31923
31924 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31925 PyObject *resultobj = 0;
31926 long arg1 ;
31927 long val1 ;
31928 int ecode1 = 0 ;
31929 PyObject * obj0 = 0 ;
31930 char * kwnames[] = {
31931 (char *) "val", NULL
31932 };
31933
31934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
31935 ecode1 = SWIG_AsVal_long(obj0, &val1);
31936 if (!SWIG_IsOK(ecode1)) {
31937 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
31938 }
31939 arg1 = static_cast< long >(val1);
31940 {
31941 PyThreadState* __tstate = wxPyBeginAllowThreads();
31942 wxPyApp::SetMacPreferencesMenuItemId(arg1);
31943 wxPyEndAllowThreads(__tstate);
31944 if (PyErr_Occurred()) SWIG_fail;
31945 }
31946 resultobj = SWIG_Py_Void();
31947 return resultobj;
31948 fail:
31949 return NULL;
31950 }
31951
31952
31953 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31954 PyObject *resultobj = 0;
31955 long arg1 ;
31956 long val1 ;
31957 int ecode1 = 0 ;
31958 PyObject * obj0 = 0 ;
31959 char * kwnames[] = {
31960 (char *) "val", NULL
31961 };
31962
31963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
31964 ecode1 = SWIG_AsVal_long(obj0, &val1);
31965 if (!SWIG_IsOK(ecode1)) {
31966 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
31967 }
31968 arg1 = static_cast< long >(val1);
31969 {
31970 PyThreadState* __tstate = wxPyBeginAllowThreads();
31971 wxPyApp::SetMacExitMenuItemId(arg1);
31972 wxPyEndAllowThreads(__tstate);
31973 if (PyErr_Occurred()) SWIG_fail;
31974 }
31975 resultobj = SWIG_Py_Void();
31976 return resultobj;
31977 fail:
31978 return NULL;
31979 }
31980
31981
31982 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31983 PyObject *resultobj = 0;
31984 wxString *arg1 = 0 ;
31985 bool temp1 = false ;
31986 PyObject * obj0 = 0 ;
31987 char * kwnames[] = {
31988 (char *) "val", NULL
31989 };
31990
31991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
31992 {
31993 arg1 = wxString_in_helper(obj0);
31994 if (arg1 == NULL) SWIG_fail;
31995 temp1 = true;
31996 }
31997 {
31998 PyThreadState* __tstate = wxPyBeginAllowThreads();
31999 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
32000 wxPyEndAllowThreads(__tstate);
32001 if (PyErr_Occurred()) SWIG_fail;
32002 }
32003 resultobj = SWIG_Py_Void();
32004 {
32005 if (temp1)
32006 delete arg1;
32007 }
32008 return resultobj;
32009 fail:
32010 {
32011 if (temp1)
32012 delete arg1;
32013 }
32014 return NULL;
32015 }
32016
32017
32018 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32019 PyObject *resultobj = 0;
32020 wxPyApp *arg1 = (wxPyApp *) 0 ;
32021 void *argp1 = 0 ;
32022 int res1 = 0 ;
32023 PyObject *swig_obj[1] ;
32024
32025 if (!args) SWIG_fail;
32026 swig_obj[0] = args;
32027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
32028 if (!SWIG_IsOK(res1)) {
32029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
32030 }
32031 arg1 = reinterpret_cast< wxPyApp * >(argp1);
32032 {
32033 PyThreadState* __tstate = wxPyBeginAllowThreads();
32034 (arg1)->_BootstrapApp();
32035 wxPyEndAllowThreads(__tstate);
32036 if (PyErr_Occurred()) SWIG_fail;
32037 }
32038 resultobj = SWIG_Py_Void();
32039 return resultobj;
32040 fail:
32041 return NULL;
32042 }
32043
32044
32045 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32046 PyObject *resultobj = 0;
32047 int result;
32048
32049 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
32050 {
32051 PyThreadState* __tstate = wxPyBeginAllowThreads();
32052 result = (int)wxPyApp_GetComCtl32Version();
32053 wxPyEndAllowThreads(__tstate);
32054 if (PyErr_Occurred()) SWIG_fail;
32055 }
32056 resultobj = SWIG_From_int(static_cast< int >(result));
32057 return resultobj;
32058 fail:
32059 return NULL;
32060 }
32061
32062
32063 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32064 PyObject *resultobj = 0;
32065 bool result;
32066
32067 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
32068 {
32069 PyThreadState* __tstate = wxPyBeginAllowThreads();
32070 result = (bool)wxPyApp_IsDisplayAvailable();
32071 wxPyEndAllowThreads(__tstate);
32072 if (PyErr_Occurred()) SWIG_fail;
32073 }
32074 {
32075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32076 }
32077 return resultobj;
32078 fail:
32079 return NULL;
32080 }
32081
32082
32083 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32084 PyObject *obj;
32085 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32086 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
32087 return SWIG_Py_Void();
32088 }
32089
32090 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32091 return SWIG_Python_InitShadowInstance(args);
32092 }
32093
32094 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32095 PyObject *resultobj = 0;
32096
32097 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
32098 {
32099 PyThreadState* __tstate = wxPyBeginAllowThreads();
32100 wxExit();
32101 wxPyEndAllowThreads(__tstate);
32102 if (PyErr_Occurred()) SWIG_fail;
32103 }
32104 resultobj = SWIG_Py_Void();
32105 return resultobj;
32106 fail:
32107 return NULL;
32108 }
32109
32110
32111 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32112 PyObject *resultobj = 0;
32113 bool result;
32114
32115 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
32116 {
32117 PyThreadState* __tstate = wxPyBeginAllowThreads();
32118 result = (bool)wxYield();
32119 wxPyEndAllowThreads(__tstate);
32120 if (PyErr_Occurred()) SWIG_fail;
32121 }
32122 {
32123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32124 }
32125 return resultobj;
32126 fail:
32127 return NULL;
32128 }
32129
32130
32131 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32132 PyObject *resultobj = 0;
32133 bool result;
32134
32135 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
32136 {
32137 PyThreadState* __tstate = wxPyBeginAllowThreads();
32138 result = (bool)wxYieldIfNeeded();
32139 wxPyEndAllowThreads(__tstate);
32140 if (PyErr_Occurred()) SWIG_fail;
32141 }
32142 {
32143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32144 }
32145 return resultobj;
32146 fail:
32147 return NULL;
32148 }
32149
32150
32151 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32152 PyObject *resultobj = 0;
32153 wxWindow *arg1 = (wxWindow *) NULL ;
32154 bool arg2 = (bool) false ;
32155 bool result;
32156 void *argp1 = 0 ;
32157 int res1 = 0 ;
32158 bool val2 ;
32159 int ecode2 = 0 ;
32160 PyObject * obj0 = 0 ;
32161 PyObject * obj1 = 0 ;
32162 char * kwnames[] = {
32163 (char *) "win",(char *) "onlyIfNeeded", NULL
32164 };
32165
32166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
32167 if (obj0) {
32168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32169 if (!SWIG_IsOK(res1)) {
32170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
32171 }
32172 arg1 = reinterpret_cast< wxWindow * >(argp1);
32173 }
32174 if (obj1) {
32175 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32176 if (!SWIG_IsOK(ecode2)) {
32177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
32178 }
32179 arg2 = static_cast< bool >(val2);
32180 }
32181 {
32182 PyThreadState* __tstate = wxPyBeginAllowThreads();
32183 result = (bool)wxSafeYield(arg1,arg2);
32184 wxPyEndAllowThreads(__tstate);
32185 if (PyErr_Occurred()) SWIG_fail;
32186 }
32187 {
32188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32189 }
32190 return resultobj;
32191 fail:
32192 return NULL;
32193 }
32194
32195
32196 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32197 PyObject *resultobj = 0;
32198
32199 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
32200 {
32201 PyThreadState* __tstate = wxPyBeginAllowThreads();
32202 wxWakeUpIdle();
32203 wxPyEndAllowThreads(__tstate);
32204 if (PyErr_Occurred()) SWIG_fail;
32205 }
32206 resultobj = SWIG_Py_Void();
32207 return resultobj;
32208 fail:
32209 return NULL;
32210 }
32211
32212
32213 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32214 PyObject *resultobj = 0;
32215 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
32216 wxEvent *arg2 = 0 ;
32217 void *argp1 = 0 ;
32218 int res1 = 0 ;
32219 void *argp2 = 0 ;
32220 int res2 = 0 ;
32221 PyObject * obj0 = 0 ;
32222 PyObject * obj1 = 0 ;
32223 char * kwnames[] = {
32224 (char *) "dest",(char *) "event", NULL
32225 };
32226
32227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
32228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
32229 if (!SWIG_IsOK(res1)) {
32230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
32231 }
32232 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
32233 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
32234 if (!SWIG_IsOK(res2)) {
32235 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
32236 }
32237 if (!argp2) {
32238 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
32239 }
32240 arg2 = reinterpret_cast< wxEvent * >(argp2);
32241 {
32242 PyThreadState* __tstate = wxPyBeginAllowThreads();
32243 wxPostEvent(arg1,*arg2);
32244 wxPyEndAllowThreads(__tstate);
32245 if (PyErr_Occurred()) SWIG_fail;
32246 }
32247 resultobj = SWIG_Py_Void();
32248 return resultobj;
32249 fail:
32250 return NULL;
32251 }
32252
32253
32254 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32255 PyObject *resultobj = 0;
32256
32257 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
32258 {
32259 PyThreadState* __tstate = wxPyBeginAllowThreads();
32260 wxApp_CleanUp();
32261 wxPyEndAllowThreads(__tstate);
32262 if (PyErr_Occurred()) SWIG_fail;
32263 }
32264 resultobj = SWIG_Py_Void();
32265 return resultobj;
32266 fail:
32267 return NULL;
32268 }
32269
32270
32271 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32272 PyObject *resultobj = 0;
32273 wxPyApp *result = 0 ;
32274
32275 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
32276 {
32277 PyThreadState* __tstate = wxPyBeginAllowThreads();
32278 result = (wxPyApp *)wxPyGetApp();
32279 wxPyEndAllowThreads(__tstate);
32280 if (PyErr_Occurred()) SWIG_fail;
32281 }
32282 {
32283 resultobj = wxPyMake_wxObject(result, 0);
32284 }
32285 return resultobj;
32286 fail:
32287 return NULL;
32288 }
32289
32290
32291 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32292 PyObject *resultobj = 0;
32293 char *arg1 = (char *) 0 ;
32294 int res1 ;
32295 char *buf1 = 0 ;
32296 int alloc1 = 0 ;
32297 PyObject * obj0 = 0 ;
32298 char * kwnames[] = {
32299 (char *) "encoding", NULL
32300 };
32301
32302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
32303 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
32304 if (!SWIG_IsOK(res1)) {
32305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
32306 }
32307 arg1 = buf1;
32308 {
32309 PyThreadState* __tstate = wxPyBeginAllowThreads();
32310 wxSetDefaultPyEncoding((char const *)arg1);
32311 wxPyEndAllowThreads(__tstate);
32312 if (PyErr_Occurred()) SWIG_fail;
32313 }
32314 resultobj = SWIG_Py_Void();
32315 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
32316 return resultobj;
32317 fail:
32318 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
32319 return NULL;
32320 }
32321
32322
32323 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32324 PyObject *resultobj = 0;
32325 char *result = 0 ;
32326
32327 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
32328 {
32329 PyThreadState* __tstate = wxPyBeginAllowThreads();
32330 result = (char *)wxGetDefaultPyEncoding();
32331 wxPyEndAllowThreads(__tstate);
32332 if (PyErr_Occurred()) SWIG_fail;
32333 }
32334 resultobj = SWIG_FromCharPtr(result);
32335 return resultobj;
32336 fail:
32337 return NULL;
32338 }
32339
32340
32341 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32342 PyObject *resultobj = 0;
32343 wxEventLoop *result = 0 ;
32344
32345 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
32346 {
32347 PyThreadState* __tstate = wxPyBeginAllowThreads();
32348 result = (wxEventLoop *)new wxEventLoop();
32349 wxPyEndAllowThreads(__tstate);
32350 if (PyErr_Occurred()) SWIG_fail;
32351 }
32352 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
32353 return resultobj;
32354 fail:
32355 return NULL;
32356 }
32357
32358
32359 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32360 PyObject *resultobj = 0;
32361 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32362 void *argp1 = 0 ;
32363 int res1 = 0 ;
32364 PyObject *swig_obj[1] ;
32365
32366 if (!args) SWIG_fail;
32367 swig_obj[0] = args;
32368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
32369 if (!SWIG_IsOK(res1)) {
32370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32371 }
32372 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32373 {
32374 PyThreadState* __tstate = wxPyBeginAllowThreads();
32375 delete arg1;
32376
32377 wxPyEndAllowThreads(__tstate);
32378 if (PyErr_Occurred()) SWIG_fail;
32379 }
32380 resultobj = SWIG_Py_Void();
32381 return resultobj;
32382 fail:
32383 return NULL;
32384 }
32385
32386
32387 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32388 PyObject *resultobj = 0;
32389 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32390 int result;
32391 void *argp1 = 0 ;
32392 int res1 = 0 ;
32393 PyObject *swig_obj[1] ;
32394
32395 if (!args) SWIG_fail;
32396 swig_obj[0] = args;
32397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32398 if (!SWIG_IsOK(res1)) {
32399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32400 }
32401 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32402 {
32403 PyThreadState* __tstate = wxPyBeginAllowThreads();
32404 result = (int)(arg1)->Run();
32405 wxPyEndAllowThreads(__tstate);
32406 if (PyErr_Occurred()) SWIG_fail;
32407 }
32408 resultobj = SWIG_From_int(static_cast< int >(result));
32409 return resultobj;
32410 fail:
32411 return NULL;
32412 }
32413
32414
32415 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32416 PyObject *resultobj = 0;
32417 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32418 int arg2 = (int) 0 ;
32419 void *argp1 = 0 ;
32420 int res1 = 0 ;
32421 int val2 ;
32422 int ecode2 = 0 ;
32423 PyObject * obj0 = 0 ;
32424 PyObject * obj1 = 0 ;
32425 char * kwnames[] = {
32426 (char *) "self",(char *) "rc", NULL
32427 };
32428
32429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
32430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32431 if (!SWIG_IsOK(res1)) {
32432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32433 }
32434 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32435 if (obj1) {
32436 ecode2 = SWIG_AsVal_int(obj1, &val2);
32437 if (!SWIG_IsOK(ecode2)) {
32438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
32439 }
32440 arg2 = static_cast< int >(val2);
32441 }
32442 {
32443 PyThreadState* __tstate = wxPyBeginAllowThreads();
32444 (arg1)->Exit(arg2);
32445 wxPyEndAllowThreads(__tstate);
32446 if (PyErr_Occurred()) SWIG_fail;
32447 }
32448 resultobj = SWIG_Py_Void();
32449 return resultobj;
32450 fail:
32451 return NULL;
32452 }
32453
32454
32455 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32456 PyObject *resultobj = 0;
32457 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32458 bool result;
32459 void *argp1 = 0 ;
32460 int res1 = 0 ;
32461 PyObject *swig_obj[1] ;
32462
32463 if (!args) SWIG_fail;
32464 swig_obj[0] = args;
32465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32466 if (!SWIG_IsOK(res1)) {
32467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
32468 }
32469 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32470 {
32471 PyThreadState* __tstate = wxPyBeginAllowThreads();
32472 result = (bool)((wxEventLoop const *)arg1)->Pending();
32473 wxPyEndAllowThreads(__tstate);
32474 if (PyErr_Occurred()) SWIG_fail;
32475 }
32476 {
32477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32478 }
32479 return resultobj;
32480 fail:
32481 return NULL;
32482 }
32483
32484
32485 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32486 PyObject *resultobj = 0;
32487 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32488 bool result;
32489 void *argp1 = 0 ;
32490 int res1 = 0 ;
32491 PyObject *swig_obj[1] ;
32492
32493 if (!args) SWIG_fail;
32494 swig_obj[0] = args;
32495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32496 if (!SWIG_IsOK(res1)) {
32497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32498 }
32499 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32500 {
32501 PyThreadState* __tstate = wxPyBeginAllowThreads();
32502 result = (bool)(arg1)->Dispatch();
32503 wxPyEndAllowThreads(__tstate);
32504 if (PyErr_Occurred()) SWIG_fail;
32505 }
32506 {
32507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32508 }
32509 return resultobj;
32510 fail:
32511 return NULL;
32512 }
32513
32514
32515 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32516 PyObject *resultobj = 0;
32517 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32518 bool result;
32519 void *argp1 = 0 ;
32520 int res1 = 0 ;
32521 PyObject *swig_obj[1] ;
32522
32523 if (!args) SWIG_fail;
32524 swig_obj[0] = args;
32525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32526 if (!SWIG_IsOK(res1)) {
32527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
32528 }
32529 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32530 {
32531 PyThreadState* __tstate = wxPyBeginAllowThreads();
32532 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
32533 wxPyEndAllowThreads(__tstate);
32534 if (PyErr_Occurred()) SWIG_fail;
32535 }
32536 {
32537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32538 }
32539 return resultobj;
32540 fail:
32541 return NULL;
32542 }
32543
32544
32545 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32546 PyObject *resultobj = 0;
32547 wxEventLoop *result = 0 ;
32548
32549 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
32550 {
32551 PyThreadState* __tstate = wxPyBeginAllowThreads();
32552 result = (wxEventLoop *)wxEventLoop::GetActive();
32553 wxPyEndAllowThreads(__tstate);
32554 if (PyErr_Occurred()) SWIG_fail;
32555 }
32556 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
32557 return resultobj;
32558 fail:
32559 return NULL;
32560 }
32561
32562
32563 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32564 PyObject *resultobj = 0;
32565 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32566 void *argp1 = 0 ;
32567 int res1 = 0 ;
32568 PyObject * obj0 = 0 ;
32569 char * kwnames[] = {
32570 (char *) "loop", NULL
32571 };
32572
32573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
32574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32575 if (!SWIG_IsOK(res1)) {
32576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32577 }
32578 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32579 {
32580 PyThreadState* __tstate = wxPyBeginAllowThreads();
32581 wxEventLoop::SetActive(arg1);
32582 wxPyEndAllowThreads(__tstate);
32583 if (PyErr_Occurred()) SWIG_fail;
32584 }
32585 resultobj = SWIG_Py_Void();
32586 return resultobj;
32587 fail:
32588 return NULL;
32589 }
32590
32591
32592 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32593 PyObject *obj;
32594 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32595 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
32596 return SWIG_Py_Void();
32597 }
32598
32599 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32600 return SWIG_Python_InitShadowInstance(args);
32601 }
32602
32603 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32604 PyObject *resultobj = 0;
32605 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32606 wxEventLoopActivator *result = 0 ;
32607 void *argp1 = 0 ;
32608 int res1 = 0 ;
32609 PyObject * obj0 = 0 ;
32610 char * kwnames[] = {
32611 (char *) "evtLoop", NULL
32612 };
32613
32614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
32615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32616 if (!SWIG_IsOK(res1)) {
32617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32618 }
32619 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32620 {
32621 PyThreadState* __tstate = wxPyBeginAllowThreads();
32622 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
32623 wxPyEndAllowThreads(__tstate);
32624 if (PyErr_Occurred()) SWIG_fail;
32625 }
32626 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
32627 return resultobj;
32628 fail:
32629 return NULL;
32630 }
32631
32632
32633 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32634 PyObject *resultobj = 0;
32635 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
32636 void *argp1 = 0 ;
32637 int res1 = 0 ;
32638 PyObject *swig_obj[1] ;
32639
32640 if (!args) SWIG_fail;
32641 swig_obj[0] = args;
32642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
32643 if (!SWIG_IsOK(res1)) {
32644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
32645 }
32646 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
32647 {
32648 PyThreadState* __tstate = wxPyBeginAllowThreads();
32649 delete arg1;
32650
32651 wxPyEndAllowThreads(__tstate);
32652 if (PyErr_Occurred()) SWIG_fail;
32653 }
32654 resultobj = SWIG_Py_Void();
32655 return resultobj;
32656 fail:
32657 return NULL;
32658 }
32659
32660
32661 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32662 PyObject *obj;
32663 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32664 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
32665 return SWIG_Py_Void();
32666 }
32667
32668 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32669 return SWIG_Python_InitShadowInstance(args);
32670 }
32671
32672 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32673 PyObject *resultobj = 0;
32674 int arg1 = (int) 0 ;
32675 int arg2 = (int) 0 ;
32676 int arg3 = (int) 0 ;
32677 wxAcceleratorEntry *result = 0 ;
32678 int val1 ;
32679 int ecode1 = 0 ;
32680 int val2 ;
32681 int ecode2 = 0 ;
32682 int val3 ;
32683 int ecode3 = 0 ;
32684 PyObject * obj0 = 0 ;
32685 PyObject * obj1 = 0 ;
32686 PyObject * obj2 = 0 ;
32687 char * kwnames[] = {
32688 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
32689 };
32690
32691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32692 if (obj0) {
32693 ecode1 = SWIG_AsVal_int(obj0, &val1);
32694 if (!SWIG_IsOK(ecode1)) {
32695 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
32696 }
32697 arg1 = static_cast< int >(val1);
32698 }
32699 if (obj1) {
32700 ecode2 = SWIG_AsVal_int(obj1, &val2);
32701 if (!SWIG_IsOK(ecode2)) {
32702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
32703 }
32704 arg2 = static_cast< int >(val2);
32705 }
32706 if (obj2) {
32707 ecode3 = SWIG_AsVal_int(obj2, &val3);
32708 if (!SWIG_IsOK(ecode3)) {
32709 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
32710 }
32711 arg3 = static_cast< int >(val3);
32712 }
32713 {
32714 PyThreadState* __tstate = wxPyBeginAllowThreads();
32715 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
32716 wxPyEndAllowThreads(__tstate);
32717 if (PyErr_Occurred()) SWIG_fail;
32718 }
32719 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
32720 return resultobj;
32721 fail:
32722 return NULL;
32723 }
32724
32725
32726 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32727 PyObject *resultobj = 0;
32728 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32729 void *argp1 = 0 ;
32730 int res1 = 0 ;
32731 PyObject *swig_obj[1] ;
32732
32733 if (!args) SWIG_fail;
32734 swig_obj[0] = args;
32735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
32736 if (!SWIG_IsOK(res1)) {
32737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32738 }
32739 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32740 {
32741 PyThreadState* __tstate = wxPyBeginAllowThreads();
32742 delete arg1;
32743
32744 wxPyEndAllowThreads(__tstate);
32745 if (PyErr_Occurred()) SWIG_fail;
32746 }
32747 resultobj = SWIG_Py_Void();
32748 return resultobj;
32749 fail:
32750 return NULL;
32751 }
32752
32753
32754 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32755 PyObject *resultobj = 0;
32756 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32757 int arg2 ;
32758 int arg3 ;
32759 int arg4 ;
32760 void *argp1 = 0 ;
32761 int res1 = 0 ;
32762 int val2 ;
32763 int ecode2 = 0 ;
32764 int val3 ;
32765 int ecode3 = 0 ;
32766 int val4 ;
32767 int ecode4 = 0 ;
32768 PyObject * obj0 = 0 ;
32769 PyObject * obj1 = 0 ;
32770 PyObject * obj2 = 0 ;
32771 PyObject * obj3 = 0 ;
32772 char * kwnames[] = {
32773 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
32774 };
32775
32776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32778 if (!SWIG_IsOK(res1)) {
32779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32780 }
32781 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32782 ecode2 = SWIG_AsVal_int(obj1, &val2);
32783 if (!SWIG_IsOK(ecode2)) {
32784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
32785 }
32786 arg2 = static_cast< int >(val2);
32787 ecode3 = SWIG_AsVal_int(obj2, &val3);
32788 if (!SWIG_IsOK(ecode3)) {
32789 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
32790 }
32791 arg3 = static_cast< int >(val3);
32792 ecode4 = SWIG_AsVal_int(obj3, &val4);
32793 if (!SWIG_IsOK(ecode4)) {
32794 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
32795 }
32796 arg4 = static_cast< int >(val4);
32797 {
32798 PyThreadState* __tstate = wxPyBeginAllowThreads();
32799 (arg1)->Set(arg2,arg3,arg4);
32800 wxPyEndAllowThreads(__tstate);
32801 if (PyErr_Occurred()) SWIG_fail;
32802 }
32803 resultobj = SWIG_Py_Void();
32804 return resultobj;
32805 fail:
32806 return NULL;
32807 }
32808
32809
32810 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32811 PyObject *resultobj = 0;
32812 wxString *arg1 = 0 ;
32813 wxAcceleratorEntry *result = 0 ;
32814 bool temp1 = false ;
32815 PyObject * obj0 = 0 ;
32816 char * kwnames[] = {
32817 (char *) "str", NULL
32818 };
32819
32820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
32821 {
32822 arg1 = wxString_in_helper(obj0);
32823 if (arg1 == NULL) SWIG_fail;
32824 temp1 = true;
32825 }
32826 {
32827 PyThreadState* __tstate = wxPyBeginAllowThreads();
32828 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
32829 wxPyEndAllowThreads(__tstate);
32830 if (PyErr_Occurred()) SWIG_fail;
32831 }
32832 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
32833 {
32834 if (temp1)
32835 delete arg1;
32836 }
32837 return resultobj;
32838 fail:
32839 {
32840 if (temp1)
32841 delete arg1;
32842 }
32843 return NULL;
32844 }
32845
32846
32847 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32848 PyObject *resultobj = 0;
32849 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32850 int result;
32851 void *argp1 = 0 ;
32852 int res1 = 0 ;
32853 PyObject *swig_obj[1] ;
32854
32855 if (!args) SWIG_fail;
32856 swig_obj[0] = args;
32857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32858 if (!SWIG_IsOK(res1)) {
32859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32860 }
32861 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32862 {
32863 PyThreadState* __tstate = wxPyBeginAllowThreads();
32864 result = (int)(arg1)->GetFlags();
32865 wxPyEndAllowThreads(__tstate);
32866 if (PyErr_Occurred()) SWIG_fail;
32867 }
32868 resultobj = SWIG_From_int(static_cast< int >(result));
32869 return resultobj;
32870 fail:
32871 return NULL;
32872 }
32873
32874
32875 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32876 PyObject *resultobj = 0;
32877 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32878 int result;
32879 void *argp1 = 0 ;
32880 int res1 = 0 ;
32881 PyObject *swig_obj[1] ;
32882
32883 if (!args) SWIG_fail;
32884 swig_obj[0] = args;
32885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32886 if (!SWIG_IsOK(res1)) {
32887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32888 }
32889 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32890 {
32891 PyThreadState* __tstate = wxPyBeginAllowThreads();
32892 result = (int)(arg1)->GetKeyCode();
32893 wxPyEndAllowThreads(__tstate);
32894 if (PyErr_Occurred()) SWIG_fail;
32895 }
32896 resultobj = SWIG_From_int(static_cast< int >(result));
32897 return resultobj;
32898 fail:
32899 return NULL;
32900 }
32901
32902
32903 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32904 PyObject *resultobj = 0;
32905 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32906 int result;
32907 void *argp1 = 0 ;
32908 int res1 = 0 ;
32909 PyObject *swig_obj[1] ;
32910
32911 if (!args) SWIG_fail;
32912 swig_obj[0] = args;
32913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32914 if (!SWIG_IsOK(res1)) {
32915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32916 }
32917 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32918 {
32919 PyThreadState* __tstate = wxPyBeginAllowThreads();
32920 result = (int)(arg1)->GetCommand();
32921 wxPyEndAllowThreads(__tstate);
32922 if (PyErr_Occurred()) SWIG_fail;
32923 }
32924 resultobj = SWIG_From_int(static_cast< int >(result));
32925 return resultobj;
32926 fail:
32927 return NULL;
32928 }
32929
32930
32931 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32932 PyObject *resultobj = 0;
32933 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32934 bool result;
32935 void *argp1 = 0 ;
32936 int res1 = 0 ;
32937 PyObject *swig_obj[1] ;
32938
32939 if (!args) SWIG_fail;
32940 swig_obj[0] = args;
32941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32942 if (!SWIG_IsOK(res1)) {
32943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32944 }
32945 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32946 {
32947 PyThreadState* __tstate = wxPyBeginAllowThreads();
32948 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
32949 wxPyEndAllowThreads(__tstate);
32950 if (PyErr_Occurred()) SWIG_fail;
32951 }
32952 {
32953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32954 }
32955 return resultobj;
32956 fail:
32957 return NULL;
32958 }
32959
32960
32961 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32962 PyObject *resultobj = 0;
32963 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32964 wxString result;
32965 void *argp1 = 0 ;
32966 int res1 = 0 ;
32967 PyObject *swig_obj[1] ;
32968
32969 if (!args) SWIG_fail;
32970 swig_obj[0] = args;
32971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32972 if (!SWIG_IsOK(res1)) {
32973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32974 }
32975 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32976 {
32977 PyThreadState* __tstate = wxPyBeginAllowThreads();
32978 result = ((wxAcceleratorEntry const *)arg1)->ToString();
32979 wxPyEndAllowThreads(__tstate);
32980 if (PyErr_Occurred()) SWIG_fail;
32981 }
32982 {
32983 #if wxUSE_UNICODE
32984 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32985 #else
32986 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32987 #endif
32988 }
32989 return resultobj;
32990 fail:
32991 return NULL;
32992 }
32993
32994
32995 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32996 PyObject *resultobj = 0;
32997 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32998 wxString *arg2 = 0 ;
32999 bool result;
33000 void *argp1 = 0 ;
33001 int res1 = 0 ;
33002 bool temp2 = false ;
33003 PyObject * obj0 = 0 ;
33004 PyObject * obj1 = 0 ;
33005 char * kwnames[] = {
33006 (char *) "self",(char *) "str", NULL
33007 };
33008
33009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
33010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
33011 if (!SWIG_IsOK(res1)) {
33012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
33013 }
33014 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
33015 {
33016 arg2 = wxString_in_helper(obj1);
33017 if (arg2 == NULL) SWIG_fail;
33018 temp2 = true;
33019 }
33020 {
33021 PyThreadState* __tstate = wxPyBeginAllowThreads();
33022 result = (bool)(arg1)->FromString((wxString const &)*arg2);
33023 wxPyEndAllowThreads(__tstate);
33024 if (PyErr_Occurred()) SWIG_fail;
33025 }
33026 {
33027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33028 }
33029 {
33030 if (temp2)
33031 delete arg2;
33032 }
33033 return resultobj;
33034 fail:
33035 {
33036 if (temp2)
33037 delete arg2;
33038 }
33039 return NULL;
33040 }
33041
33042
33043 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33044 PyObject *obj;
33045 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33046 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
33047 return SWIG_Py_Void();
33048 }
33049
33050 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33051 return SWIG_Python_InitShadowInstance(args);
33052 }
33053
33054 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33055 PyObject *resultobj = 0;
33056 int arg1 ;
33057 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
33058 wxAcceleratorTable *result = 0 ;
33059 PyObject * obj0 = 0 ;
33060 char * kwnames[] = {
33061 (char *) "n", NULL
33062 };
33063
33064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
33065 {
33066 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
33067 if (arg2) arg1 = PyList_Size(obj0);
33068 else arg1 = 0;
33069 }
33070 {
33071 PyThreadState* __tstate = wxPyBeginAllowThreads();
33072 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
33073 wxPyEndAllowThreads(__tstate);
33074 if (PyErr_Occurred()) SWIG_fail;
33075 }
33076 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
33077 return resultobj;
33078 fail:
33079 return NULL;
33080 }
33081
33082
33083 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33084 PyObject *resultobj = 0;
33085 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
33086 void *argp1 = 0 ;
33087 int res1 = 0 ;
33088 PyObject *swig_obj[1] ;
33089
33090 if (!args) SWIG_fail;
33091 swig_obj[0] = args;
33092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
33093 if (!SWIG_IsOK(res1)) {
33094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
33095 }
33096 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
33097 {
33098 PyThreadState* __tstate = wxPyBeginAllowThreads();
33099 delete arg1;
33100
33101 wxPyEndAllowThreads(__tstate);
33102 if (PyErr_Occurred()) SWIG_fail;
33103 }
33104 resultobj = SWIG_Py_Void();
33105 return resultobj;
33106 fail:
33107 return NULL;
33108 }
33109
33110
33111 SWIGINTERN PyObject *_wrap_AcceleratorTable_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33112 PyObject *resultobj = 0;
33113 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
33114 bool result;
33115 void *argp1 = 0 ;
33116 int res1 = 0 ;
33117 PyObject *swig_obj[1] ;
33118
33119 if (!args) SWIG_fail;
33120 swig_obj[0] = args;
33121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33122 if (!SWIG_IsOK(res1)) {
33123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
33124 }
33125 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
33126 {
33127 PyThreadState* __tstate = wxPyBeginAllowThreads();
33128 result = (bool)((wxAcceleratorTable const *)arg1)->IsOk();
33129 wxPyEndAllowThreads(__tstate);
33130 if (PyErr_Occurred()) SWIG_fail;
33131 }
33132 {
33133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33134 }
33135 return resultobj;
33136 fail:
33137 return NULL;
33138 }
33139
33140
33141 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33142 PyObject *obj;
33143 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33144 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
33145 return SWIG_Py_Void();
33146 }
33147
33148 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33149 return SWIG_Python_InitShadowInstance(args);
33150 }
33151
33152 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
33153 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
33154 return 1;
33155 }
33156
33157
33158 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
33159 PyObject *pyobj = 0;
33160
33161 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
33162 return pyobj;
33163 }
33164
33165
33166 SWIGINTERN int PanelNameStr_set(PyObject *) {
33167 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
33168 return 1;
33169 }
33170
33171
33172 SWIGINTERN PyObject *PanelNameStr_get(void) {
33173 PyObject *pyobj = 0;
33174
33175 {
33176 #if wxUSE_UNICODE
33177 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
33178 #else
33179 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
33180 #endif
33181 }
33182 return pyobj;
33183 }
33184
33185
33186 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33187 PyObject *resultobj = 0;
33188 wxVisualAttributes *result = 0 ;
33189
33190 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
33191 {
33192 PyThreadState* __tstate = wxPyBeginAllowThreads();
33193 result = (wxVisualAttributes *)new_wxVisualAttributes();
33194 wxPyEndAllowThreads(__tstate);
33195 if (PyErr_Occurred()) SWIG_fail;
33196 }
33197 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
33198 return resultobj;
33199 fail:
33200 return NULL;
33201 }
33202
33203
33204 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33205 PyObject *resultobj = 0;
33206 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
33207 void *argp1 = 0 ;
33208 int res1 = 0 ;
33209 PyObject *swig_obj[1] ;
33210
33211 if (!args) SWIG_fail;
33212 swig_obj[0] = args;
33213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
33214 if (!SWIG_IsOK(res1)) {
33215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
33216 }
33217 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
33218 {
33219 PyThreadState* __tstate = wxPyBeginAllowThreads();
33220 delete_wxVisualAttributes(arg1);
33221
33222 wxPyEndAllowThreads(__tstate);
33223 if (PyErr_Occurred()) SWIG_fail;
33224 }
33225 resultobj = SWIG_Py_Void();
33226 return resultobj;
33227 fail:
33228 return NULL;
33229 }
33230
33231
33232 SWIGINTERN PyObject *_wrap_VisualAttributes__get_font(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33233 PyObject *resultobj = 0;
33234 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
33235 wxFont result;
33236 void *argp1 = 0 ;
33237 int res1 = 0 ;
33238 PyObject *swig_obj[1] ;
33239
33240 if (!args) SWIG_fail;
33241 swig_obj[0] = args;
33242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
33243 if (!SWIG_IsOK(res1)) {
33244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes__get_font" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
33245 }
33246 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
33247 {
33248 PyThreadState* __tstate = wxPyBeginAllowThreads();
33249 result = wxVisualAttributes__get_font(arg1);
33250 wxPyEndAllowThreads(__tstate);
33251 if (PyErr_Occurred()) SWIG_fail;
33252 }
33253 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
33254 return resultobj;
33255 fail:
33256 return NULL;
33257 }
33258
33259
33260 SWIGINTERN PyObject *_wrap_VisualAttributes__get_colFg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33261 PyObject *resultobj = 0;
33262 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
33263 wxColour result;
33264 void *argp1 = 0 ;
33265 int res1 = 0 ;
33266 PyObject *swig_obj[1] ;
33267
33268 if (!args) SWIG_fail;
33269 swig_obj[0] = args;
33270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
33271 if (!SWIG_IsOK(res1)) {
33272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes__get_colFg" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
33273 }
33274 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
33275 {
33276 PyThreadState* __tstate = wxPyBeginAllowThreads();
33277 result = wxVisualAttributes__get_colFg(arg1);
33278 wxPyEndAllowThreads(__tstate);
33279 if (PyErr_Occurred()) SWIG_fail;
33280 }
33281 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
33282 return resultobj;
33283 fail:
33284 return NULL;
33285 }
33286
33287
33288 SWIGINTERN PyObject *_wrap_VisualAttributes__get_colBg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33289 PyObject *resultobj = 0;
33290 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
33291 wxColour result;
33292 void *argp1 = 0 ;
33293 int res1 = 0 ;
33294 PyObject *swig_obj[1] ;
33295
33296 if (!args) SWIG_fail;
33297 swig_obj[0] = args;
33298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
33299 if (!SWIG_IsOK(res1)) {
33300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes__get_colBg" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
33301 }
33302 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
33303 {
33304 PyThreadState* __tstate = wxPyBeginAllowThreads();
33305 result = wxVisualAttributes__get_colBg(arg1);
33306 wxPyEndAllowThreads(__tstate);
33307 if (PyErr_Occurred()) SWIG_fail;
33308 }
33309 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
33310 return resultobj;
33311 fail:
33312 return NULL;
33313 }
33314
33315
33316 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33317 PyObject *obj;
33318 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33319 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
33320 return SWIG_Py_Void();
33321 }
33322
33323 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33324 return SWIG_Python_InitShadowInstance(args);
33325 }
33326
33327 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33328 PyObject *resultobj = 0;
33329 wxWindow *arg1 = (wxWindow *) 0 ;
33330 int arg2 = (int) (int)-1 ;
33331 wxPoint const &arg3_defvalue = wxDefaultPosition ;
33332 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
33333 wxSize const &arg4_defvalue = wxDefaultSize ;
33334 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
33335 long arg5 = (long) 0 ;
33336 wxString const &arg6_defvalue = wxPyPanelNameStr ;
33337 wxString *arg6 = (wxString *) &arg6_defvalue ;
33338 wxWindow *result = 0 ;
33339 void *argp1 = 0 ;
33340 int res1 = 0 ;
33341 int val2 ;
33342 int ecode2 = 0 ;
33343 wxPoint temp3 ;
33344 wxSize temp4 ;
33345 long val5 ;
33346 int ecode5 = 0 ;
33347 bool temp6 = false ;
33348 PyObject * obj0 = 0 ;
33349 PyObject * obj1 = 0 ;
33350 PyObject * obj2 = 0 ;
33351 PyObject * obj3 = 0 ;
33352 PyObject * obj4 = 0 ;
33353 PyObject * obj5 = 0 ;
33354 char * kwnames[] = {
33355 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
33356 };
33357
33358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
33359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33360 if (!SWIG_IsOK(res1)) {
33361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
33362 }
33363 arg1 = reinterpret_cast< wxWindow * >(argp1);
33364 if (obj1) {
33365 ecode2 = SWIG_AsVal_int(obj1, &val2);
33366 if (!SWIG_IsOK(ecode2)) {
33367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
33368 }
33369 arg2 = static_cast< int >(val2);
33370 }
33371 if (obj2) {
33372 {
33373 arg3 = &temp3;
33374 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
33375 }
33376 }
33377 if (obj3) {
33378 {
33379 arg4 = &temp4;
33380 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
33381 }
33382 }
33383 if (obj4) {
33384 ecode5 = SWIG_AsVal_long(obj4, &val5);
33385 if (!SWIG_IsOK(ecode5)) {
33386 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
33387 }
33388 arg5 = static_cast< long >(val5);
33389 }
33390 if (obj5) {
33391 {
33392 arg6 = wxString_in_helper(obj5);
33393 if (arg6 == NULL) SWIG_fail;
33394 temp6 = true;
33395 }
33396 }
33397 {
33398 if (!wxPyCheckForApp()) SWIG_fail;
33399 PyThreadState* __tstate = wxPyBeginAllowThreads();
33400 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
33401 wxPyEndAllowThreads(__tstate);
33402 if (PyErr_Occurred()) SWIG_fail;
33403 }
33404 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
33405 {
33406 if (temp6)
33407 delete arg6;
33408 }
33409 return resultobj;
33410 fail:
33411 {
33412 if (temp6)
33413 delete arg6;
33414 }
33415 return NULL;
33416 }
33417
33418
33419 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33420 PyObject *resultobj = 0;
33421 wxWindow *result = 0 ;
33422
33423 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
33424 {
33425 if (!wxPyCheckForApp()) SWIG_fail;
33426 PyThreadState* __tstate = wxPyBeginAllowThreads();
33427 result = (wxWindow *)new wxWindow();
33428 wxPyEndAllowThreads(__tstate);
33429 if (PyErr_Occurred()) SWIG_fail;
33430 }
33431 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
33432 return resultobj;
33433 fail:
33434 return NULL;
33435 }
33436
33437
33438 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33439 PyObject *resultobj = 0;
33440 wxWindow *arg1 = (wxWindow *) 0 ;
33441 wxWindow *arg2 = (wxWindow *) 0 ;
33442 int arg3 = (int) (int)-1 ;
33443 wxPoint const &arg4_defvalue = wxDefaultPosition ;
33444 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
33445 wxSize const &arg5_defvalue = wxDefaultSize ;
33446 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
33447 long arg6 = (long) 0 ;
33448 wxString const &arg7_defvalue = wxPyPanelNameStr ;
33449 wxString *arg7 = (wxString *) &arg7_defvalue ;
33450 bool result;
33451 void *argp1 = 0 ;
33452 int res1 = 0 ;
33453 void *argp2 = 0 ;
33454 int res2 = 0 ;
33455 int val3 ;
33456 int ecode3 = 0 ;
33457 wxPoint temp4 ;
33458 wxSize temp5 ;
33459 long val6 ;
33460 int ecode6 = 0 ;
33461 bool temp7 = false ;
33462 PyObject * obj0 = 0 ;
33463 PyObject * obj1 = 0 ;
33464 PyObject * obj2 = 0 ;
33465 PyObject * obj3 = 0 ;
33466 PyObject * obj4 = 0 ;
33467 PyObject * obj5 = 0 ;
33468 PyObject * obj6 = 0 ;
33469 char * kwnames[] = {
33470 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
33471 };
33472
33473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
33474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33475 if (!SWIG_IsOK(res1)) {
33476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
33477 }
33478 arg1 = reinterpret_cast< wxWindow * >(argp1);
33479 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33480 if (!SWIG_IsOK(res2)) {
33481 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
33482 }
33483 arg2 = reinterpret_cast< wxWindow * >(argp2);
33484 if (obj2) {
33485 ecode3 = SWIG_AsVal_int(obj2, &val3);
33486 if (!SWIG_IsOK(ecode3)) {
33487 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
33488 }
33489 arg3 = static_cast< int >(val3);
33490 }
33491 if (obj3) {
33492 {
33493 arg4 = &temp4;
33494 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
33495 }
33496 }
33497 if (obj4) {
33498 {
33499 arg5 = &temp5;
33500 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
33501 }
33502 }
33503 if (obj5) {
33504 ecode6 = SWIG_AsVal_long(obj5, &val6);
33505 if (!SWIG_IsOK(ecode6)) {
33506 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
33507 }
33508 arg6 = static_cast< long >(val6);
33509 }
33510 if (obj6) {
33511 {
33512 arg7 = wxString_in_helper(obj6);
33513 if (arg7 == NULL) SWIG_fail;
33514 temp7 = true;
33515 }
33516 }
33517 {
33518 PyThreadState* __tstate = wxPyBeginAllowThreads();
33519 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
33520 wxPyEndAllowThreads(__tstate);
33521 if (PyErr_Occurred()) SWIG_fail;
33522 }
33523 {
33524 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33525 }
33526 {
33527 if (temp7)
33528 delete arg7;
33529 }
33530 return resultobj;
33531 fail:
33532 {
33533 if (temp7)
33534 delete arg7;
33535 }
33536 return NULL;
33537 }
33538
33539
33540 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33541 PyObject *resultobj = 0;
33542 wxWindow *arg1 = (wxWindow *) 0 ;
33543 bool arg2 = (bool) false ;
33544 bool result;
33545 void *argp1 = 0 ;
33546 int res1 = 0 ;
33547 bool val2 ;
33548 int ecode2 = 0 ;
33549 PyObject * obj0 = 0 ;
33550 PyObject * obj1 = 0 ;
33551 char * kwnames[] = {
33552 (char *) "self",(char *) "force", NULL
33553 };
33554
33555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
33556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33557 if (!SWIG_IsOK(res1)) {
33558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
33559 }
33560 arg1 = reinterpret_cast< wxWindow * >(argp1);
33561 if (obj1) {
33562 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33563 if (!SWIG_IsOK(ecode2)) {
33564 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
33565 }
33566 arg2 = static_cast< bool >(val2);
33567 }
33568 {
33569 PyThreadState* __tstate = wxPyBeginAllowThreads();
33570 result = (bool)(arg1)->Close(arg2);
33571 wxPyEndAllowThreads(__tstate);
33572 if (PyErr_Occurred()) SWIG_fail;
33573 }
33574 {
33575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33576 }
33577 return resultobj;
33578 fail:
33579 return NULL;
33580 }
33581
33582
33583 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33584 PyObject *resultobj = 0;
33585 wxWindow *arg1 = (wxWindow *) 0 ;
33586 bool result;
33587 void *argp1 = 0 ;
33588 int res1 = 0 ;
33589 PyObject *swig_obj[1] ;
33590
33591 if (!args) SWIG_fail;
33592 swig_obj[0] = args;
33593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33594 if (!SWIG_IsOK(res1)) {
33595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
33596 }
33597 arg1 = reinterpret_cast< wxWindow * >(argp1);
33598 {
33599 PyThreadState* __tstate = wxPyBeginAllowThreads();
33600 result = (bool)(arg1)->Destroy();
33601 wxPyEndAllowThreads(__tstate);
33602 if (PyErr_Occurred()) SWIG_fail;
33603 }
33604 {
33605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33606 }
33607 return resultobj;
33608 fail:
33609 return NULL;
33610 }
33611
33612
33613 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33614 PyObject *resultobj = 0;
33615 wxWindow *arg1 = (wxWindow *) 0 ;
33616 bool result;
33617 void *argp1 = 0 ;
33618 int res1 = 0 ;
33619 PyObject *swig_obj[1] ;
33620
33621 if (!args) SWIG_fail;
33622 swig_obj[0] = args;
33623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33624 if (!SWIG_IsOK(res1)) {
33625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33626 }
33627 arg1 = reinterpret_cast< wxWindow * >(argp1);
33628 {
33629 PyThreadState* __tstate = wxPyBeginAllowThreads();
33630 result = (bool)(arg1)->DestroyChildren();
33631 wxPyEndAllowThreads(__tstate);
33632 if (PyErr_Occurred()) SWIG_fail;
33633 }
33634 {
33635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33636 }
33637 return resultobj;
33638 fail:
33639 return NULL;
33640 }
33641
33642
33643 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33644 PyObject *resultobj = 0;
33645 wxWindow *arg1 = (wxWindow *) 0 ;
33646 bool result;
33647 void *argp1 = 0 ;
33648 int res1 = 0 ;
33649 PyObject *swig_obj[1] ;
33650
33651 if (!args) SWIG_fail;
33652 swig_obj[0] = args;
33653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33654 if (!SWIG_IsOK(res1)) {
33655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
33656 }
33657 arg1 = reinterpret_cast< wxWindow * >(argp1);
33658 {
33659 PyThreadState* __tstate = wxPyBeginAllowThreads();
33660 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
33661 wxPyEndAllowThreads(__tstate);
33662 if (PyErr_Occurred()) SWIG_fail;
33663 }
33664 {
33665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33666 }
33667 return resultobj;
33668 fail:
33669 return NULL;
33670 }
33671
33672
33673 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33674 PyObject *resultobj = 0;
33675 wxWindow *arg1 = (wxWindow *) 0 ;
33676 wxString *arg2 = 0 ;
33677 void *argp1 = 0 ;
33678 int res1 = 0 ;
33679 bool temp2 = false ;
33680 PyObject * obj0 = 0 ;
33681 PyObject * obj1 = 0 ;
33682 char * kwnames[] = {
33683 (char *) "self",(char *) "label", NULL
33684 };
33685
33686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
33687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33688 if (!SWIG_IsOK(res1)) {
33689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
33690 }
33691 arg1 = reinterpret_cast< wxWindow * >(argp1);
33692 {
33693 arg2 = wxString_in_helper(obj1);
33694 if (arg2 == NULL) SWIG_fail;
33695 temp2 = true;
33696 }
33697 {
33698 PyThreadState* __tstate = wxPyBeginAllowThreads();
33699 (arg1)->SetLabel((wxString const &)*arg2);
33700 wxPyEndAllowThreads(__tstate);
33701 if (PyErr_Occurred()) SWIG_fail;
33702 }
33703 resultobj = SWIG_Py_Void();
33704 {
33705 if (temp2)
33706 delete arg2;
33707 }
33708 return resultobj;
33709 fail:
33710 {
33711 if (temp2)
33712 delete arg2;
33713 }
33714 return NULL;
33715 }
33716
33717
33718 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33719 PyObject *resultobj = 0;
33720 wxWindow *arg1 = (wxWindow *) 0 ;
33721 wxString result;
33722 void *argp1 = 0 ;
33723 int res1 = 0 ;
33724 PyObject *swig_obj[1] ;
33725
33726 if (!args) SWIG_fail;
33727 swig_obj[0] = args;
33728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33729 if (!SWIG_IsOK(res1)) {
33730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33731 }
33732 arg1 = reinterpret_cast< wxWindow * >(argp1);
33733 {
33734 PyThreadState* __tstate = wxPyBeginAllowThreads();
33735 result = ((wxWindow const *)arg1)->GetLabel();
33736 wxPyEndAllowThreads(__tstate);
33737 if (PyErr_Occurred()) SWIG_fail;
33738 }
33739 {
33740 #if wxUSE_UNICODE
33741 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33742 #else
33743 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33744 #endif
33745 }
33746 return resultobj;
33747 fail:
33748 return NULL;
33749 }
33750
33751
33752 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33753 PyObject *resultobj = 0;
33754 wxWindow *arg1 = (wxWindow *) 0 ;
33755 wxString *arg2 = 0 ;
33756 void *argp1 = 0 ;
33757 int res1 = 0 ;
33758 bool temp2 = false ;
33759 PyObject * obj0 = 0 ;
33760 PyObject * obj1 = 0 ;
33761 char * kwnames[] = {
33762 (char *) "self",(char *) "name", NULL
33763 };
33764
33765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
33766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33767 if (!SWIG_IsOK(res1)) {
33768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
33769 }
33770 arg1 = reinterpret_cast< wxWindow * >(argp1);
33771 {
33772 arg2 = wxString_in_helper(obj1);
33773 if (arg2 == NULL) SWIG_fail;
33774 temp2 = true;
33775 }
33776 {
33777 PyThreadState* __tstate = wxPyBeginAllowThreads();
33778 (arg1)->SetName((wxString const &)*arg2);
33779 wxPyEndAllowThreads(__tstate);
33780 if (PyErr_Occurred()) SWIG_fail;
33781 }
33782 resultobj = SWIG_Py_Void();
33783 {
33784 if (temp2)
33785 delete arg2;
33786 }
33787 return resultobj;
33788 fail:
33789 {
33790 if (temp2)
33791 delete arg2;
33792 }
33793 return NULL;
33794 }
33795
33796
33797 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33798 PyObject *resultobj = 0;
33799 wxWindow *arg1 = (wxWindow *) 0 ;
33800 wxString result;
33801 void *argp1 = 0 ;
33802 int res1 = 0 ;
33803 PyObject *swig_obj[1] ;
33804
33805 if (!args) SWIG_fail;
33806 swig_obj[0] = args;
33807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33808 if (!SWIG_IsOK(res1)) {
33809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
33810 }
33811 arg1 = reinterpret_cast< wxWindow * >(argp1);
33812 {
33813 PyThreadState* __tstate = wxPyBeginAllowThreads();
33814 result = ((wxWindow const *)arg1)->GetName();
33815 wxPyEndAllowThreads(__tstate);
33816 if (PyErr_Occurred()) SWIG_fail;
33817 }
33818 {
33819 #if wxUSE_UNICODE
33820 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33821 #else
33822 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33823 #endif
33824 }
33825 return resultobj;
33826 fail:
33827 return NULL;
33828 }
33829
33830
33831 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33832 PyObject *resultobj = 0;
33833 wxWindow *arg1 = (wxWindow *) 0 ;
33834 wxWindowVariant arg2 ;
33835 void *argp1 = 0 ;
33836 int res1 = 0 ;
33837 int val2 ;
33838 int ecode2 = 0 ;
33839 PyObject * obj0 = 0 ;
33840 PyObject * obj1 = 0 ;
33841 char * kwnames[] = {
33842 (char *) "self",(char *) "variant", NULL
33843 };
33844
33845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
33846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33847 if (!SWIG_IsOK(res1)) {
33848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
33849 }
33850 arg1 = reinterpret_cast< wxWindow * >(argp1);
33851 ecode2 = SWIG_AsVal_int(obj1, &val2);
33852 if (!SWIG_IsOK(ecode2)) {
33853 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
33854 }
33855 arg2 = static_cast< wxWindowVariant >(val2);
33856 {
33857 PyThreadState* __tstate = wxPyBeginAllowThreads();
33858 (arg1)->SetWindowVariant(arg2);
33859 wxPyEndAllowThreads(__tstate);
33860 if (PyErr_Occurred()) SWIG_fail;
33861 }
33862 resultobj = SWIG_Py_Void();
33863 return resultobj;
33864 fail:
33865 return NULL;
33866 }
33867
33868
33869 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33870 PyObject *resultobj = 0;
33871 wxWindow *arg1 = (wxWindow *) 0 ;
33872 wxWindowVariant result;
33873 void *argp1 = 0 ;
33874 int res1 = 0 ;
33875 PyObject *swig_obj[1] ;
33876
33877 if (!args) SWIG_fail;
33878 swig_obj[0] = args;
33879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33880 if (!SWIG_IsOK(res1)) {
33881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
33882 }
33883 arg1 = reinterpret_cast< wxWindow * >(argp1);
33884 {
33885 PyThreadState* __tstate = wxPyBeginAllowThreads();
33886 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
33887 wxPyEndAllowThreads(__tstate);
33888 if (PyErr_Occurred()) SWIG_fail;
33889 }
33890 resultobj = SWIG_From_int(static_cast< int >(result));
33891 return resultobj;
33892 fail:
33893 return NULL;
33894 }
33895
33896
33897 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33898 PyObject *resultobj = 0;
33899 wxWindow *arg1 = (wxWindow *) 0 ;
33900 int arg2 ;
33901 void *argp1 = 0 ;
33902 int res1 = 0 ;
33903 int val2 ;
33904 int ecode2 = 0 ;
33905 PyObject * obj0 = 0 ;
33906 PyObject * obj1 = 0 ;
33907 char * kwnames[] = {
33908 (char *) "self",(char *) "winid", NULL
33909 };
33910
33911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
33912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33913 if (!SWIG_IsOK(res1)) {
33914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
33915 }
33916 arg1 = reinterpret_cast< wxWindow * >(argp1);
33917 ecode2 = SWIG_AsVal_int(obj1, &val2);
33918 if (!SWIG_IsOK(ecode2)) {
33919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
33920 }
33921 arg2 = static_cast< int >(val2);
33922 {
33923 PyThreadState* __tstate = wxPyBeginAllowThreads();
33924 (arg1)->SetId(arg2);
33925 wxPyEndAllowThreads(__tstate);
33926 if (PyErr_Occurred()) SWIG_fail;
33927 }
33928 resultobj = SWIG_Py_Void();
33929 return resultobj;
33930 fail:
33931 return NULL;
33932 }
33933
33934
33935 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33936 PyObject *resultobj = 0;
33937 wxWindow *arg1 = (wxWindow *) 0 ;
33938 int result;
33939 void *argp1 = 0 ;
33940 int res1 = 0 ;
33941 PyObject *swig_obj[1] ;
33942
33943 if (!args) SWIG_fail;
33944 swig_obj[0] = args;
33945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33946 if (!SWIG_IsOK(res1)) {
33947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
33948 }
33949 arg1 = reinterpret_cast< wxWindow * >(argp1);
33950 {
33951 PyThreadState* __tstate = wxPyBeginAllowThreads();
33952 result = (int)((wxWindow const *)arg1)->GetId();
33953 wxPyEndAllowThreads(__tstate);
33954 if (PyErr_Occurred()) SWIG_fail;
33955 }
33956 resultobj = SWIG_From_int(static_cast< int >(result));
33957 return resultobj;
33958 fail:
33959 return NULL;
33960 }
33961
33962
33963 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33964 PyObject *resultobj = 0;
33965 int result;
33966
33967 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
33968 {
33969 PyThreadState* __tstate = wxPyBeginAllowThreads();
33970 result = (int)wxWindow::NewControlId();
33971 wxPyEndAllowThreads(__tstate);
33972 if (PyErr_Occurred()) SWIG_fail;
33973 }
33974 resultobj = SWIG_From_int(static_cast< int >(result));
33975 return resultobj;
33976 fail:
33977 return NULL;
33978 }
33979
33980
33981 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33982 PyObject *resultobj = 0;
33983 int arg1 ;
33984 int result;
33985 int val1 ;
33986 int ecode1 = 0 ;
33987 PyObject * obj0 = 0 ;
33988 char * kwnames[] = {
33989 (char *) "winid", NULL
33990 };
33991
33992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
33993 ecode1 = SWIG_AsVal_int(obj0, &val1);
33994 if (!SWIG_IsOK(ecode1)) {
33995 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
33996 }
33997 arg1 = static_cast< int >(val1);
33998 {
33999 PyThreadState* __tstate = wxPyBeginAllowThreads();
34000 result = (int)wxWindow::NextControlId(arg1);
34001 wxPyEndAllowThreads(__tstate);
34002 if (PyErr_Occurred()) SWIG_fail;
34003 }
34004 resultobj = SWIG_From_int(static_cast< int >(result));
34005 return resultobj;
34006 fail:
34007 return NULL;
34008 }
34009
34010
34011 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34012 PyObject *resultobj = 0;
34013 int arg1 ;
34014 int result;
34015 int val1 ;
34016 int ecode1 = 0 ;
34017 PyObject * obj0 = 0 ;
34018 char * kwnames[] = {
34019 (char *) "winid", NULL
34020 };
34021
34022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
34023 ecode1 = SWIG_AsVal_int(obj0, &val1);
34024 if (!SWIG_IsOK(ecode1)) {
34025 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
34026 }
34027 arg1 = static_cast< int >(val1);
34028 {
34029 PyThreadState* __tstate = wxPyBeginAllowThreads();
34030 result = (int)wxWindow::PrevControlId(arg1);
34031 wxPyEndAllowThreads(__tstate);
34032 if (PyErr_Occurred()) SWIG_fail;
34033 }
34034 resultobj = SWIG_From_int(static_cast< int >(result));
34035 return resultobj;
34036 fail:
34037 return NULL;
34038 }
34039
34040
34041 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34042 PyObject *resultobj = 0;
34043 wxWindow *arg1 = (wxWindow *) 0 ;
34044 wxLayoutDirection result;
34045 void *argp1 = 0 ;
34046 int res1 = 0 ;
34047 PyObject *swig_obj[1] ;
34048
34049 if (!args) SWIG_fail;
34050 swig_obj[0] = args;
34051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34052 if (!SWIG_IsOK(res1)) {
34053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
34054 }
34055 arg1 = reinterpret_cast< wxWindow * >(argp1);
34056 {
34057 PyThreadState* __tstate = wxPyBeginAllowThreads();
34058 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
34059 wxPyEndAllowThreads(__tstate);
34060 if (PyErr_Occurred()) SWIG_fail;
34061 }
34062 resultobj = SWIG_From_int(static_cast< int >(result));
34063 return resultobj;
34064 fail:
34065 return NULL;
34066 }
34067
34068
34069 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34070 PyObject *resultobj = 0;
34071 wxWindow *arg1 = (wxWindow *) 0 ;
34072 wxLayoutDirection arg2 ;
34073 void *argp1 = 0 ;
34074 int res1 = 0 ;
34075 int val2 ;
34076 int ecode2 = 0 ;
34077 PyObject * obj0 = 0 ;
34078 PyObject * obj1 = 0 ;
34079 char * kwnames[] = {
34080 (char *) "self",(char *) "dir", NULL
34081 };
34082
34083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
34084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34085 if (!SWIG_IsOK(res1)) {
34086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
34087 }
34088 arg1 = reinterpret_cast< wxWindow * >(argp1);
34089 ecode2 = SWIG_AsVal_int(obj1, &val2);
34090 if (!SWIG_IsOK(ecode2)) {
34091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
34092 }
34093 arg2 = static_cast< wxLayoutDirection >(val2);
34094 {
34095 PyThreadState* __tstate = wxPyBeginAllowThreads();
34096 (arg1)->SetLayoutDirection(arg2);
34097 wxPyEndAllowThreads(__tstate);
34098 if (PyErr_Occurred()) SWIG_fail;
34099 }
34100 resultobj = SWIG_Py_Void();
34101 return resultobj;
34102 fail:
34103 return NULL;
34104 }
34105
34106
34107 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34108 PyObject *resultobj = 0;
34109 wxWindow *arg1 = (wxWindow *) 0 ;
34110 int arg2 ;
34111 int arg3 ;
34112 int arg4 ;
34113 int result;
34114 void *argp1 = 0 ;
34115 int res1 = 0 ;
34116 int val2 ;
34117 int ecode2 = 0 ;
34118 int val3 ;
34119 int ecode3 = 0 ;
34120 int val4 ;
34121 int ecode4 = 0 ;
34122 PyObject * obj0 = 0 ;
34123 PyObject * obj1 = 0 ;
34124 PyObject * obj2 = 0 ;
34125 PyObject * obj3 = 0 ;
34126 char * kwnames[] = {
34127 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
34128 };
34129
34130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34132 if (!SWIG_IsOK(res1)) {
34133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
34134 }
34135 arg1 = reinterpret_cast< wxWindow * >(argp1);
34136 ecode2 = SWIG_AsVal_int(obj1, &val2);
34137 if (!SWIG_IsOK(ecode2)) {
34138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
34139 }
34140 arg2 = static_cast< int >(val2);
34141 ecode3 = SWIG_AsVal_int(obj2, &val3);
34142 if (!SWIG_IsOK(ecode3)) {
34143 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
34144 }
34145 arg3 = static_cast< int >(val3);
34146 ecode4 = SWIG_AsVal_int(obj3, &val4);
34147 if (!SWIG_IsOK(ecode4)) {
34148 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
34149 }
34150 arg4 = static_cast< int >(val4);
34151 {
34152 PyThreadState* __tstate = wxPyBeginAllowThreads();
34153 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
34154 wxPyEndAllowThreads(__tstate);
34155 if (PyErr_Occurred()) SWIG_fail;
34156 }
34157 resultobj = SWIG_From_int(static_cast< int >(result));
34158 return resultobj;
34159 fail:
34160 return NULL;
34161 }
34162
34163
34164 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34165 PyObject *resultobj = 0;
34166 wxWindow *arg1 = (wxWindow *) 0 ;
34167 wxSize *arg2 = 0 ;
34168 void *argp1 = 0 ;
34169 int res1 = 0 ;
34170 wxSize temp2 ;
34171 PyObject * obj0 = 0 ;
34172 PyObject * obj1 = 0 ;
34173 char * kwnames[] = {
34174 (char *) "self",(char *) "size", NULL
34175 };
34176
34177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
34178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34179 if (!SWIG_IsOK(res1)) {
34180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34181 }
34182 arg1 = reinterpret_cast< wxWindow * >(argp1);
34183 {
34184 arg2 = &temp2;
34185 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34186 }
34187 {
34188 PyThreadState* __tstate = wxPyBeginAllowThreads();
34189 (arg1)->SetSize((wxSize const &)*arg2);
34190 wxPyEndAllowThreads(__tstate);
34191 if (PyErr_Occurred()) SWIG_fail;
34192 }
34193 resultobj = SWIG_Py_Void();
34194 return resultobj;
34195 fail:
34196 return NULL;
34197 }
34198
34199
34200 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34201 PyObject *resultobj = 0;
34202 wxWindow *arg1 = (wxWindow *) 0 ;
34203 int arg2 ;
34204 int arg3 ;
34205 int arg4 ;
34206 int arg5 ;
34207 int arg6 = (int) wxSIZE_AUTO ;
34208 void *argp1 = 0 ;
34209 int res1 = 0 ;
34210 int val2 ;
34211 int ecode2 = 0 ;
34212 int val3 ;
34213 int ecode3 = 0 ;
34214 int val4 ;
34215 int ecode4 = 0 ;
34216 int val5 ;
34217 int ecode5 = 0 ;
34218 int val6 ;
34219 int ecode6 = 0 ;
34220 PyObject * obj0 = 0 ;
34221 PyObject * obj1 = 0 ;
34222 PyObject * obj2 = 0 ;
34223 PyObject * obj3 = 0 ;
34224 PyObject * obj4 = 0 ;
34225 PyObject * obj5 = 0 ;
34226 char * kwnames[] = {
34227 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
34228 };
34229
34230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
34231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34232 if (!SWIG_IsOK(res1)) {
34233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
34234 }
34235 arg1 = reinterpret_cast< wxWindow * >(argp1);
34236 ecode2 = SWIG_AsVal_int(obj1, &val2);
34237 if (!SWIG_IsOK(ecode2)) {
34238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
34239 }
34240 arg2 = static_cast< int >(val2);
34241 ecode3 = SWIG_AsVal_int(obj2, &val3);
34242 if (!SWIG_IsOK(ecode3)) {
34243 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
34244 }
34245 arg3 = static_cast< int >(val3);
34246 ecode4 = SWIG_AsVal_int(obj3, &val4);
34247 if (!SWIG_IsOK(ecode4)) {
34248 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
34249 }
34250 arg4 = static_cast< int >(val4);
34251 ecode5 = SWIG_AsVal_int(obj4, &val5);
34252 if (!SWIG_IsOK(ecode5)) {
34253 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
34254 }
34255 arg5 = static_cast< int >(val5);
34256 if (obj5) {
34257 ecode6 = SWIG_AsVal_int(obj5, &val6);
34258 if (!SWIG_IsOK(ecode6)) {
34259 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
34260 }
34261 arg6 = static_cast< int >(val6);
34262 }
34263 {
34264 PyThreadState* __tstate = wxPyBeginAllowThreads();
34265 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
34266 wxPyEndAllowThreads(__tstate);
34267 if (PyErr_Occurred()) SWIG_fail;
34268 }
34269 resultobj = SWIG_Py_Void();
34270 return resultobj;
34271 fail:
34272 return NULL;
34273 }
34274
34275
34276 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34277 PyObject *resultobj = 0;
34278 wxWindow *arg1 = (wxWindow *) 0 ;
34279 wxRect *arg2 = 0 ;
34280 int arg3 = (int) wxSIZE_AUTO ;
34281 void *argp1 = 0 ;
34282 int res1 = 0 ;
34283 wxRect temp2 ;
34284 int val3 ;
34285 int ecode3 = 0 ;
34286 PyObject * obj0 = 0 ;
34287 PyObject * obj1 = 0 ;
34288 PyObject * obj2 = 0 ;
34289 char * kwnames[] = {
34290 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
34291 };
34292
34293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34295 if (!SWIG_IsOK(res1)) {
34296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34297 }
34298 arg1 = reinterpret_cast< wxWindow * >(argp1);
34299 {
34300 arg2 = &temp2;
34301 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34302 }
34303 if (obj2) {
34304 ecode3 = SWIG_AsVal_int(obj2, &val3);
34305 if (!SWIG_IsOK(ecode3)) {
34306 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
34307 }
34308 arg3 = static_cast< int >(val3);
34309 }
34310 {
34311 PyThreadState* __tstate = wxPyBeginAllowThreads();
34312 (arg1)->SetSize((wxRect const &)*arg2,arg3);
34313 wxPyEndAllowThreads(__tstate);
34314 if (PyErr_Occurred()) SWIG_fail;
34315 }
34316 resultobj = SWIG_Py_Void();
34317 return resultobj;
34318 fail:
34319 return NULL;
34320 }
34321
34322
34323 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34324 PyObject *resultobj = 0;
34325 wxWindow *arg1 = (wxWindow *) 0 ;
34326 int arg2 ;
34327 int arg3 ;
34328 void *argp1 = 0 ;
34329 int res1 = 0 ;
34330 int val2 ;
34331 int ecode2 = 0 ;
34332 int val3 ;
34333 int ecode3 = 0 ;
34334 PyObject * obj0 = 0 ;
34335 PyObject * obj1 = 0 ;
34336 PyObject * obj2 = 0 ;
34337 char * kwnames[] = {
34338 (char *) "self",(char *) "width",(char *) "height", NULL
34339 };
34340
34341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34343 if (!SWIG_IsOK(res1)) {
34344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
34345 }
34346 arg1 = reinterpret_cast< wxWindow * >(argp1);
34347 ecode2 = SWIG_AsVal_int(obj1, &val2);
34348 if (!SWIG_IsOK(ecode2)) {
34349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
34350 }
34351 arg2 = static_cast< int >(val2);
34352 ecode3 = SWIG_AsVal_int(obj2, &val3);
34353 if (!SWIG_IsOK(ecode3)) {
34354 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
34355 }
34356 arg3 = static_cast< int >(val3);
34357 {
34358 PyThreadState* __tstate = wxPyBeginAllowThreads();
34359 (arg1)->SetSize(arg2,arg3);
34360 wxPyEndAllowThreads(__tstate);
34361 if (PyErr_Occurred()) SWIG_fail;
34362 }
34363 resultobj = SWIG_Py_Void();
34364 return resultobj;
34365 fail:
34366 return NULL;
34367 }
34368
34369
34370 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34371 PyObject *resultobj = 0;
34372 wxWindow *arg1 = (wxWindow *) 0 ;
34373 wxPoint *arg2 = 0 ;
34374 int arg3 = (int) wxSIZE_USE_EXISTING ;
34375 void *argp1 = 0 ;
34376 int res1 = 0 ;
34377 wxPoint temp2 ;
34378 int val3 ;
34379 int ecode3 = 0 ;
34380 PyObject * obj0 = 0 ;
34381 PyObject * obj1 = 0 ;
34382 PyObject * obj2 = 0 ;
34383 char * kwnames[] = {
34384 (char *) "self",(char *) "pt",(char *) "flags", NULL
34385 };
34386
34387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34389 if (!SWIG_IsOK(res1)) {
34390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
34391 }
34392 arg1 = reinterpret_cast< wxWindow * >(argp1);
34393 {
34394 arg2 = &temp2;
34395 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34396 }
34397 if (obj2) {
34398 ecode3 = SWIG_AsVal_int(obj2, &val3);
34399 if (!SWIG_IsOK(ecode3)) {
34400 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
34401 }
34402 arg3 = static_cast< int >(val3);
34403 }
34404 {
34405 PyThreadState* __tstate = wxPyBeginAllowThreads();
34406 (arg1)->Move((wxPoint const &)*arg2,arg3);
34407 wxPyEndAllowThreads(__tstate);
34408 if (PyErr_Occurred()) SWIG_fail;
34409 }
34410 resultobj = SWIG_Py_Void();
34411 return resultobj;
34412 fail:
34413 return NULL;
34414 }
34415
34416
34417 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34418 PyObject *resultobj = 0;
34419 wxWindow *arg1 = (wxWindow *) 0 ;
34420 int arg2 ;
34421 int arg3 ;
34422 int arg4 = (int) wxSIZE_USE_EXISTING ;
34423 void *argp1 = 0 ;
34424 int res1 = 0 ;
34425 int val2 ;
34426 int ecode2 = 0 ;
34427 int val3 ;
34428 int ecode3 = 0 ;
34429 int val4 ;
34430 int ecode4 = 0 ;
34431 PyObject * obj0 = 0 ;
34432 PyObject * obj1 = 0 ;
34433 PyObject * obj2 = 0 ;
34434 PyObject * obj3 = 0 ;
34435 char * kwnames[] = {
34436 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
34437 };
34438
34439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34441 if (!SWIG_IsOK(res1)) {
34442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
34443 }
34444 arg1 = reinterpret_cast< wxWindow * >(argp1);
34445 ecode2 = SWIG_AsVal_int(obj1, &val2);
34446 if (!SWIG_IsOK(ecode2)) {
34447 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
34448 }
34449 arg2 = static_cast< int >(val2);
34450 ecode3 = SWIG_AsVal_int(obj2, &val3);
34451 if (!SWIG_IsOK(ecode3)) {
34452 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
34453 }
34454 arg3 = static_cast< int >(val3);
34455 if (obj3) {
34456 ecode4 = SWIG_AsVal_int(obj3, &val4);
34457 if (!SWIG_IsOK(ecode4)) {
34458 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
34459 }
34460 arg4 = static_cast< int >(val4);
34461 }
34462 {
34463 PyThreadState* __tstate = wxPyBeginAllowThreads();
34464 (arg1)->Move(arg2,arg3,arg4);
34465 wxPyEndAllowThreads(__tstate);
34466 if (PyErr_Occurred()) SWIG_fail;
34467 }
34468 resultobj = SWIG_Py_Void();
34469 return resultobj;
34470 fail:
34471 return NULL;
34472 }
34473
34474
34475 SWIGINTERN PyObject *_wrap_Window_SetInitialSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34476 PyObject *resultobj = 0;
34477 wxWindow *arg1 = (wxWindow *) 0 ;
34478 wxSize const &arg2_defvalue = wxDefaultSize ;
34479 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
34480 void *argp1 = 0 ;
34481 int res1 = 0 ;
34482 wxSize temp2 ;
34483 PyObject * obj0 = 0 ;
34484 PyObject * obj1 = 0 ;
34485 char * kwnames[] = {
34486 (char *) "self",(char *) "size", NULL
34487 };
34488
34489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetInitialSize",kwnames,&obj0,&obj1)) SWIG_fail;
34490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34491 if (!SWIG_IsOK(res1)) {
34492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetInitialSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34493 }
34494 arg1 = reinterpret_cast< wxWindow * >(argp1);
34495 if (obj1) {
34496 {
34497 arg2 = &temp2;
34498 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34499 }
34500 }
34501 {
34502 PyThreadState* __tstate = wxPyBeginAllowThreads();
34503 (arg1)->SetInitialSize((wxSize const &)*arg2);
34504 wxPyEndAllowThreads(__tstate);
34505 if (PyErr_Occurred()) SWIG_fail;
34506 }
34507 resultobj = SWIG_Py_Void();
34508 return resultobj;
34509 fail:
34510 return NULL;
34511 }
34512
34513
34514 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34515 PyObject *resultobj = 0;
34516 wxWindow *arg1 = (wxWindow *) 0 ;
34517 void *argp1 = 0 ;
34518 int res1 = 0 ;
34519 PyObject *swig_obj[1] ;
34520
34521 if (!args) SWIG_fail;
34522 swig_obj[0] = args;
34523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34524 if (!SWIG_IsOK(res1)) {
34525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
34526 }
34527 arg1 = reinterpret_cast< wxWindow * >(argp1);
34528 {
34529 PyThreadState* __tstate = wxPyBeginAllowThreads();
34530 (arg1)->Raise();
34531 wxPyEndAllowThreads(__tstate);
34532 if (PyErr_Occurred()) SWIG_fail;
34533 }
34534 resultobj = SWIG_Py_Void();
34535 return resultobj;
34536 fail:
34537 return NULL;
34538 }
34539
34540
34541 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34542 PyObject *resultobj = 0;
34543 wxWindow *arg1 = (wxWindow *) 0 ;
34544 void *argp1 = 0 ;
34545 int res1 = 0 ;
34546 PyObject *swig_obj[1] ;
34547
34548 if (!args) SWIG_fail;
34549 swig_obj[0] = args;
34550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34551 if (!SWIG_IsOK(res1)) {
34552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
34553 }
34554 arg1 = reinterpret_cast< wxWindow * >(argp1);
34555 {
34556 PyThreadState* __tstate = wxPyBeginAllowThreads();
34557 (arg1)->Lower();
34558 wxPyEndAllowThreads(__tstate);
34559 if (PyErr_Occurred()) SWIG_fail;
34560 }
34561 resultobj = SWIG_Py_Void();
34562 return resultobj;
34563 fail:
34564 return NULL;
34565 }
34566
34567
34568 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34569 PyObject *resultobj = 0;
34570 wxWindow *arg1 = (wxWindow *) 0 ;
34571 wxSize *arg2 = 0 ;
34572 void *argp1 = 0 ;
34573 int res1 = 0 ;
34574 wxSize temp2 ;
34575 PyObject * obj0 = 0 ;
34576 PyObject * obj1 = 0 ;
34577 char * kwnames[] = {
34578 (char *) "self",(char *) "size", NULL
34579 };
34580
34581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
34582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34583 if (!SWIG_IsOK(res1)) {
34584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34585 }
34586 arg1 = reinterpret_cast< wxWindow * >(argp1);
34587 {
34588 arg2 = &temp2;
34589 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34590 }
34591 {
34592 PyThreadState* __tstate = wxPyBeginAllowThreads();
34593 (arg1)->SetClientSize((wxSize const &)*arg2);
34594 wxPyEndAllowThreads(__tstate);
34595 if (PyErr_Occurred()) SWIG_fail;
34596 }
34597 resultobj = SWIG_Py_Void();
34598 return resultobj;
34599 fail:
34600 return NULL;
34601 }
34602
34603
34604 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34605 PyObject *resultobj = 0;
34606 wxWindow *arg1 = (wxWindow *) 0 ;
34607 int arg2 ;
34608 int arg3 ;
34609 void *argp1 = 0 ;
34610 int res1 = 0 ;
34611 int val2 ;
34612 int ecode2 = 0 ;
34613 int val3 ;
34614 int ecode3 = 0 ;
34615 PyObject * obj0 = 0 ;
34616 PyObject * obj1 = 0 ;
34617 PyObject * obj2 = 0 ;
34618 char * kwnames[] = {
34619 (char *) "self",(char *) "width",(char *) "height", NULL
34620 };
34621
34622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34624 if (!SWIG_IsOK(res1)) {
34625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
34626 }
34627 arg1 = reinterpret_cast< wxWindow * >(argp1);
34628 ecode2 = SWIG_AsVal_int(obj1, &val2);
34629 if (!SWIG_IsOK(ecode2)) {
34630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
34631 }
34632 arg2 = static_cast< int >(val2);
34633 ecode3 = SWIG_AsVal_int(obj2, &val3);
34634 if (!SWIG_IsOK(ecode3)) {
34635 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
34636 }
34637 arg3 = static_cast< int >(val3);
34638 {
34639 PyThreadState* __tstate = wxPyBeginAllowThreads();
34640 (arg1)->SetClientSize(arg2,arg3);
34641 wxPyEndAllowThreads(__tstate);
34642 if (PyErr_Occurred()) SWIG_fail;
34643 }
34644 resultobj = SWIG_Py_Void();
34645 return resultobj;
34646 fail:
34647 return NULL;
34648 }
34649
34650
34651 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34652 PyObject *resultobj = 0;
34653 wxWindow *arg1 = (wxWindow *) 0 ;
34654 wxRect *arg2 = 0 ;
34655 void *argp1 = 0 ;
34656 int res1 = 0 ;
34657 wxRect temp2 ;
34658 PyObject * obj0 = 0 ;
34659 PyObject * obj1 = 0 ;
34660 char * kwnames[] = {
34661 (char *) "self",(char *) "rect", NULL
34662 };
34663
34664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
34665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34666 if (!SWIG_IsOK(res1)) {
34667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34668 }
34669 arg1 = reinterpret_cast< wxWindow * >(argp1);
34670 {
34671 arg2 = &temp2;
34672 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34673 }
34674 {
34675 PyThreadState* __tstate = wxPyBeginAllowThreads();
34676 (arg1)->SetClientSize((wxRect const &)*arg2);
34677 wxPyEndAllowThreads(__tstate);
34678 if (PyErr_Occurred()) SWIG_fail;
34679 }
34680 resultobj = SWIG_Py_Void();
34681 return resultobj;
34682 fail:
34683 return NULL;
34684 }
34685
34686
34687 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34688 PyObject *resultobj = 0;
34689 wxWindow *arg1 = (wxWindow *) 0 ;
34690 wxPoint result;
34691 void *argp1 = 0 ;
34692 int res1 = 0 ;
34693 PyObject *swig_obj[1] ;
34694
34695 if (!args) SWIG_fail;
34696 swig_obj[0] = args;
34697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34698 if (!SWIG_IsOK(res1)) {
34699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34700 }
34701 arg1 = reinterpret_cast< wxWindow * >(argp1);
34702 {
34703 PyThreadState* __tstate = wxPyBeginAllowThreads();
34704 result = ((wxWindow const *)arg1)->GetPosition();
34705 wxPyEndAllowThreads(__tstate);
34706 if (PyErr_Occurred()) SWIG_fail;
34707 }
34708 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34709 return resultobj;
34710 fail:
34711 return NULL;
34712 }
34713
34714
34715 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34716 PyObject *resultobj = 0;
34717 wxWindow *arg1 = (wxWindow *) 0 ;
34718 int *arg2 = (int *) 0 ;
34719 int *arg3 = (int *) 0 ;
34720 void *argp1 = 0 ;
34721 int res1 = 0 ;
34722 int temp2 ;
34723 int res2 = SWIG_TMPOBJ ;
34724 int temp3 ;
34725 int res3 = SWIG_TMPOBJ ;
34726 PyObject *swig_obj[1] ;
34727
34728 arg2 = &temp2;
34729 arg3 = &temp3;
34730 if (!args) SWIG_fail;
34731 swig_obj[0] = args;
34732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34733 if (!SWIG_IsOK(res1)) {
34734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34735 }
34736 arg1 = reinterpret_cast< wxWindow * >(argp1);
34737 {
34738 PyThreadState* __tstate = wxPyBeginAllowThreads();
34739 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
34740 wxPyEndAllowThreads(__tstate);
34741 if (PyErr_Occurred()) SWIG_fail;
34742 }
34743 resultobj = SWIG_Py_Void();
34744 if (SWIG_IsTmpObj(res2)) {
34745 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34746 } else {
34747 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34748 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34749 }
34750 if (SWIG_IsTmpObj(res3)) {
34751 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34752 } else {
34753 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34754 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34755 }
34756 return resultobj;
34757 fail:
34758 return NULL;
34759 }
34760
34761
34762 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34763 PyObject *resultobj = 0;
34764 wxWindow *arg1 = (wxWindow *) 0 ;
34765 wxPoint result;
34766 void *argp1 = 0 ;
34767 int res1 = 0 ;
34768 PyObject *swig_obj[1] ;
34769
34770 if (!args) SWIG_fail;
34771 swig_obj[0] = args;
34772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34773 if (!SWIG_IsOK(res1)) {
34774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34775 }
34776 arg1 = reinterpret_cast< wxWindow * >(argp1);
34777 {
34778 PyThreadState* __tstate = wxPyBeginAllowThreads();
34779 result = ((wxWindow const *)arg1)->GetScreenPosition();
34780 wxPyEndAllowThreads(__tstate);
34781 if (PyErr_Occurred()) SWIG_fail;
34782 }
34783 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34784 return resultobj;
34785 fail:
34786 return NULL;
34787 }
34788
34789
34790 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34791 PyObject *resultobj = 0;
34792 wxWindow *arg1 = (wxWindow *) 0 ;
34793 int *arg2 = (int *) 0 ;
34794 int *arg3 = (int *) 0 ;
34795 void *argp1 = 0 ;
34796 int res1 = 0 ;
34797 int temp2 ;
34798 int res2 = SWIG_TMPOBJ ;
34799 int temp3 ;
34800 int res3 = SWIG_TMPOBJ ;
34801 PyObject *swig_obj[1] ;
34802
34803 arg2 = &temp2;
34804 arg3 = &temp3;
34805 if (!args) SWIG_fail;
34806 swig_obj[0] = args;
34807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34808 if (!SWIG_IsOK(res1)) {
34809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34810 }
34811 arg1 = reinterpret_cast< wxWindow * >(argp1);
34812 {
34813 PyThreadState* __tstate = wxPyBeginAllowThreads();
34814 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
34815 wxPyEndAllowThreads(__tstate);
34816 if (PyErr_Occurred()) SWIG_fail;
34817 }
34818 resultobj = SWIG_Py_Void();
34819 if (SWIG_IsTmpObj(res2)) {
34820 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34821 } else {
34822 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34823 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34824 }
34825 if (SWIG_IsTmpObj(res3)) {
34826 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34827 } else {
34828 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34829 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34830 }
34831 return resultobj;
34832 fail:
34833 return NULL;
34834 }
34835
34836
34837 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34838 PyObject *resultobj = 0;
34839 wxWindow *arg1 = (wxWindow *) 0 ;
34840 wxRect result;
34841 void *argp1 = 0 ;
34842 int res1 = 0 ;
34843 PyObject *swig_obj[1] ;
34844
34845 if (!args) SWIG_fail;
34846 swig_obj[0] = args;
34847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34848 if (!SWIG_IsOK(res1)) {
34849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34850 }
34851 arg1 = reinterpret_cast< wxWindow * >(argp1);
34852 {
34853 PyThreadState* __tstate = wxPyBeginAllowThreads();
34854 result = ((wxWindow const *)arg1)->GetScreenRect();
34855 wxPyEndAllowThreads(__tstate);
34856 if (PyErr_Occurred()) SWIG_fail;
34857 }
34858 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34859 return resultobj;
34860 fail:
34861 return NULL;
34862 }
34863
34864
34865 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34866 PyObject *resultobj = 0;
34867 wxWindow *arg1 = (wxWindow *) 0 ;
34868 wxSize result;
34869 void *argp1 = 0 ;
34870 int res1 = 0 ;
34871 PyObject *swig_obj[1] ;
34872
34873 if (!args) SWIG_fail;
34874 swig_obj[0] = args;
34875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34876 if (!SWIG_IsOK(res1)) {
34877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34878 }
34879 arg1 = reinterpret_cast< wxWindow * >(argp1);
34880 {
34881 PyThreadState* __tstate = wxPyBeginAllowThreads();
34882 result = ((wxWindow const *)arg1)->GetSize();
34883 wxPyEndAllowThreads(__tstate);
34884 if (PyErr_Occurred()) SWIG_fail;
34885 }
34886 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34887 return resultobj;
34888 fail:
34889 return NULL;
34890 }
34891
34892
34893 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34894 PyObject *resultobj = 0;
34895 wxWindow *arg1 = (wxWindow *) 0 ;
34896 int *arg2 = (int *) 0 ;
34897 int *arg3 = (int *) 0 ;
34898 void *argp1 = 0 ;
34899 int res1 = 0 ;
34900 int temp2 ;
34901 int res2 = SWIG_TMPOBJ ;
34902 int temp3 ;
34903 int res3 = SWIG_TMPOBJ ;
34904 PyObject *swig_obj[1] ;
34905
34906 arg2 = &temp2;
34907 arg3 = &temp3;
34908 if (!args) SWIG_fail;
34909 swig_obj[0] = args;
34910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34911 if (!SWIG_IsOK(res1)) {
34912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34913 }
34914 arg1 = reinterpret_cast< wxWindow * >(argp1);
34915 {
34916 PyThreadState* __tstate = wxPyBeginAllowThreads();
34917 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
34918 wxPyEndAllowThreads(__tstate);
34919 if (PyErr_Occurred()) SWIG_fail;
34920 }
34921 resultobj = SWIG_Py_Void();
34922 if (SWIG_IsTmpObj(res2)) {
34923 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34924 } else {
34925 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34926 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34927 }
34928 if (SWIG_IsTmpObj(res3)) {
34929 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34930 } else {
34931 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34932 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34933 }
34934 return resultobj;
34935 fail:
34936 return NULL;
34937 }
34938
34939
34940 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34941 PyObject *resultobj = 0;
34942 wxWindow *arg1 = (wxWindow *) 0 ;
34943 wxRect result;
34944 void *argp1 = 0 ;
34945 int res1 = 0 ;
34946 PyObject *swig_obj[1] ;
34947
34948 if (!args) SWIG_fail;
34949 swig_obj[0] = args;
34950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34951 if (!SWIG_IsOK(res1)) {
34952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34953 }
34954 arg1 = reinterpret_cast< wxWindow * >(argp1);
34955 {
34956 PyThreadState* __tstate = wxPyBeginAllowThreads();
34957 result = ((wxWindow const *)arg1)->GetRect();
34958 wxPyEndAllowThreads(__tstate);
34959 if (PyErr_Occurred()) SWIG_fail;
34960 }
34961 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34962 return resultobj;
34963 fail:
34964 return NULL;
34965 }
34966
34967
34968 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34969 PyObject *resultobj = 0;
34970 wxWindow *arg1 = (wxWindow *) 0 ;
34971 wxSize result;
34972 void *argp1 = 0 ;
34973 int res1 = 0 ;
34974 PyObject *swig_obj[1] ;
34975
34976 if (!args) SWIG_fail;
34977 swig_obj[0] = args;
34978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34979 if (!SWIG_IsOK(res1)) {
34980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34981 }
34982 arg1 = reinterpret_cast< wxWindow * >(argp1);
34983 {
34984 PyThreadState* __tstate = wxPyBeginAllowThreads();
34985 result = ((wxWindow const *)arg1)->GetClientSize();
34986 wxPyEndAllowThreads(__tstate);
34987 if (PyErr_Occurred()) SWIG_fail;
34988 }
34989 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34990 return resultobj;
34991 fail:
34992 return NULL;
34993 }
34994
34995
34996 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34997 PyObject *resultobj = 0;
34998 wxWindow *arg1 = (wxWindow *) 0 ;
34999 int *arg2 = (int *) 0 ;
35000 int *arg3 = (int *) 0 ;
35001 void *argp1 = 0 ;
35002 int res1 = 0 ;
35003 int temp2 ;
35004 int res2 = SWIG_TMPOBJ ;
35005 int temp3 ;
35006 int res3 = SWIG_TMPOBJ ;
35007 PyObject *swig_obj[1] ;
35008
35009 arg2 = &temp2;
35010 arg3 = &temp3;
35011 if (!args) SWIG_fail;
35012 swig_obj[0] = args;
35013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35014 if (!SWIG_IsOK(res1)) {
35015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
35016 }
35017 arg1 = reinterpret_cast< wxWindow * >(argp1);
35018 {
35019 PyThreadState* __tstate = wxPyBeginAllowThreads();
35020 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
35021 wxPyEndAllowThreads(__tstate);
35022 if (PyErr_Occurred()) SWIG_fail;
35023 }
35024 resultobj = SWIG_Py_Void();
35025 if (SWIG_IsTmpObj(res2)) {
35026 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35027 } else {
35028 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35029 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35030 }
35031 if (SWIG_IsTmpObj(res3)) {
35032 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35033 } else {
35034 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35035 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35036 }
35037 return resultobj;
35038 fail:
35039 return NULL;
35040 }
35041
35042
35043 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35044 PyObject *resultobj = 0;
35045 wxWindow *arg1 = (wxWindow *) 0 ;
35046 wxPoint result;
35047 void *argp1 = 0 ;
35048 int res1 = 0 ;
35049 PyObject *swig_obj[1] ;
35050
35051 if (!args) SWIG_fail;
35052 swig_obj[0] = args;
35053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35054 if (!SWIG_IsOK(res1)) {
35055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
35056 }
35057 arg1 = reinterpret_cast< wxWindow * >(argp1);
35058 {
35059 PyThreadState* __tstate = wxPyBeginAllowThreads();
35060 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
35061 wxPyEndAllowThreads(__tstate);
35062 if (PyErr_Occurred()) SWIG_fail;
35063 }
35064 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35065 return resultobj;
35066 fail:
35067 return NULL;
35068 }
35069
35070
35071 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35072 PyObject *resultobj = 0;
35073 wxWindow *arg1 = (wxWindow *) 0 ;
35074 wxRect result;
35075 void *argp1 = 0 ;
35076 int res1 = 0 ;
35077 PyObject *swig_obj[1] ;
35078
35079 if (!args) SWIG_fail;
35080 swig_obj[0] = args;
35081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35082 if (!SWIG_IsOK(res1)) {
35083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35084 }
35085 arg1 = reinterpret_cast< wxWindow * >(argp1);
35086 {
35087 PyThreadState* __tstate = wxPyBeginAllowThreads();
35088 result = ((wxWindow const *)arg1)->GetClientRect();
35089 wxPyEndAllowThreads(__tstate);
35090 if (PyErr_Occurred()) SWIG_fail;
35091 }
35092 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35093 return resultobj;
35094 fail:
35095 return NULL;
35096 }
35097
35098
35099 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35100 PyObject *resultobj = 0;
35101 wxWindow *arg1 = (wxWindow *) 0 ;
35102 wxSize result;
35103 void *argp1 = 0 ;
35104 int res1 = 0 ;
35105 PyObject *swig_obj[1] ;
35106
35107 if (!args) SWIG_fail;
35108 swig_obj[0] = args;
35109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35110 if (!SWIG_IsOK(res1)) {
35111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35112 }
35113 arg1 = reinterpret_cast< wxWindow * >(argp1);
35114 {
35115 PyThreadState* __tstate = wxPyBeginAllowThreads();
35116 result = ((wxWindow const *)arg1)->GetBestSize();
35117 wxPyEndAllowThreads(__tstate);
35118 if (PyErr_Occurred()) SWIG_fail;
35119 }
35120 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35121 return resultobj;
35122 fail:
35123 return NULL;
35124 }
35125
35126
35127 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35128 PyObject *resultobj = 0;
35129 wxWindow *arg1 = (wxWindow *) 0 ;
35130 int *arg2 = (int *) 0 ;
35131 int *arg3 = (int *) 0 ;
35132 void *argp1 = 0 ;
35133 int res1 = 0 ;
35134 int temp2 ;
35135 int res2 = SWIG_TMPOBJ ;
35136 int temp3 ;
35137 int res3 = SWIG_TMPOBJ ;
35138 PyObject *swig_obj[1] ;
35139
35140 arg2 = &temp2;
35141 arg3 = &temp3;
35142 if (!args) SWIG_fail;
35143 swig_obj[0] = args;
35144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35145 if (!SWIG_IsOK(res1)) {
35146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
35147 }
35148 arg1 = reinterpret_cast< wxWindow * >(argp1);
35149 {
35150 PyThreadState* __tstate = wxPyBeginAllowThreads();
35151 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
35152 wxPyEndAllowThreads(__tstate);
35153 if (PyErr_Occurred()) SWIG_fail;
35154 }
35155 resultobj = SWIG_Py_Void();
35156 if (SWIG_IsTmpObj(res2)) {
35157 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35158 } else {
35159 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35160 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35161 }
35162 if (SWIG_IsTmpObj(res3)) {
35163 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35164 } else {
35165 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35166 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35167 }
35168 return resultobj;
35169 fail:
35170 return NULL;
35171 }
35172
35173
35174 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35175 PyObject *resultobj = 0;
35176 wxWindow *arg1 = (wxWindow *) 0 ;
35177 void *argp1 = 0 ;
35178 int res1 = 0 ;
35179 PyObject *swig_obj[1] ;
35180
35181 if (!args) SWIG_fail;
35182 swig_obj[0] = args;
35183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35184 if (!SWIG_IsOK(res1)) {
35185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35186 }
35187 arg1 = reinterpret_cast< wxWindow * >(argp1);
35188 {
35189 PyThreadState* __tstate = wxPyBeginAllowThreads();
35190 (arg1)->InvalidateBestSize();
35191 wxPyEndAllowThreads(__tstate);
35192 if (PyErr_Occurred()) SWIG_fail;
35193 }
35194 resultobj = SWIG_Py_Void();
35195 return resultobj;
35196 fail:
35197 return NULL;
35198 }
35199
35200
35201 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35202 PyObject *resultobj = 0;
35203 wxWindow *arg1 = (wxWindow *) 0 ;
35204 wxSize *arg2 = 0 ;
35205 void *argp1 = 0 ;
35206 int res1 = 0 ;
35207 wxSize temp2 ;
35208 PyObject * obj0 = 0 ;
35209 PyObject * obj1 = 0 ;
35210 char * kwnames[] = {
35211 (char *) "self",(char *) "size", NULL
35212 };
35213
35214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
35215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35216 if (!SWIG_IsOK(res1)) {
35217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35218 }
35219 arg1 = reinterpret_cast< wxWindow * >(argp1);
35220 {
35221 arg2 = &temp2;
35222 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35223 }
35224 {
35225 PyThreadState* __tstate = wxPyBeginAllowThreads();
35226 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
35227 wxPyEndAllowThreads(__tstate);
35228 if (PyErr_Occurred()) SWIG_fail;
35229 }
35230 resultobj = SWIG_Py_Void();
35231 return resultobj;
35232 fail:
35233 return NULL;
35234 }
35235
35236
35237 SWIGINTERN PyObject *_wrap_Window_GetEffectiveMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35238 PyObject *resultobj = 0;
35239 wxWindow *arg1 = (wxWindow *) 0 ;
35240 wxSize result;
35241 void *argp1 = 0 ;
35242 int res1 = 0 ;
35243 PyObject *swig_obj[1] ;
35244
35245 if (!args) SWIG_fail;
35246 swig_obj[0] = args;
35247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35248 if (!SWIG_IsOK(res1)) {
35249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEffectiveMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35250 }
35251 arg1 = reinterpret_cast< wxWindow * >(argp1);
35252 {
35253 PyThreadState* __tstate = wxPyBeginAllowThreads();
35254 result = ((wxWindow const *)arg1)->GetEffectiveMinSize();
35255 wxPyEndAllowThreads(__tstate);
35256 if (PyErr_Occurred()) SWIG_fail;
35257 }
35258 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35259 return resultobj;
35260 fail:
35261 return NULL;
35262 }
35263
35264
35265 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35266 PyObject *resultobj = 0;
35267 wxWindow *arg1 = (wxWindow *) 0 ;
35268 int arg2 = (int) wxBOTH ;
35269 void *argp1 = 0 ;
35270 int res1 = 0 ;
35271 int val2 ;
35272 int ecode2 = 0 ;
35273 PyObject * obj0 = 0 ;
35274 PyObject * obj1 = 0 ;
35275 char * kwnames[] = {
35276 (char *) "self",(char *) "direction", NULL
35277 };
35278
35279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
35280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35281 if (!SWIG_IsOK(res1)) {
35282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
35283 }
35284 arg1 = reinterpret_cast< wxWindow * >(argp1);
35285 if (obj1) {
35286 ecode2 = SWIG_AsVal_int(obj1, &val2);
35287 if (!SWIG_IsOK(ecode2)) {
35288 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
35289 }
35290 arg2 = static_cast< int >(val2);
35291 }
35292 {
35293 PyThreadState* __tstate = wxPyBeginAllowThreads();
35294 (arg1)->Center(arg2);
35295 wxPyEndAllowThreads(__tstate);
35296 if (PyErr_Occurred()) SWIG_fail;
35297 }
35298 resultobj = SWIG_Py_Void();
35299 return resultobj;
35300 fail:
35301 return NULL;
35302 }
35303
35304
35305 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35306 PyObject *resultobj = 0;
35307 wxWindow *arg1 = (wxWindow *) 0 ;
35308 int arg2 = (int) wxBOTH ;
35309 void *argp1 = 0 ;
35310 int res1 = 0 ;
35311 int val2 ;
35312 int ecode2 = 0 ;
35313 PyObject * obj0 = 0 ;
35314 PyObject * obj1 = 0 ;
35315 char * kwnames[] = {
35316 (char *) "self",(char *) "dir", NULL
35317 };
35318
35319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
35320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35321 if (!SWIG_IsOK(res1)) {
35322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
35323 }
35324 arg1 = reinterpret_cast< wxWindow * >(argp1);
35325 if (obj1) {
35326 ecode2 = SWIG_AsVal_int(obj1, &val2);
35327 if (!SWIG_IsOK(ecode2)) {
35328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
35329 }
35330 arg2 = static_cast< int >(val2);
35331 }
35332 {
35333 PyThreadState* __tstate = wxPyBeginAllowThreads();
35334 (arg1)->CenterOnParent(arg2);
35335 wxPyEndAllowThreads(__tstate);
35336 if (PyErr_Occurred()) SWIG_fail;
35337 }
35338 resultobj = SWIG_Py_Void();
35339 return resultobj;
35340 fail:
35341 return NULL;
35342 }
35343
35344
35345 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35346 PyObject *resultobj = 0;
35347 wxWindow *arg1 = (wxWindow *) 0 ;
35348 void *argp1 = 0 ;
35349 int res1 = 0 ;
35350 PyObject *swig_obj[1] ;
35351
35352 if (!args) SWIG_fail;
35353 swig_obj[0] = args;
35354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35355 if (!SWIG_IsOK(res1)) {
35356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
35357 }
35358 arg1 = reinterpret_cast< wxWindow * >(argp1);
35359 {
35360 PyThreadState* __tstate = wxPyBeginAllowThreads();
35361 (arg1)->Fit();
35362 wxPyEndAllowThreads(__tstate);
35363 if (PyErr_Occurred()) SWIG_fail;
35364 }
35365 resultobj = SWIG_Py_Void();
35366 return resultobj;
35367 fail:
35368 return NULL;
35369 }
35370
35371
35372 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35373 PyObject *resultobj = 0;
35374 wxWindow *arg1 = (wxWindow *) 0 ;
35375 void *argp1 = 0 ;
35376 int res1 = 0 ;
35377 PyObject *swig_obj[1] ;
35378
35379 if (!args) SWIG_fail;
35380 swig_obj[0] = args;
35381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35382 if (!SWIG_IsOK(res1)) {
35383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
35384 }
35385 arg1 = reinterpret_cast< wxWindow * >(argp1);
35386 {
35387 PyThreadState* __tstate = wxPyBeginAllowThreads();
35388 (arg1)->FitInside();
35389 wxPyEndAllowThreads(__tstate);
35390 if (PyErr_Occurred()) SWIG_fail;
35391 }
35392 resultobj = SWIG_Py_Void();
35393 return resultobj;
35394 fail:
35395 return NULL;
35396 }
35397
35398
35399 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35400 PyObject *resultobj = 0;
35401 wxWindow *arg1 = (wxWindow *) 0 ;
35402 int arg2 ;
35403 int arg3 ;
35404 int arg4 = (int) -1 ;
35405 int arg5 = (int) -1 ;
35406 int arg6 = (int) -1 ;
35407 int arg7 = (int) -1 ;
35408 void *argp1 = 0 ;
35409 int res1 = 0 ;
35410 int val2 ;
35411 int ecode2 = 0 ;
35412 int val3 ;
35413 int ecode3 = 0 ;
35414 int val4 ;
35415 int ecode4 = 0 ;
35416 int val5 ;
35417 int ecode5 = 0 ;
35418 int val6 ;
35419 int ecode6 = 0 ;
35420 int val7 ;
35421 int ecode7 = 0 ;
35422 PyObject * obj0 = 0 ;
35423 PyObject * obj1 = 0 ;
35424 PyObject * obj2 = 0 ;
35425 PyObject * obj3 = 0 ;
35426 PyObject * obj4 = 0 ;
35427 PyObject * obj5 = 0 ;
35428 PyObject * obj6 = 0 ;
35429 char * kwnames[] = {
35430 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
35431 };
35432
35433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
35434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35435 if (!SWIG_IsOK(res1)) {
35436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
35437 }
35438 arg1 = reinterpret_cast< wxWindow * >(argp1);
35439 ecode2 = SWIG_AsVal_int(obj1, &val2);
35440 if (!SWIG_IsOK(ecode2)) {
35441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
35442 }
35443 arg2 = static_cast< int >(val2);
35444 ecode3 = SWIG_AsVal_int(obj2, &val3);
35445 if (!SWIG_IsOK(ecode3)) {
35446 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
35447 }
35448 arg3 = static_cast< int >(val3);
35449 if (obj3) {
35450 ecode4 = SWIG_AsVal_int(obj3, &val4);
35451 if (!SWIG_IsOK(ecode4)) {
35452 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
35453 }
35454 arg4 = static_cast< int >(val4);
35455 }
35456 if (obj4) {
35457 ecode5 = SWIG_AsVal_int(obj4, &val5);
35458 if (!SWIG_IsOK(ecode5)) {
35459 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
35460 }
35461 arg5 = static_cast< int >(val5);
35462 }
35463 if (obj5) {
35464 ecode6 = SWIG_AsVal_int(obj5, &val6);
35465 if (!SWIG_IsOK(ecode6)) {
35466 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
35467 }
35468 arg6 = static_cast< int >(val6);
35469 }
35470 if (obj6) {
35471 ecode7 = SWIG_AsVal_int(obj6, &val7);
35472 if (!SWIG_IsOK(ecode7)) {
35473 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
35474 }
35475 arg7 = static_cast< int >(val7);
35476 }
35477 {
35478 PyThreadState* __tstate = wxPyBeginAllowThreads();
35479 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
35480 wxPyEndAllowThreads(__tstate);
35481 if (PyErr_Occurred()) SWIG_fail;
35482 }
35483 resultobj = SWIG_Py_Void();
35484 return resultobj;
35485 fail:
35486 return NULL;
35487 }
35488
35489
35490 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35491 PyObject *resultobj = 0;
35492 wxWindow *arg1 = (wxWindow *) 0 ;
35493 wxSize *arg2 = 0 ;
35494 wxSize const &arg3_defvalue = wxDefaultSize ;
35495 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
35496 wxSize const &arg4_defvalue = wxDefaultSize ;
35497 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
35498 void *argp1 = 0 ;
35499 int res1 = 0 ;
35500 wxSize temp2 ;
35501 wxSize temp3 ;
35502 wxSize temp4 ;
35503 PyObject * obj0 = 0 ;
35504 PyObject * obj1 = 0 ;
35505 PyObject * obj2 = 0 ;
35506 PyObject * obj3 = 0 ;
35507 char * kwnames[] = {
35508 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
35509 };
35510
35511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35513 if (!SWIG_IsOK(res1)) {
35514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
35515 }
35516 arg1 = reinterpret_cast< wxWindow * >(argp1);
35517 {
35518 arg2 = &temp2;
35519 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35520 }
35521 if (obj2) {
35522 {
35523 arg3 = &temp3;
35524 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
35525 }
35526 }
35527 if (obj3) {
35528 {
35529 arg4 = &temp4;
35530 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
35531 }
35532 }
35533 {
35534 PyThreadState* __tstate = wxPyBeginAllowThreads();
35535 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
35536 wxPyEndAllowThreads(__tstate);
35537 if (PyErr_Occurred()) SWIG_fail;
35538 }
35539 resultobj = SWIG_Py_Void();
35540 return resultobj;
35541 fail:
35542 return NULL;
35543 }
35544
35545
35546 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35547 PyObject *resultobj = 0;
35548 wxWindow *arg1 = (wxWindow *) 0 ;
35549 int arg2 ;
35550 int arg3 ;
35551 int arg4 = (int) -1 ;
35552 int arg5 = (int) -1 ;
35553 void *argp1 = 0 ;
35554 int res1 = 0 ;
35555 int val2 ;
35556 int ecode2 = 0 ;
35557 int val3 ;
35558 int ecode3 = 0 ;
35559 int val4 ;
35560 int ecode4 = 0 ;
35561 int val5 ;
35562 int ecode5 = 0 ;
35563 PyObject * obj0 = 0 ;
35564 PyObject * obj1 = 0 ;
35565 PyObject * obj2 = 0 ;
35566 PyObject * obj3 = 0 ;
35567 PyObject * obj4 = 0 ;
35568 char * kwnames[] = {
35569 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
35570 };
35571
35572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
35573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35574 if (!SWIG_IsOK(res1)) {
35575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
35576 }
35577 arg1 = reinterpret_cast< wxWindow * >(argp1);
35578 ecode2 = SWIG_AsVal_int(obj1, &val2);
35579 if (!SWIG_IsOK(ecode2)) {
35580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
35581 }
35582 arg2 = static_cast< int >(val2);
35583 ecode3 = SWIG_AsVal_int(obj2, &val3);
35584 if (!SWIG_IsOK(ecode3)) {
35585 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
35586 }
35587 arg3 = static_cast< int >(val3);
35588 if (obj3) {
35589 ecode4 = SWIG_AsVal_int(obj3, &val4);
35590 if (!SWIG_IsOK(ecode4)) {
35591 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
35592 }
35593 arg4 = static_cast< int >(val4);
35594 }
35595 if (obj4) {
35596 ecode5 = SWIG_AsVal_int(obj4, &val5);
35597 if (!SWIG_IsOK(ecode5)) {
35598 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
35599 }
35600 arg5 = static_cast< int >(val5);
35601 }
35602 {
35603 PyThreadState* __tstate = wxPyBeginAllowThreads();
35604 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
35605 wxPyEndAllowThreads(__tstate);
35606 if (PyErr_Occurred()) SWIG_fail;
35607 }
35608 resultobj = SWIG_Py_Void();
35609 return resultobj;
35610 fail:
35611 return NULL;
35612 }
35613
35614
35615 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35616 PyObject *resultobj = 0;
35617 wxWindow *arg1 = (wxWindow *) 0 ;
35618 wxSize *arg2 = 0 ;
35619 wxSize const &arg3_defvalue = wxDefaultSize ;
35620 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
35621 void *argp1 = 0 ;
35622 int res1 = 0 ;
35623 wxSize temp2 ;
35624 wxSize temp3 ;
35625 PyObject * obj0 = 0 ;
35626 PyObject * obj1 = 0 ;
35627 PyObject * obj2 = 0 ;
35628 char * kwnames[] = {
35629 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
35630 };
35631
35632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35634 if (!SWIG_IsOK(res1)) {
35635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
35636 }
35637 arg1 = reinterpret_cast< wxWindow * >(argp1);
35638 {
35639 arg2 = &temp2;
35640 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35641 }
35642 if (obj2) {
35643 {
35644 arg3 = &temp3;
35645 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
35646 }
35647 }
35648 {
35649 PyThreadState* __tstate = wxPyBeginAllowThreads();
35650 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
35651 wxPyEndAllowThreads(__tstate);
35652 if (PyErr_Occurred()) SWIG_fail;
35653 }
35654 resultobj = SWIG_Py_Void();
35655 return resultobj;
35656 fail:
35657 return NULL;
35658 }
35659
35660
35661 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35662 PyObject *resultobj = 0;
35663 wxWindow *arg1 = (wxWindow *) 0 ;
35664 wxSize result;
35665 void *argp1 = 0 ;
35666 int res1 = 0 ;
35667 PyObject *swig_obj[1] ;
35668
35669 if (!args) SWIG_fail;
35670 swig_obj[0] = args;
35671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35672 if (!SWIG_IsOK(res1)) {
35673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35674 }
35675 arg1 = reinterpret_cast< wxWindow * >(argp1);
35676 {
35677 PyThreadState* __tstate = wxPyBeginAllowThreads();
35678 result = ((wxWindow const *)arg1)->GetMaxSize();
35679 wxPyEndAllowThreads(__tstate);
35680 if (PyErr_Occurred()) SWIG_fail;
35681 }
35682 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35683 return resultobj;
35684 fail:
35685 return NULL;
35686 }
35687
35688
35689 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35690 PyObject *resultobj = 0;
35691 wxWindow *arg1 = (wxWindow *) 0 ;
35692 wxSize result;
35693 void *argp1 = 0 ;
35694 int res1 = 0 ;
35695 PyObject *swig_obj[1] ;
35696
35697 if (!args) SWIG_fail;
35698 swig_obj[0] = args;
35699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35700 if (!SWIG_IsOK(res1)) {
35701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35702 }
35703 arg1 = reinterpret_cast< wxWindow * >(argp1);
35704 {
35705 PyThreadState* __tstate = wxPyBeginAllowThreads();
35706 result = ((wxWindow const *)arg1)->GetMinSize();
35707 wxPyEndAllowThreads(__tstate);
35708 if (PyErr_Occurred()) SWIG_fail;
35709 }
35710 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35711 return resultobj;
35712 fail:
35713 return NULL;
35714 }
35715
35716
35717 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35718 PyObject *resultobj = 0;
35719 wxWindow *arg1 = (wxWindow *) 0 ;
35720 wxSize *arg2 = 0 ;
35721 void *argp1 = 0 ;
35722 int res1 = 0 ;
35723 wxSize temp2 ;
35724 PyObject * obj0 = 0 ;
35725 PyObject * obj1 = 0 ;
35726 char * kwnames[] = {
35727 (char *) "self",(char *) "minSize", NULL
35728 };
35729
35730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
35731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35732 if (!SWIG_IsOK(res1)) {
35733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35734 }
35735 arg1 = reinterpret_cast< wxWindow * >(argp1);
35736 {
35737 arg2 = &temp2;
35738 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35739 }
35740 {
35741 PyThreadState* __tstate = wxPyBeginAllowThreads();
35742 (arg1)->SetMinSize((wxSize const &)*arg2);
35743 wxPyEndAllowThreads(__tstate);
35744 if (PyErr_Occurred()) SWIG_fail;
35745 }
35746 resultobj = SWIG_Py_Void();
35747 return resultobj;
35748 fail:
35749 return NULL;
35750 }
35751
35752
35753 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35754 PyObject *resultobj = 0;
35755 wxWindow *arg1 = (wxWindow *) 0 ;
35756 wxSize *arg2 = 0 ;
35757 void *argp1 = 0 ;
35758 int res1 = 0 ;
35759 wxSize temp2 ;
35760 PyObject * obj0 = 0 ;
35761 PyObject * obj1 = 0 ;
35762 char * kwnames[] = {
35763 (char *) "self",(char *) "maxSize", NULL
35764 };
35765
35766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
35767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35768 if (!SWIG_IsOK(res1)) {
35769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35770 }
35771 arg1 = reinterpret_cast< wxWindow * >(argp1);
35772 {
35773 arg2 = &temp2;
35774 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35775 }
35776 {
35777 PyThreadState* __tstate = wxPyBeginAllowThreads();
35778 (arg1)->SetMaxSize((wxSize const &)*arg2);
35779 wxPyEndAllowThreads(__tstate);
35780 if (PyErr_Occurred()) SWIG_fail;
35781 }
35782 resultobj = SWIG_Py_Void();
35783 return resultobj;
35784 fail:
35785 return NULL;
35786 }
35787
35788
35789 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35790 PyObject *resultobj = 0;
35791 wxWindow *arg1 = (wxWindow *) 0 ;
35792 int result;
35793 void *argp1 = 0 ;
35794 int res1 = 0 ;
35795 PyObject *swig_obj[1] ;
35796
35797 if (!args) SWIG_fail;
35798 swig_obj[0] = args;
35799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35800 if (!SWIG_IsOK(res1)) {
35801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35802 }
35803 arg1 = reinterpret_cast< wxWindow * >(argp1);
35804 {
35805 PyThreadState* __tstate = wxPyBeginAllowThreads();
35806 result = (int)((wxWindow const *)arg1)->GetMinWidth();
35807 wxPyEndAllowThreads(__tstate);
35808 if (PyErr_Occurred()) SWIG_fail;
35809 }
35810 resultobj = SWIG_From_int(static_cast< int >(result));
35811 return resultobj;
35812 fail:
35813 return NULL;
35814 }
35815
35816
35817 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35818 PyObject *resultobj = 0;
35819 wxWindow *arg1 = (wxWindow *) 0 ;
35820 int result;
35821 void *argp1 = 0 ;
35822 int res1 = 0 ;
35823 PyObject *swig_obj[1] ;
35824
35825 if (!args) SWIG_fail;
35826 swig_obj[0] = args;
35827 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35828 if (!SWIG_IsOK(res1)) {
35829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35830 }
35831 arg1 = reinterpret_cast< wxWindow * >(argp1);
35832 {
35833 PyThreadState* __tstate = wxPyBeginAllowThreads();
35834 result = (int)((wxWindow const *)arg1)->GetMinHeight();
35835 wxPyEndAllowThreads(__tstate);
35836 if (PyErr_Occurred()) SWIG_fail;
35837 }
35838 resultobj = SWIG_From_int(static_cast< int >(result));
35839 return resultobj;
35840 fail:
35841 return NULL;
35842 }
35843
35844
35845 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35846 PyObject *resultobj = 0;
35847 wxWindow *arg1 = (wxWindow *) 0 ;
35848 int result;
35849 void *argp1 = 0 ;
35850 int res1 = 0 ;
35851 PyObject *swig_obj[1] ;
35852
35853 if (!args) SWIG_fail;
35854 swig_obj[0] = args;
35855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35856 if (!SWIG_IsOK(res1)) {
35857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35858 }
35859 arg1 = reinterpret_cast< wxWindow * >(argp1);
35860 {
35861 PyThreadState* __tstate = wxPyBeginAllowThreads();
35862 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
35863 wxPyEndAllowThreads(__tstate);
35864 if (PyErr_Occurred()) SWIG_fail;
35865 }
35866 resultobj = SWIG_From_int(static_cast< int >(result));
35867 return resultobj;
35868 fail:
35869 return NULL;
35870 }
35871
35872
35873 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35874 PyObject *resultobj = 0;
35875 wxWindow *arg1 = (wxWindow *) 0 ;
35876 int result;
35877 void *argp1 = 0 ;
35878 int res1 = 0 ;
35879 PyObject *swig_obj[1] ;
35880
35881 if (!args) SWIG_fail;
35882 swig_obj[0] = args;
35883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35884 if (!SWIG_IsOK(res1)) {
35885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35886 }
35887 arg1 = reinterpret_cast< wxWindow * >(argp1);
35888 {
35889 PyThreadState* __tstate = wxPyBeginAllowThreads();
35890 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
35891 wxPyEndAllowThreads(__tstate);
35892 if (PyErr_Occurred()) SWIG_fail;
35893 }
35894 resultobj = SWIG_From_int(static_cast< int >(result));
35895 return resultobj;
35896 fail:
35897 return NULL;
35898 }
35899
35900
35901 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35902 PyObject *resultobj = 0;
35903 wxWindow *arg1 = (wxWindow *) 0 ;
35904 wxSize *arg2 = 0 ;
35905 void *argp1 = 0 ;
35906 int res1 = 0 ;
35907 wxSize temp2 ;
35908 PyObject * obj0 = 0 ;
35909 PyObject * obj1 = 0 ;
35910 char * kwnames[] = {
35911 (char *) "self",(char *) "size", NULL
35912 };
35913
35914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
35915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35916 if (!SWIG_IsOK(res1)) {
35917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35918 }
35919 arg1 = reinterpret_cast< wxWindow * >(argp1);
35920 {
35921 arg2 = &temp2;
35922 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35923 }
35924 {
35925 PyThreadState* __tstate = wxPyBeginAllowThreads();
35926 (arg1)->SetVirtualSize((wxSize const &)*arg2);
35927 wxPyEndAllowThreads(__tstate);
35928 if (PyErr_Occurred()) SWIG_fail;
35929 }
35930 resultobj = SWIG_Py_Void();
35931 return resultobj;
35932 fail:
35933 return NULL;
35934 }
35935
35936
35937 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35938 PyObject *resultobj = 0;
35939 wxWindow *arg1 = (wxWindow *) 0 ;
35940 int arg2 ;
35941 int arg3 ;
35942 void *argp1 = 0 ;
35943 int res1 = 0 ;
35944 int val2 ;
35945 int ecode2 = 0 ;
35946 int val3 ;
35947 int ecode3 = 0 ;
35948 PyObject * obj0 = 0 ;
35949 PyObject * obj1 = 0 ;
35950 PyObject * obj2 = 0 ;
35951 char * kwnames[] = {
35952 (char *) "self",(char *) "w",(char *) "h", NULL
35953 };
35954
35955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35957 if (!SWIG_IsOK(res1)) {
35958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
35959 }
35960 arg1 = reinterpret_cast< wxWindow * >(argp1);
35961 ecode2 = SWIG_AsVal_int(obj1, &val2);
35962 if (!SWIG_IsOK(ecode2)) {
35963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
35964 }
35965 arg2 = static_cast< int >(val2);
35966 ecode3 = SWIG_AsVal_int(obj2, &val3);
35967 if (!SWIG_IsOK(ecode3)) {
35968 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
35969 }
35970 arg3 = static_cast< int >(val3);
35971 {
35972 PyThreadState* __tstate = wxPyBeginAllowThreads();
35973 (arg1)->SetVirtualSize(arg2,arg3);
35974 wxPyEndAllowThreads(__tstate);
35975 if (PyErr_Occurred()) SWIG_fail;
35976 }
35977 resultobj = SWIG_Py_Void();
35978 return resultobj;
35979 fail:
35980 return NULL;
35981 }
35982
35983
35984 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35985 PyObject *resultobj = 0;
35986 wxWindow *arg1 = (wxWindow *) 0 ;
35987 wxSize result;
35988 void *argp1 = 0 ;
35989 int res1 = 0 ;
35990 PyObject *swig_obj[1] ;
35991
35992 if (!args) SWIG_fail;
35993 swig_obj[0] = args;
35994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35995 if (!SWIG_IsOK(res1)) {
35996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35997 }
35998 arg1 = reinterpret_cast< wxWindow * >(argp1);
35999 {
36000 PyThreadState* __tstate = wxPyBeginAllowThreads();
36001 result = ((wxWindow const *)arg1)->GetVirtualSize();
36002 wxPyEndAllowThreads(__tstate);
36003 if (PyErr_Occurred()) SWIG_fail;
36004 }
36005 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
36006 return resultobj;
36007 fail:
36008 return NULL;
36009 }
36010
36011
36012 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36013 PyObject *resultobj = 0;
36014 wxWindow *arg1 = (wxWindow *) 0 ;
36015 int *arg2 = (int *) 0 ;
36016 int *arg3 = (int *) 0 ;
36017 void *argp1 = 0 ;
36018 int res1 = 0 ;
36019 int temp2 ;
36020 int res2 = SWIG_TMPOBJ ;
36021 int temp3 ;
36022 int res3 = SWIG_TMPOBJ ;
36023 PyObject *swig_obj[1] ;
36024
36025 arg2 = &temp2;
36026 arg3 = &temp3;
36027 if (!args) SWIG_fail;
36028 swig_obj[0] = args;
36029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36030 if (!SWIG_IsOK(res1)) {
36031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
36032 }
36033 arg1 = reinterpret_cast< wxWindow * >(argp1);
36034 {
36035 PyThreadState* __tstate = wxPyBeginAllowThreads();
36036 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
36037 wxPyEndAllowThreads(__tstate);
36038 if (PyErr_Occurred()) SWIG_fail;
36039 }
36040 resultobj = SWIG_Py_Void();
36041 if (SWIG_IsTmpObj(res2)) {
36042 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36043 } else {
36044 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36045 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36046 }
36047 if (SWIG_IsTmpObj(res3)) {
36048 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36049 } else {
36050 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36051 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36052 }
36053 return resultobj;
36054 fail:
36055 return NULL;
36056 }
36057
36058
36059 SWIGINTERN PyObject *_wrap_Window_GetWindowBorderSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36060 PyObject *resultobj = 0;
36061 wxWindow *arg1 = (wxWindow *) 0 ;
36062 wxSize result;
36063 void *argp1 = 0 ;
36064 int res1 = 0 ;
36065 PyObject *swig_obj[1] ;
36066
36067 if (!args) SWIG_fail;
36068 swig_obj[0] = args;
36069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36070 if (!SWIG_IsOK(res1)) {
36071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowBorderSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
36072 }
36073 arg1 = reinterpret_cast< wxWindow * >(argp1);
36074 {
36075 PyThreadState* __tstate = wxPyBeginAllowThreads();
36076 result = ((wxWindow const *)arg1)->GetWindowBorderSize();
36077 wxPyEndAllowThreads(__tstate);
36078 if (PyErr_Occurred()) SWIG_fail;
36079 }
36080 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
36081 return resultobj;
36082 fail:
36083 return NULL;
36084 }
36085
36086
36087 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36088 PyObject *resultobj = 0;
36089 wxWindow *arg1 = (wxWindow *) 0 ;
36090 wxSize result;
36091 void *argp1 = 0 ;
36092 int res1 = 0 ;
36093 PyObject *swig_obj[1] ;
36094
36095 if (!args) SWIG_fail;
36096 swig_obj[0] = args;
36097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36098 if (!SWIG_IsOK(res1)) {
36099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
36100 }
36101 arg1 = reinterpret_cast< wxWindow * >(argp1);
36102 {
36103 PyThreadState* __tstate = wxPyBeginAllowThreads();
36104 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
36105 wxPyEndAllowThreads(__tstate);
36106 if (PyErr_Occurred()) SWIG_fail;
36107 }
36108 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
36109 return resultobj;
36110 fail:
36111 return NULL;
36112 }
36113
36114
36115 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36116 PyObject *resultobj = 0;
36117 wxWindow *arg1 = (wxWindow *) 0 ;
36118 bool arg2 = (bool) true ;
36119 bool result;
36120 void *argp1 = 0 ;
36121 int res1 = 0 ;
36122 bool val2 ;
36123 int ecode2 = 0 ;
36124 PyObject * obj0 = 0 ;
36125 PyObject * obj1 = 0 ;
36126 char * kwnames[] = {
36127 (char *) "self",(char *) "show", NULL
36128 };
36129
36130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
36131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36132 if (!SWIG_IsOK(res1)) {
36133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
36134 }
36135 arg1 = reinterpret_cast< wxWindow * >(argp1);
36136 if (obj1) {
36137 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36138 if (!SWIG_IsOK(ecode2)) {
36139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
36140 }
36141 arg2 = static_cast< bool >(val2);
36142 }
36143 {
36144 PyThreadState* __tstate = wxPyBeginAllowThreads();
36145 result = (bool)(arg1)->Show(arg2);
36146 wxPyEndAllowThreads(__tstate);
36147 if (PyErr_Occurred()) SWIG_fail;
36148 }
36149 {
36150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36151 }
36152 return resultobj;
36153 fail:
36154 return NULL;
36155 }
36156
36157
36158 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36159 PyObject *resultobj = 0;
36160 wxWindow *arg1 = (wxWindow *) 0 ;
36161 bool result;
36162 void *argp1 = 0 ;
36163 int res1 = 0 ;
36164 PyObject *swig_obj[1] ;
36165
36166 if (!args) SWIG_fail;
36167 swig_obj[0] = args;
36168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36169 if (!SWIG_IsOK(res1)) {
36170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
36171 }
36172 arg1 = reinterpret_cast< wxWindow * >(argp1);
36173 {
36174 PyThreadState* __tstate = wxPyBeginAllowThreads();
36175 result = (bool)(arg1)->Hide();
36176 wxPyEndAllowThreads(__tstate);
36177 if (PyErr_Occurred()) SWIG_fail;
36178 }
36179 {
36180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36181 }
36182 return resultobj;
36183 fail:
36184 return NULL;
36185 }
36186
36187
36188 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36189 PyObject *resultobj = 0;
36190 wxWindow *arg1 = (wxWindow *) 0 ;
36191 bool arg2 = (bool) true ;
36192 bool result;
36193 void *argp1 = 0 ;
36194 int res1 = 0 ;
36195 bool val2 ;
36196 int ecode2 = 0 ;
36197 PyObject * obj0 = 0 ;
36198 PyObject * obj1 = 0 ;
36199 char * kwnames[] = {
36200 (char *) "self",(char *) "enable", NULL
36201 };
36202
36203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
36204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36205 if (!SWIG_IsOK(res1)) {
36206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
36207 }
36208 arg1 = reinterpret_cast< wxWindow * >(argp1);
36209 if (obj1) {
36210 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36211 if (!SWIG_IsOK(ecode2)) {
36212 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
36213 }
36214 arg2 = static_cast< bool >(val2);
36215 }
36216 {
36217 PyThreadState* __tstate = wxPyBeginAllowThreads();
36218 result = (bool)(arg1)->Enable(arg2);
36219 wxPyEndAllowThreads(__tstate);
36220 if (PyErr_Occurred()) SWIG_fail;
36221 }
36222 {
36223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36224 }
36225 return resultobj;
36226 fail:
36227 return NULL;
36228 }
36229
36230
36231 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36232 PyObject *resultobj = 0;
36233 wxWindow *arg1 = (wxWindow *) 0 ;
36234 bool result;
36235 void *argp1 = 0 ;
36236 int res1 = 0 ;
36237 PyObject *swig_obj[1] ;
36238
36239 if (!args) SWIG_fail;
36240 swig_obj[0] = args;
36241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36242 if (!SWIG_IsOK(res1)) {
36243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
36244 }
36245 arg1 = reinterpret_cast< wxWindow * >(argp1);
36246 {
36247 PyThreadState* __tstate = wxPyBeginAllowThreads();
36248 result = (bool)(arg1)->Disable();
36249 wxPyEndAllowThreads(__tstate);
36250 if (PyErr_Occurred()) SWIG_fail;
36251 }
36252 {
36253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36254 }
36255 return resultobj;
36256 fail:
36257 return NULL;
36258 }
36259
36260
36261 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36262 PyObject *resultobj = 0;
36263 wxWindow *arg1 = (wxWindow *) 0 ;
36264 bool result;
36265 void *argp1 = 0 ;
36266 int res1 = 0 ;
36267 PyObject *swig_obj[1] ;
36268
36269 if (!args) SWIG_fail;
36270 swig_obj[0] = args;
36271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36272 if (!SWIG_IsOK(res1)) {
36273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
36274 }
36275 arg1 = reinterpret_cast< wxWindow * >(argp1);
36276 {
36277 PyThreadState* __tstate = wxPyBeginAllowThreads();
36278 result = (bool)((wxWindow const *)arg1)->IsShown();
36279 wxPyEndAllowThreads(__tstate);
36280 if (PyErr_Occurred()) SWIG_fail;
36281 }
36282 {
36283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36284 }
36285 return resultobj;
36286 fail:
36287 return NULL;
36288 }
36289
36290
36291 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36292 PyObject *resultobj = 0;
36293 wxWindow *arg1 = (wxWindow *) 0 ;
36294 bool result;
36295 void *argp1 = 0 ;
36296 int res1 = 0 ;
36297 PyObject *swig_obj[1] ;
36298
36299 if (!args) SWIG_fail;
36300 swig_obj[0] = args;
36301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36302 if (!SWIG_IsOK(res1)) {
36303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
36304 }
36305 arg1 = reinterpret_cast< wxWindow * >(argp1);
36306 {
36307 PyThreadState* __tstate = wxPyBeginAllowThreads();
36308 result = (bool)((wxWindow const *)arg1)->IsEnabled();
36309 wxPyEndAllowThreads(__tstate);
36310 if (PyErr_Occurred()) SWIG_fail;
36311 }
36312 {
36313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36314 }
36315 return resultobj;
36316 fail:
36317 return NULL;
36318 }
36319
36320
36321 SWIGINTERN PyObject *_wrap_Window_IsThisEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36322 PyObject *resultobj = 0;
36323 wxWindow *arg1 = (wxWindow *) 0 ;
36324 bool result;
36325 void *argp1 = 0 ;
36326 int res1 = 0 ;
36327 PyObject *swig_obj[1] ;
36328
36329 if (!args) SWIG_fail;
36330 swig_obj[0] = args;
36331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36332 if (!SWIG_IsOK(res1)) {
36333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsThisEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
36334 }
36335 arg1 = reinterpret_cast< wxWindow * >(argp1);
36336 {
36337 PyThreadState* __tstate = wxPyBeginAllowThreads();
36338 result = (bool)((wxWindow const *)arg1)->IsThisEnabled();
36339 wxPyEndAllowThreads(__tstate);
36340 if (PyErr_Occurred()) SWIG_fail;
36341 }
36342 {
36343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36344 }
36345 return resultobj;
36346 fail:
36347 return NULL;
36348 }
36349
36350
36351 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36352 PyObject *resultobj = 0;
36353 wxWindow *arg1 = (wxWindow *) 0 ;
36354 bool result;
36355 void *argp1 = 0 ;
36356 int res1 = 0 ;
36357 PyObject *swig_obj[1] ;
36358
36359 if (!args) SWIG_fail;
36360 swig_obj[0] = args;
36361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36362 if (!SWIG_IsOK(res1)) {
36363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
36364 }
36365 arg1 = reinterpret_cast< wxWindow * >(argp1);
36366 {
36367 PyThreadState* __tstate = wxPyBeginAllowThreads();
36368 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
36369 wxPyEndAllowThreads(__tstate);
36370 if (PyErr_Occurred()) SWIG_fail;
36371 }
36372 {
36373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36374 }
36375 return resultobj;
36376 fail:
36377 return NULL;
36378 }
36379
36380
36381 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36382 PyObject *resultobj = 0;
36383 wxWindow *arg1 = (wxWindow *) 0 ;
36384 long arg2 ;
36385 void *argp1 = 0 ;
36386 int res1 = 0 ;
36387 long val2 ;
36388 int ecode2 = 0 ;
36389 PyObject * obj0 = 0 ;
36390 PyObject * obj1 = 0 ;
36391 char * kwnames[] = {
36392 (char *) "self",(char *) "style", NULL
36393 };
36394
36395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
36396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36397 if (!SWIG_IsOK(res1)) {
36398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
36399 }
36400 arg1 = reinterpret_cast< wxWindow * >(argp1);
36401 ecode2 = SWIG_AsVal_long(obj1, &val2);
36402 if (!SWIG_IsOK(ecode2)) {
36403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
36404 }
36405 arg2 = static_cast< long >(val2);
36406 {
36407 PyThreadState* __tstate = wxPyBeginAllowThreads();
36408 (arg1)->SetWindowStyleFlag(arg2);
36409 wxPyEndAllowThreads(__tstate);
36410 if (PyErr_Occurred()) SWIG_fail;
36411 }
36412 resultobj = SWIG_Py_Void();
36413 return resultobj;
36414 fail:
36415 return NULL;
36416 }
36417
36418
36419 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36420 PyObject *resultobj = 0;
36421 wxWindow *arg1 = (wxWindow *) 0 ;
36422 long result;
36423 void *argp1 = 0 ;
36424 int res1 = 0 ;
36425 PyObject *swig_obj[1] ;
36426
36427 if (!args) SWIG_fail;
36428 swig_obj[0] = args;
36429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36430 if (!SWIG_IsOK(res1)) {
36431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
36432 }
36433 arg1 = reinterpret_cast< wxWindow * >(argp1);
36434 {
36435 PyThreadState* __tstate = wxPyBeginAllowThreads();
36436 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
36437 wxPyEndAllowThreads(__tstate);
36438 if (PyErr_Occurred()) SWIG_fail;
36439 }
36440 resultobj = SWIG_From_long(static_cast< long >(result));
36441 return resultobj;
36442 fail:
36443 return NULL;
36444 }
36445
36446
36447 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36448 PyObject *resultobj = 0;
36449 wxWindow *arg1 = (wxWindow *) 0 ;
36450 int arg2 ;
36451 bool result;
36452 void *argp1 = 0 ;
36453 int res1 = 0 ;
36454 int val2 ;
36455 int ecode2 = 0 ;
36456 PyObject * obj0 = 0 ;
36457 PyObject * obj1 = 0 ;
36458 char * kwnames[] = {
36459 (char *) "self",(char *) "flag", NULL
36460 };
36461
36462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
36463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36464 if (!SWIG_IsOK(res1)) {
36465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
36466 }
36467 arg1 = reinterpret_cast< wxWindow * >(argp1);
36468 ecode2 = SWIG_AsVal_int(obj1, &val2);
36469 if (!SWIG_IsOK(ecode2)) {
36470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
36471 }
36472 arg2 = static_cast< int >(val2);
36473 {
36474 PyThreadState* __tstate = wxPyBeginAllowThreads();
36475 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
36476 wxPyEndAllowThreads(__tstate);
36477 if (PyErr_Occurred()) SWIG_fail;
36478 }
36479 {
36480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36481 }
36482 return resultobj;
36483 fail:
36484 return NULL;
36485 }
36486
36487
36488 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36489 PyObject *resultobj = 0;
36490 wxWindow *arg1 = (wxWindow *) 0 ;
36491 bool result;
36492 void *argp1 = 0 ;
36493 int res1 = 0 ;
36494 PyObject *swig_obj[1] ;
36495
36496 if (!args) SWIG_fail;
36497 swig_obj[0] = args;
36498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36499 if (!SWIG_IsOK(res1)) {
36500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
36501 }
36502 arg1 = reinterpret_cast< wxWindow * >(argp1);
36503 {
36504 PyThreadState* __tstate = wxPyBeginAllowThreads();
36505 result = (bool)((wxWindow const *)arg1)->IsRetained();
36506 wxPyEndAllowThreads(__tstate);
36507 if (PyErr_Occurred()) SWIG_fail;
36508 }
36509 {
36510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36511 }
36512 return resultobj;
36513 fail:
36514 return NULL;
36515 }
36516
36517
36518 SWIGINTERN PyObject *_wrap_Window_ToggleWindowStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36519 PyObject *resultobj = 0;
36520 wxWindow *arg1 = (wxWindow *) 0 ;
36521 int arg2 ;
36522 bool result;
36523 void *argp1 = 0 ;
36524 int res1 = 0 ;
36525 int val2 ;
36526 int ecode2 = 0 ;
36527 PyObject * obj0 = 0 ;
36528 PyObject * obj1 = 0 ;
36529 char * kwnames[] = {
36530 (char *) "self",(char *) "flag", NULL
36531 };
36532
36533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ToggleWindowStyle",kwnames,&obj0,&obj1)) SWIG_fail;
36534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36535 if (!SWIG_IsOK(res1)) {
36536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ToggleWindowStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
36537 }
36538 arg1 = reinterpret_cast< wxWindow * >(argp1);
36539 ecode2 = SWIG_AsVal_int(obj1, &val2);
36540 if (!SWIG_IsOK(ecode2)) {
36541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ToggleWindowStyle" "', expected argument " "2"" of type '" "int""'");
36542 }
36543 arg2 = static_cast< int >(val2);
36544 {
36545 PyThreadState* __tstate = wxPyBeginAllowThreads();
36546 result = (bool)(arg1)->ToggleWindowStyle(arg2);
36547 wxPyEndAllowThreads(__tstate);
36548 if (PyErr_Occurred()) SWIG_fail;
36549 }
36550 {
36551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36552 }
36553 return resultobj;
36554 fail:
36555 return NULL;
36556 }
36557
36558
36559 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36560 PyObject *resultobj = 0;
36561 wxWindow *arg1 = (wxWindow *) 0 ;
36562 long arg2 ;
36563 void *argp1 = 0 ;
36564 int res1 = 0 ;
36565 long val2 ;
36566 int ecode2 = 0 ;
36567 PyObject * obj0 = 0 ;
36568 PyObject * obj1 = 0 ;
36569 char * kwnames[] = {
36570 (char *) "self",(char *) "exStyle", NULL
36571 };
36572
36573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
36574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36575 if (!SWIG_IsOK(res1)) {
36576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
36577 }
36578 arg1 = reinterpret_cast< wxWindow * >(argp1);
36579 ecode2 = SWIG_AsVal_long(obj1, &val2);
36580 if (!SWIG_IsOK(ecode2)) {
36581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
36582 }
36583 arg2 = static_cast< long >(val2);
36584 {
36585 PyThreadState* __tstate = wxPyBeginAllowThreads();
36586 (arg1)->SetExtraStyle(arg2);
36587 wxPyEndAllowThreads(__tstate);
36588 if (PyErr_Occurred()) SWIG_fail;
36589 }
36590 resultobj = SWIG_Py_Void();
36591 return resultobj;
36592 fail:
36593 return NULL;
36594 }
36595
36596
36597 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36598 PyObject *resultobj = 0;
36599 wxWindow *arg1 = (wxWindow *) 0 ;
36600 long result;
36601 void *argp1 = 0 ;
36602 int res1 = 0 ;
36603 PyObject *swig_obj[1] ;
36604
36605 if (!args) SWIG_fail;
36606 swig_obj[0] = args;
36607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36608 if (!SWIG_IsOK(res1)) {
36609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
36610 }
36611 arg1 = reinterpret_cast< wxWindow * >(argp1);
36612 {
36613 PyThreadState* __tstate = wxPyBeginAllowThreads();
36614 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
36615 wxPyEndAllowThreads(__tstate);
36616 if (PyErr_Occurred()) SWIG_fail;
36617 }
36618 resultobj = SWIG_From_long(static_cast< long >(result));
36619 return resultobj;
36620 fail:
36621 return NULL;
36622 }
36623
36624
36625 SWIGINTERN PyObject *_wrap_Window_HasExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36626 PyObject *resultobj = 0;
36627 wxWindow *arg1 = (wxWindow *) 0 ;
36628 int arg2 ;
36629 bool result;
36630 void *argp1 = 0 ;
36631 int res1 = 0 ;
36632 int val2 ;
36633 int ecode2 = 0 ;
36634 PyObject * obj0 = 0 ;
36635 PyObject * obj1 = 0 ;
36636 char * kwnames[] = {
36637 (char *) "self",(char *) "exFlag", NULL
36638 };
36639
36640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
36641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36642 if (!SWIG_IsOK(res1)) {
36643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
36644 }
36645 arg1 = reinterpret_cast< wxWindow * >(argp1);
36646 ecode2 = SWIG_AsVal_int(obj1, &val2);
36647 if (!SWIG_IsOK(ecode2)) {
36648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasExtraStyle" "', expected argument " "2"" of type '" "int""'");
36649 }
36650 arg2 = static_cast< int >(val2);
36651 {
36652 PyThreadState* __tstate = wxPyBeginAllowThreads();
36653 result = (bool)((wxWindow const *)arg1)->HasExtraStyle(arg2);
36654 wxPyEndAllowThreads(__tstate);
36655 if (PyErr_Occurred()) SWIG_fail;
36656 }
36657 {
36658 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36659 }
36660 return resultobj;
36661 fail:
36662 return NULL;
36663 }
36664
36665
36666 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36667 PyObject *resultobj = 0;
36668 wxWindow *arg1 = (wxWindow *) 0 ;
36669 bool arg2 = (bool) true ;
36670 void *argp1 = 0 ;
36671 int res1 = 0 ;
36672 bool val2 ;
36673 int ecode2 = 0 ;
36674 PyObject * obj0 = 0 ;
36675 PyObject * obj1 = 0 ;
36676 char * kwnames[] = {
36677 (char *) "self",(char *) "modal", NULL
36678 };
36679
36680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
36681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36682 if (!SWIG_IsOK(res1)) {
36683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
36684 }
36685 arg1 = reinterpret_cast< wxWindow * >(argp1);
36686 if (obj1) {
36687 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36688 if (!SWIG_IsOK(ecode2)) {
36689 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
36690 }
36691 arg2 = static_cast< bool >(val2);
36692 }
36693 {
36694 PyThreadState* __tstate = wxPyBeginAllowThreads();
36695 (arg1)->MakeModal(arg2);
36696 wxPyEndAllowThreads(__tstate);
36697 if (PyErr_Occurred()) SWIG_fail;
36698 }
36699 resultobj = SWIG_Py_Void();
36700 return resultobj;
36701 fail:
36702 return NULL;
36703 }
36704
36705
36706 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36707 PyObject *resultobj = 0;
36708 wxWindow *arg1 = (wxWindow *) 0 ;
36709 bool arg2 ;
36710 void *argp1 = 0 ;
36711 int res1 = 0 ;
36712 bool val2 ;
36713 int ecode2 = 0 ;
36714 PyObject * obj0 = 0 ;
36715 PyObject * obj1 = 0 ;
36716 char * kwnames[] = {
36717 (char *) "self",(char *) "enableTheme", NULL
36718 };
36719
36720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
36721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36722 if (!SWIG_IsOK(res1)) {
36723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
36724 }
36725 arg1 = reinterpret_cast< wxWindow * >(argp1);
36726 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36727 if (!SWIG_IsOK(ecode2)) {
36728 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
36729 }
36730 arg2 = static_cast< bool >(val2);
36731 {
36732 PyThreadState* __tstate = wxPyBeginAllowThreads();
36733 (arg1)->SetThemeEnabled(arg2);
36734 wxPyEndAllowThreads(__tstate);
36735 if (PyErr_Occurred()) SWIG_fail;
36736 }
36737 resultobj = SWIG_Py_Void();
36738 return resultobj;
36739 fail:
36740 return NULL;
36741 }
36742
36743
36744 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36745 PyObject *resultobj = 0;
36746 wxWindow *arg1 = (wxWindow *) 0 ;
36747 bool result;
36748 void *argp1 = 0 ;
36749 int res1 = 0 ;
36750 PyObject *swig_obj[1] ;
36751
36752 if (!args) SWIG_fail;
36753 swig_obj[0] = args;
36754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36755 if (!SWIG_IsOK(res1)) {
36756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
36757 }
36758 arg1 = reinterpret_cast< wxWindow * >(argp1);
36759 {
36760 PyThreadState* __tstate = wxPyBeginAllowThreads();
36761 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
36762 wxPyEndAllowThreads(__tstate);
36763 if (PyErr_Occurred()) SWIG_fail;
36764 }
36765 {
36766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36767 }
36768 return resultobj;
36769 fail:
36770 return NULL;
36771 }
36772
36773
36774 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36775 PyObject *resultobj = 0;
36776 wxWindow *arg1 = (wxWindow *) 0 ;
36777 void *argp1 = 0 ;
36778 int res1 = 0 ;
36779 PyObject *swig_obj[1] ;
36780
36781 if (!args) SWIG_fail;
36782 swig_obj[0] = args;
36783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36784 if (!SWIG_IsOK(res1)) {
36785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
36786 }
36787 arg1 = reinterpret_cast< wxWindow * >(argp1);
36788 {
36789 PyThreadState* __tstate = wxPyBeginAllowThreads();
36790 (arg1)->SetFocus();
36791 wxPyEndAllowThreads(__tstate);
36792 if (PyErr_Occurred()) SWIG_fail;
36793 }
36794 resultobj = SWIG_Py_Void();
36795 return resultobj;
36796 fail:
36797 return NULL;
36798 }
36799
36800
36801 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36802 PyObject *resultobj = 0;
36803 wxWindow *arg1 = (wxWindow *) 0 ;
36804 void *argp1 = 0 ;
36805 int res1 = 0 ;
36806 PyObject *swig_obj[1] ;
36807
36808 if (!args) SWIG_fail;
36809 swig_obj[0] = args;
36810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36811 if (!SWIG_IsOK(res1)) {
36812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
36813 }
36814 arg1 = reinterpret_cast< wxWindow * >(argp1);
36815 {
36816 PyThreadState* __tstate = wxPyBeginAllowThreads();
36817 (arg1)->SetFocusFromKbd();
36818 wxPyEndAllowThreads(__tstate);
36819 if (PyErr_Occurred()) SWIG_fail;
36820 }
36821 resultobj = SWIG_Py_Void();
36822 return resultobj;
36823 fail:
36824 return NULL;
36825 }
36826
36827
36828 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36829 PyObject *resultobj = 0;
36830 wxWindow *result = 0 ;
36831
36832 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
36833 {
36834 if (!wxPyCheckForApp()) SWIG_fail;
36835 PyThreadState* __tstate = wxPyBeginAllowThreads();
36836 result = (wxWindow *)wxWindow::FindFocus();
36837 wxPyEndAllowThreads(__tstate);
36838 if (PyErr_Occurred()) SWIG_fail;
36839 }
36840 {
36841 resultobj = wxPyMake_wxObject(result, 0);
36842 }
36843 return resultobj;
36844 fail:
36845 return NULL;
36846 }
36847
36848
36849 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36850 PyObject *resultobj = 0;
36851 wxWindow *arg1 = (wxWindow *) 0 ;
36852 bool result;
36853 void *argp1 = 0 ;
36854 int res1 = 0 ;
36855 PyObject *swig_obj[1] ;
36856
36857 if (!args) SWIG_fail;
36858 swig_obj[0] = args;
36859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36860 if (!SWIG_IsOK(res1)) {
36861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36862 }
36863 arg1 = reinterpret_cast< wxWindow * >(argp1);
36864 {
36865 PyThreadState* __tstate = wxPyBeginAllowThreads();
36866 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
36867 wxPyEndAllowThreads(__tstate);
36868 if (PyErr_Occurred()) SWIG_fail;
36869 }
36870 {
36871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36872 }
36873 return resultobj;
36874 fail:
36875 return NULL;
36876 }
36877
36878
36879 SWIGINTERN PyObject *_wrap_Window_CanAcceptFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36880 PyObject *resultobj = 0;
36881 wxWindow *arg1 = (wxWindow *) 0 ;
36882 bool result;
36883 void *argp1 = 0 ;
36884 int res1 = 0 ;
36885 PyObject *swig_obj[1] ;
36886
36887 if (!args) SWIG_fail;
36888 swig_obj[0] = args;
36889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36890 if (!SWIG_IsOK(res1)) {
36891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanAcceptFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36892 }
36893 arg1 = reinterpret_cast< wxWindow * >(argp1);
36894 {
36895 PyThreadState* __tstate = wxPyBeginAllowThreads();
36896 result = (bool)((wxWindow const *)arg1)->CanAcceptFocus();
36897 wxPyEndAllowThreads(__tstate);
36898 if (PyErr_Occurred()) SWIG_fail;
36899 }
36900 {
36901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36902 }
36903 return resultobj;
36904 fail:
36905 return NULL;
36906 }
36907
36908
36909 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36910 PyObject *resultobj = 0;
36911 wxWindow *arg1 = (wxWindow *) 0 ;
36912 bool result;
36913 void *argp1 = 0 ;
36914 int res1 = 0 ;
36915 PyObject *swig_obj[1] ;
36916
36917 if (!args) SWIG_fail;
36918 swig_obj[0] = args;
36919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36920 if (!SWIG_IsOK(res1)) {
36921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36922 }
36923 arg1 = reinterpret_cast< wxWindow * >(argp1);
36924 {
36925 PyThreadState* __tstate = wxPyBeginAllowThreads();
36926 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
36927 wxPyEndAllowThreads(__tstate);
36928 if (PyErr_Occurred()) SWIG_fail;
36929 }
36930 {
36931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36932 }
36933 return resultobj;
36934 fail:
36935 return NULL;
36936 }
36937
36938
36939 SWIGINTERN PyObject *_wrap_Window_CanAcceptFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36940 PyObject *resultobj = 0;
36941 wxWindow *arg1 = (wxWindow *) 0 ;
36942 bool result;
36943 void *argp1 = 0 ;
36944 int res1 = 0 ;
36945 PyObject *swig_obj[1] ;
36946
36947 if (!args) SWIG_fail;
36948 swig_obj[0] = args;
36949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36950 if (!SWIG_IsOK(res1)) {
36951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanAcceptFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36952 }
36953 arg1 = reinterpret_cast< wxWindow * >(argp1);
36954 {
36955 PyThreadState* __tstate = wxPyBeginAllowThreads();
36956 result = (bool)((wxWindow const *)arg1)->CanAcceptFocusFromKeyboard();
36957 wxPyEndAllowThreads(__tstate);
36958 if (PyErr_Occurred()) SWIG_fail;
36959 }
36960 {
36961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36962 }
36963 return resultobj;
36964 fail:
36965 return NULL;
36966 }
36967
36968
36969 SWIGINTERN PyObject *_wrap_Window_SetCanFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36970 PyObject *resultobj = 0;
36971 wxWindow *arg1 = (wxWindow *) 0 ;
36972 bool arg2 ;
36973 void *argp1 = 0 ;
36974 int res1 = 0 ;
36975 bool val2 ;
36976 int ecode2 = 0 ;
36977 PyObject * obj0 = 0 ;
36978 PyObject * obj1 = 0 ;
36979 char * kwnames[] = {
36980 (char *) "self",(char *) "canFocus", NULL
36981 };
36982
36983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCanFocus",kwnames,&obj0,&obj1)) SWIG_fail;
36984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36985 if (!SWIG_IsOK(res1)) {
36986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCanFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
36987 }
36988 arg1 = reinterpret_cast< wxWindow * >(argp1);
36989 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36990 if (!SWIG_IsOK(ecode2)) {
36991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetCanFocus" "', expected argument " "2"" of type '" "bool""'");
36992 }
36993 arg2 = static_cast< bool >(val2);
36994 {
36995 PyThreadState* __tstate = wxPyBeginAllowThreads();
36996 (arg1)->SetCanFocus(arg2);
36997 wxPyEndAllowThreads(__tstate);
36998 if (PyErr_Occurred()) SWIG_fail;
36999 }
37000 resultobj = SWIG_Py_Void();
37001 return resultobj;
37002 fail:
37003 return NULL;
37004 }
37005
37006
37007 SWIGINTERN PyObject *_wrap_Window_NavigateIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37008 PyObject *resultobj = 0;
37009 wxWindow *arg1 = (wxWindow *) 0 ;
37010 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
37011 bool result;
37012 void *argp1 = 0 ;
37013 int res1 = 0 ;
37014 int val2 ;
37015 int ecode2 = 0 ;
37016 PyObject * obj0 = 0 ;
37017 PyObject * obj1 = 0 ;
37018 char * kwnames[] = {
37019 (char *) "self",(char *) "flags", NULL
37020 };
37021
37022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_NavigateIn",kwnames,&obj0,&obj1)) SWIG_fail;
37023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37024 if (!SWIG_IsOK(res1)) {
37025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_NavigateIn" "', expected argument " "1"" of type '" "wxWindow *""'");
37026 }
37027 arg1 = reinterpret_cast< wxWindow * >(argp1);
37028 if (obj1) {
37029 ecode2 = SWIG_AsVal_int(obj1, &val2);
37030 if (!SWIG_IsOK(ecode2)) {
37031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_NavigateIn" "', expected argument " "2"" of type '" "int""'");
37032 }
37033 arg2 = static_cast< int >(val2);
37034 }
37035 {
37036 PyThreadState* __tstate = wxPyBeginAllowThreads();
37037 result = (bool)(arg1)->NavigateIn(arg2);
37038 wxPyEndAllowThreads(__tstate);
37039 if (PyErr_Occurred()) SWIG_fail;
37040 }
37041 {
37042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37043 }
37044 return resultobj;
37045 fail:
37046 return NULL;
37047 }
37048
37049
37050 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37051 PyObject *resultobj = 0;
37052 wxWindow *arg1 = (wxWindow *) 0 ;
37053 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
37054 bool result;
37055 void *argp1 = 0 ;
37056 int res1 = 0 ;
37057 int val2 ;
37058 int ecode2 = 0 ;
37059 PyObject * obj0 = 0 ;
37060 PyObject * obj1 = 0 ;
37061 char * kwnames[] = {
37062 (char *) "self",(char *) "flags", NULL
37063 };
37064
37065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
37066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37067 if (!SWIG_IsOK(res1)) {
37068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
37069 }
37070 arg1 = reinterpret_cast< wxWindow * >(argp1);
37071 if (obj1) {
37072 ecode2 = SWIG_AsVal_int(obj1, &val2);
37073 if (!SWIG_IsOK(ecode2)) {
37074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
37075 }
37076 arg2 = static_cast< int >(val2);
37077 }
37078 {
37079 PyThreadState* __tstate = wxPyBeginAllowThreads();
37080 result = (bool)(arg1)->Navigate(arg2);
37081 wxPyEndAllowThreads(__tstate);
37082 if (PyErr_Occurred()) SWIG_fail;
37083 }
37084 {
37085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37086 }
37087 return resultobj;
37088 fail:
37089 return NULL;
37090 }
37091
37092
37093 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37094 PyObject *resultobj = 0;
37095 wxWindow *arg1 = (wxWindow *) 0 ;
37096 wxWindow *arg2 = (wxWindow *) 0 ;
37097 void *argp1 = 0 ;
37098 int res1 = 0 ;
37099 void *argp2 = 0 ;
37100 int res2 = 0 ;
37101 PyObject * obj0 = 0 ;
37102 PyObject * obj1 = 0 ;
37103 char * kwnames[] = {
37104 (char *) "self",(char *) "win", NULL
37105 };
37106
37107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
37108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37109 if (!SWIG_IsOK(res1)) {
37110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
37111 }
37112 arg1 = reinterpret_cast< wxWindow * >(argp1);
37113 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37114 if (!SWIG_IsOK(res2)) {
37115 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
37116 }
37117 arg2 = reinterpret_cast< wxWindow * >(argp2);
37118 {
37119 PyThreadState* __tstate = wxPyBeginAllowThreads();
37120 (arg1)->MoveAfterInTabOrder(arg2);
37121 wxPyEndAllowThreads(__tstate);
37122 if (PyErr_Occurred()) SWIG_fail;
37123 }
37124 resultobj = SWIG_Py_Void();
37125 return resultobj;
37126 fail:
37127 return NULL;
37128 }
37129
37130
37131 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37132 PyObject *resultobj = 0;
37133 wxWindow *arg1 = (wxWindow *) 0 ;
37134 wxWindow *arg2 = (wxWindow *) 0 ;
37135 void *argp1 = 0 ;
37136 int res1 = 0 ;
37137 void *argp2 = 0 ;
37138 int res2 = 0 ;
37139 PyObject * obj0 = 0 ;
37140 PyObject * obj1 = 0 ;
37141 char * kwnames[] = {
37142 (char *) "self",(char *) "win", NULL
37143 };
37144
37145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
37146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37147 if (!SWIG_IsOK(res1)) {
37148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
37149 }
37150 arg1 = reinterpret_cast< wxWindow * >(argp1);
37151 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37152 if (!SWIG_IsOK(res2)) {
37153 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
37154 }
37155 arg2 = reinterpret_cast< wxWindow * >(argp2);
37156 {
37157 PyThreadState* __tstate = wxPyBeginAllowThreads();
37158 (arg1)->MoveBeforeInTabOrder(arg2);
37159 wxPyEndAllowThreads(__tstate);
37160 if (PyErr_Occurred()) SWIG_fail;
37161 }
37162 resultobj = SWIG_Py_Void();
37163 return resultobj;
37164 fail:
37165 return NULL;
37166 }
37167
37168
37169 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37170 PyObject *resultobj = 0;
37171 wxWindow *arg1 = (wxWindow *) 0 ;
37172 PyObject *result = 0 ;
37173 void *argp1 = 0 ;
37174 int res1 = 0 ;
37175 PyObject *swig_obj[1] ;
37176
37177 if (!args) SWIG_fail;
37178 swig_obj[0] = args;
37179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37180 if (!SWIG_IsOK(res1)) {
37181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
37182 }
37183 arg1 = reinterpret_cast< wxWindow * >(argp1);
37184 {
37185 PyThreadState* __tstate = wxPyBeginAllowThreads();
37186 result = (PyObject *)wxWindow_GetChildren(arg1);
37187 wxPyEndAllowThreads(__tstate);
37188 if (PyErr_Occurred()) SWIG_fail;
37189 }
37190 resultobj = result;
37191 return resultobj;
37192 fail:
37193 return NULL;
37194 }
37195
37196
37197 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37198 PyObject *resultobj = 0;
37199 wxWindow *arg1 = (wxWindow *) 0 ;
37200 wxWindow *result = 0 ;
37201 void *argp1 = 0 ;
37202 int res1 = 0 ;
37203 PyObject *swig_obj[1] ;
37204
37205 if (!args) SWIG_fail;
37206 swig_obj[0] = args;
37207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37208 if (!SWIG_IsOK(res1)) {
37209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
37210 }
37211 arg1 = reinterpret_cast< wxWindow * >(argp1);
37212 {
37213 PyThreadState* __tstate = wxPyBeginAllowThreads();
37214 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
37215 wxPyEndAllowThreads(__tstate);
37216 if (PyErr_Occurred()) SWIG_fail;
37217 }
37218 {
37219 resultobj = wxPyMake_wxObject(result, 0);
37220 }
37221 return resultobj;
37222 fail:
37223 return NULL;
37224 }
37225
37226
37227 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37228 PyObject *resultobj = 0;
37229 wxWindow *arg1 = (wxWindow *) 0 ;
37230 wxWindow *result = 0 ;
37231 void *argp1 = 0 ;
37232 int res1 = 0 ;
37233 PyObject *swig_obj[1] ;
37234
37235 if (!args) SWIG_fail;
37236 swig_obj[0] = args;
37237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37238 if (!SWIG_IsOK(res1)) {
37239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
37240 }
37241 arg1 = reinterpret_cast< wxWindow * >(argp1);
37242 {
37243 PyThreadState* __tstate = wxPyBeginAllowThreads();
37244 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
37245 wxPyEndAllowThreads(__tstate);
37246 if (PyErr_Occurred()) SWIG_fail;
37247 }
37248 {
37249 resultobj = wxPyMake_wxObject(result, 0);
37250 }
37251 return resultobj;
37252 fail:
37253 return NULL;
37254 }
37255
37256
37257 SWIGINTERN PyObject *_wrap_Window_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37258 PyObject *resultobj = 0;
37259 wxWindow *arg1 = (wxWindow *) 0 ;
37260 wxWindow *result = 0 ;
37261 void *argp1 = 0 ;
37262 int res1 = 0 ;
37263 PyObject *swig_obj[1] ;
37264
37265 if (!args) SWIG_fail;
37266 swig_obj[0] = args;
37267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37268 if (!SWIG_IsOK(res1)) {
37269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
37270 }
37271 arg1 = reinterpret_cast< wxWindow * >(argp1);
37272 {
37273 PyThreadState* __tstate = wxPyBeginAllowThreads();
37274 result = (wxWindow *)wxWindow_GetTopLevelParent(arg1);
37275 wxPyEndAllowThreads(__tstate);
37276 if (PyErr_Occurred()) SWIG_fail;
37277 }
37278 {
37279 resultobj = wxPyMake_wxObject(result, 0);
37280 }
37281 return resultobj;
37282 fail:
37283 return NULL;
37284 }
37285
37286
37287 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37288 PyObject *resultobj = 0;
37289 wxWindow *arg1 = (wxWindow *) 0 ;
37290 bool result;
37291 void *argp1 = 0 ;
37292 int res1 = 0 ;
37293 PyObject *swig_obj[1] ;
37294
37295 if (!args) SWIG_fail;
37296 swig_obj[0] = args;
37297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37298 if (!SWIG_IsOK(res1)) {
37299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
37300 }
37301 arg1 = reinterpret_cast< wxWindow * >(argp1);
37302 {
37303 PyThreadState* __tstate = wxPyBeginAllowThreads();
37304 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
37305 wxPyEndAllowThreads(__tstate);
37306 if (PyErr_Occurred()) SWIG_fail;
37307 }
37308 {
37309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37310 }
37311 return resultobj;
37312 fail:
37313 return NULL;
37314 }
37315
37316
37317 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37318 PyObject *resultobj = 0;
37319 wxWindow *arg1 = (wxWindow *) 0 ;
37320 wxWindow *arg2 = (wxWindow *) 0 ;
37321 bool result;
37322 void *argp1 = 0 ;
37323 int res1 = 0 ;
37324 void *argp2 = 0 ;
37325 int res2 = 0 ;
37326 PyObject * obj0 = 0 ;
37327 PyObject * obj1 = 0 ;
37328 char * kwnames[] = {
37329 (char *) "self",(char *) "newParent", NULL
37330 };
37331
37332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
37333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37334 if (!SWIG_IsOK(res1)) {
37335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
37336 }
37337 arg1 = reinterpret_cast< wxWindow * >(argp1);
37338 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37339 if (!SWIG_IsOK(res2)) {
37340 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
37341 }
37342 arg2 = reinterpret_cast< wxWindow * >(argp2);
37343 {
37344 PyThreadState* __tstate = wxPyBeginAllowThreads();
37345 result = (bool)(arg1)->Reparent(arg2);
37346 wxPyEndAllowThreads(__tstate);
37347 if (PyErr_Occurred()) SWIG_fail;
37348 }
37349 {
37350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37351 }
37352 return resultobj;
37353 fail:
37354 return NULL;
37355 }
37356
37357
37358 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37359 PyObject *resultobj = 0;
37360 wxWindow *arg1 = (wxWindow *) 0 ;
37361 wxWindow *arg2 = (wxWindow *) 0 ;
37362 void *argp1 = 0 ;
37363 int res1 = 0 ;
37364 void *argp2 = 0 ;
37365 int res2 = 0 ;
37366 PyObject * obj0 = 0 ;
37367 PyObject * obj1 = 0 ;
37368 char * kwnames[] = {
37369 (char *) "self",(char *) "child", NULL
37370 };
37371
37372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
37373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37374 if (!SWIG_IsOK(res1)) {
37375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
37376 }
37377 arg1 = reinterpret_cast< wxWindow * >(argp1);
37378 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37379 if (!SWIG_IsOK(res2)) {
37380 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
37381 }
37382 arg2 = reinterpret_cast< wxWindow * >(argp2);
37383 {
37384 PyThreadState* __tstate = wxPyBeginAllowThreads();
37385 (arg1)->AddChild(arg2);
37386 wxPyEndAllowThreads(__tstate);
37387 if (PyErr_Occurred()) SWIG_fail;
37388 }
37389 resultobj = SWIG_Py_Void();
37390 return resultobj;
37391 fail:
37392 return NULL;
37393 }
37394
37395
37396 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37397 PyObject *resultobj = 0;
37398 wxWindow *arg1 = (wxWindow *) 0 ;
37399 wxWindow *arg2 = (wxWindow *) 0 ;
37400 void *argp1 = 0 ;
37401 int res1 = 0 ;
37402 void *argp2 = 0 ;
37403 int res2 = 0 ;
37404 PyObject * obj0 = 0 ;
37405 PyObject * obj1 = 0 ;
37406 char * kwnames[] = {
37407 (char *) "self",(char *) "child", NULL
37408 };
37409
37410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
37411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37412 if (!SWIG_IsOK(res1)) {
37413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
37414 }
37415 arg1 = reinterpret_cast< wxWindow * >(argp1);
37416 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37417 if (!SWIG_IsOK(res2)) {
37418 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
37419 }
37420 arg2 = reinterpret_cast< wxWindow * >(argp2);
37421 {
37422 PyThreadState* __tstate = wxPyBeginAllowThreads();
37423 (arg1)->RemoveChild(arg2);
37424 wxPyEndAllowThreads(__tstate);
37425 if (PyErr_Occurred()) SWIG_fail;
37426 }
37427 resultobj = SWIG_Py_Void();
37428 return resultobj;
37429 fail:
37430 return NULL;
37431 }
37432
37433
37434 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37435 PyObject *resultobj = 0;
37436 wxWindow *arg1 = (wxWindow *) 0 ;
37437 bool arg2 ;
37438 void *argp1 = 0 ;
37439 int res1 = 0 ;
37440 bool val2 ;
37441 int ecode2 = 0 ;
37442 PyObject * obj0 = 0 ;
37443 PyObject * obj1 = 0 ;
37444 char * kwnames[] = {
37445 (char *) "self",(char *) "on", NULL
37446 };
37447
37448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
37449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37450 if (!SWIG_IsOK(res1)) {
37451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
37452 }
37453 arg1 = reinterpret_cast< wxWindow * >(argp1);
37454 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37455 if (!SWIG_IsOK(ecode2)) {
37456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
37457 }
37458 arg2 = static_cast< bool >(val2);
37459 {
37460 PyThreadState* __tstate = wxPyBeginAllowThreads();
37461 wxWindow_SetDoubleBuffered(arg1,arg2);
37462 wxPyEndAllowThreads(__tstate);
37463 if (PyErr_Occurred()) SWIG_fail;
37464 }
37465 resultobj = SWIG_Py_Void();
37466 return resultobj;
37467 fail:
37468 return NULL;
37469 }
37470
37471
37472 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37473 PyObject *resultobj = 0;
37474 wxWindow *arg1 = (wxWindow *) 0 ;
37475 long arg2 ;
37476 wxWindow *result = 0 ;
37477 void *argp1 = 0 ;
37478 int res1 = 0 ;
37479 long val2 ;
37480 int ecode2 = 0 ;
37481 PyObject * obj0 = 0 ;
37482 PyObject * obj1 = 0 ;
37483 char * kwnames[] = {
37484 (char *) "self",(char *) "winid", NULL
37485 };
37486
37487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37489 if (!SWIG_IsOK(res1)) {
37490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
37491 }
37492 arg1 = reinterpret_cast< wxWindow * >(argp1);
37493 ecode2 = SWIG_AsVal_long(obj1, &val2);
37494 if (!SWIG_IsOK(ecode2)) {
37495 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
37496 }
37497 arg2 = static_cast< long >(val2);
37498 {
37499 PyThreadState* __tstate = wxPyBeginAllowThreads();
37500 result = (wxWindow *)(arg1)->FindWindow(arg2);
37501 wxPyEndAllowThreads(__tstate);
37502 if (PyErr_Occurred()) SWIG_fail;
37503 }
37504 {
37505 resultobj = wxPyMake_wxObject(result, 0);
37506 }
37507 return resultobj;
37508 fail:
37509 return NULL;
37510 }
37511
37512
37513 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37514 PyObject *resultobj = 0;
37515 wxWindow *arg1 = (wxWindow *) 0 ;
37516 wxString *arg2 = 0 ;
37517 wxWindow *result = 0 ;
37518 void *argp1 = 0 ;
37519 int res1 = 0 ;
37520 bool temp2 = false ;
37521 PyObject * obj0 = 0 ;
37522 PyObject * obj1 = 0 ;
37523 char * kwnames[] = {
37524 (char *) "self",(char *) "name", NULL
37525 };
37526
37527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37529 if (!SWIG_IsOK(res1)) {
37530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
37531 }
37532 arg1 = reinterpret_cast< wxWindow * >(argp1);
37533 {
37534 arg2 = wxString_in_helper(obj1);
37535 if (arg2 == NULL) SWIG_fail;
37536 temp2 = true;
37537 }
37538 {
37539 PyThreadState* __tstate = wxPyBeginAllowThreads();
37540 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
37541 wxPyEndAllowThreads(__tstate);
37542 if (PyErr_Occurred()) SWIG_fail;
37543 }
37544 {
37545 resultobj = wxPyMake_wxObject(result, 0);
37546 }
37547 {
37548 if (temp2)
37549 delete arg2;
37550 }
37551 return resultobj;
37552 fail:
37553 {
37554 if (temp2)
37555 delete arg2;
37556 }
37557 return NULL;
37558 }
37559
37560
37561 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37562 PyObject *resultobj = 0;
37563 wxWindow *arg1 = (wxWindow *) 0 ;
37564 wxEvtHandler *result = 0 ;
37565 void *argp1 = 0 ;
37566 int res1 = 0 ;
37567 PyObject *swig_obj[1] ;
37568
37569 if (!args) SWIG_fail;
37570 swig_obj[0] = args;
37571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37572 if (!SWIG_IsOK(res1)) {
37573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
37574 }
37575 arg1 = reinterpret_cast< wxWindow * >(argp1);
37576 {
37577 PyThreadState* __tstate = wxPyBeginAllowThreads();
37578 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
37579 wxPyEndAllowThreads(__tstate);
37580 if (PyErr_Occurred()) SWIG_fail;
37581 }
37582 {
37583 resultobj = wxPyMake_wxObject(result, 0);
37584 }
37585 return resultobj;
37586 fail:
37587 return NULL;
37588 }
37589
37590
37591 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37592 PyObject *resultobj = 0;
37593 wxWindow *arg1 = (wxWindow *) 0 ;
37594 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
37595 void *argp1 = 0 ;
37596 int res1 = 0 ;
37597 void *argp2 = 0 ;
37598 int res2 = 0 ;
37599 PyObject * obj0 = 0 ;
37600 PyObject * obj1 = 0 ;
37601 char * kwnames[] = {
37602 (char *) "self",(char *) "handler", NULL
37603 };
37604
37605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37607 if (!SWIG_IsOK(res1)) {
37608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37609 }
37610 arg1 = reinterpret_cast< wxWindow * >(argp1);
37611 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
37612 if (!SWIG_IsOK(res2)) {
37613 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
37614 }
37615 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
37616 {
37617 PyThreadState* __tstate = wxPyBeginAllowThreads();
37618 (arg1)->SetEventHandler(arg2);
37619 wxPyEndAllowThreads(__tstate);
37620 if (PyErr_Occurred()) SWIG_fail;
37621 }
37622 resultobj = SWIG_Py_Void();
37623 return resultobj;
37624 fail:
37625 return NULL;
37626 }
37627
37628
37629 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37630 PyObject *resultobj = 0;
37631 wxWindow *arg1 = (wxWindow *) 0 ;
37632 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
37633 void *argp1 = 0 ;
37634 int res1 = 0 ;
37635 void *argp2 = 0 ;
37636 int res2 = 0 ;
37637 PyObject * obj0 = 0 ;
37638 PyObject * obj1 = 0 ;
37639 char * kwnames[] = {
37640 (char *) "self",(char *) "handler", NULL
37641 };
37642
37643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37645 if (!SWIG_IsOK(res1)) {
37646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37647 }
37648 arg1 = reinterpret_cast< wxWindow * >(argp1);
37649 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
37650 if (!SWIG_IsOK(res2)) {
37651 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
37652 }
37653 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
37654 {
37655 PyThreadState* __tstate = wxPyBeginAllowThreads();
37656 (arg1)->PushEventHandler(arg2);
37657 wxPyEndAllowThreads(__tstate);
37658 if (PyErr_Occurred()) SWIG_fail;
37659 }
37660 resultobj = SWIG_Py_Void();
37661 return resultobj;
37662 fail:
37663 return NULL;
37664 }
37665
37666
37667 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37668 PyObject *resultobj = 0;
37669 wxWindow *arg1 = (wxWindow *) 0 ;
37670 bool arg2 = (bool) false ;
37671 wxEvtHandler *result = 0 ;
37672 void *argp1 = 0 ;
37673 int res1 = 0 ;
37674 bool val2 ;
37675 int ecode2 = 0 ;
37676 PyObject * obj0 = 0 ;
37677 PyObject * obj1 = 0 ;
37678 char * kwnames[] = {
37679 (char *) "self",(char *) "deleteHandler", NULL
37680 };
37681
37682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37684 if (!SWIG_IsOK(res1)) {
37685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37686 }
37687 arg1 = reinterpret_cast< wxWindow * >(argp1);
37688 if (obj1) {
37689 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37690 if (!SWIG_IsOK(ecode2)) {
37691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
37692 }
37693 arg2 = static_cast< bool >(val2);
37694 }
37695 {
37696 PyThreadState* __tstate = wxPyBeginAllowThreads();
37697 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
37698 wxPyEndAllowThreads(__tstate);
37699 if (PyErr_Occurred()) SWIG_fail;
37700 }
37701 {
37702 resultobj = wxPyMake_wxObject(result, 0);
37703 }
37704 return resultobj;
37705 fail:
37706 return NULL;
37707 }
37708
37709
37710 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37711 PyObject *resultobj = 0;
37712 wxWindow *arg1 = (wxWindow *) 0 ;
37713 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
37714 bool result;
37715 void *argp1 = 0 ;
37716 int res1 = 0 ;
37717 void *argp2 = 0 ;
37718 int res2 = 0 ;
37719 PyObject * obj0 = 0 ;
37720 PyObject * obj1 = 0 ;
37721 char * kwnames[] = {
37722 (char *) "self",(char *) "handler", NULL
37723 };
37724
37725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37727 if (!SWIG_IsOK(res1)) {
37728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37729 }
37730 arg1 = reinterpret_cast< wxWindow * >(argp1);
37731 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
37732 if (!SWIG_IsOK(res2)) {
37733 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
37734 }
37735 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
37736 {
37737 PyThreadState* __tstate = wxPyBeginAllowThreads();
37738 result = (bool)(arg1)->RemoveEventHandler(arg2);
37739 wxPyEndAllowThreads(__tstate);
37740 if (PyErr_Occurred()) SWIG_fail;
37741 }
37742 {
37743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37744 }
37745 return resultobj;
37746 fail:
37747 return NULL;
37748 }
37749
37750
37751 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37752 PyObject *resultobj = 0;
37753 wxWindow *arg1 = (wxWindow *) 0 ;
37754 wxValidator *arg2 = 0 ;
37755 void *argp1 = 0 ;
37756 int res1 = 0 ;
37757 void *argp2 = 0 ;
37758 int res2 = 0 ;
37759 PyObject * obj0 = 0 ;
37760 PyObject * obj1 = 0 ;
37761 char * kwnames[] = {
37762 (char *) "self",(char *) "validator", NULL
37763 };
37764
37765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
37766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37767 if (!SWIG_IsOK(res1)) {
37768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
37769 }
37770 arg1 = reinterpret_cast< wxWindow * >(argp1);
37771 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
37772 if (!SWIG_IsOK(res2)) {
37773 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
37774 }
37775 if (!argp2) {
37776 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
37777 }
37778 arg2 = reinterpret_cast< wxValidator * >(argp2);
37779 {
37780 PyThreadState* __tstate = wxPyBeginAllowThreads();
37781 (arg1)->SetValidator((wxValidator const &)*arg2);
37782 wxPyEndAllowThreads(__tstate);
37783 if (PyErr_Occurred()) SWIG_fail;
37784 }
37785 resultobj = SWIG_Py_Void();
37786 return resultobj;
37787 fail:
37788 return NULL;
37789 }
37790
37791
37792 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37793 PyObject *resultobj = 0;
37794 wxWindow *arg1 = (wxWindow *) 0 ;
37795 wxValidator *result = 0 ;
37796 void *argp1 = 0 ;
37797 int res1 = 0 ;
37798 PyObject *swig_obj[1] ;
37799
37800 if (!args) SWIG_fail;
37801 swig_obj[0] = args;
37802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37803 if (!SWIG_IsOK(res1)) {
37804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
37805 }
37806 arg1 = reinterpret_cast< wxWindow * >(argp1);
37807 {
37808 PyThreadState* __tstate = wxPyBeginAllowThreads();
37809 result = (wxValidator *)(arg1)->GetValidator();
37810 wxPyEndAllowThreads(__tstate);
37811 if (PyErr_Occurred()) SWIG_fail;
37812 }
37813 {
37814 resultobj = wxPyMake_wxObject(result, (bool)0);
37815 }
37816 return resultobj;
37817 fail:
37818 return NULL;
37819 }
37820
37821
37822 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37823 PyObject *resultobj = 0;
37824 wxWindow *arg1 = (wxWindow *) 0 ;
37825 bool result;
37826 void *argp1 = 0 ;
37827 int res1 = 0 ;
37828 PyObject *swig_obj[1] ;
37829
37830 if (!args) SWIG_fail;
37831 swig_obj[0] = args;
37832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37833 if (!SWIG_IsOK(res1)) {
37834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
37835 }
37836 arg1 = reinterpret_cast< wxWindow * >(argp1);
37837 {
37838 PyThreadState* __tstate = wxPyBeginAllowThreads();
37839 result = (bool)(arg1)->Validate();
37840 wxPyEndAllowThreads(__tstate);
37841 if (PyErr_Occurred()) SWIG_fail;
37842 }
37843 {
37844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37845 }
37846 return resultobj;
37847 fail:
37848 return NULL;
37849 }
37850
37851
37852 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37853 PyObject *resultobj = 0;
37854 wxWindow *arg1 = (wxWindow *) 0 ;
37855 bool result;
37856 void *argp1 = 0 ;
37857 int res1 = 0 ;
37858 PyObject *swig_obj[1] ;
37859
37860 if (!args) SWIG_fail;
37861 swig_obj[0] = args;
37862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37863 if (!SWIG_IsOK(res1)) {
37864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37865 }
37866 arg1 = reinterpret_cast< wxWindow * >(argp1);
37867 {
37868 PyThreadState* __tstate = wxPyBeginAllowThreads();
37869 result = (bool)(arg1)->TransferDataToWindow();
37870 wxPyEndAllowThreads(__tstate);
37871 if (PyErr_Occurred()) SWIG_fail;
37872 }
37873 {
37874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37875 }
37876 return resultobj;
37877 fail:
37878 return NULL;
37879 }
37880
37881
37882 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37883 PyObject *resultobj = 0;
37884 wxWindow *arg1 = (wxWindow *) 0 ;
37885 bool result;
37886 void *argp1 = 0 ;
37887 int res1 = 0 ;
37888 PyObject *swig_obj[1] ;
37889
37890 if (!args) SWIG_fail;
37891 swig_obj[0] = args;
37892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37893 if (!SWIG_IsOK(res1)) {
37894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37895 }
37896 arg1 = reinterpret_cast< wxWindow * >(argp1);
37897 {
37898 PyThreadState* __tstate = wxPyBeginAllowThreads();
37899 result = (bool)(arg1)->TransferDataFromWindow();
37900 wxPyEndAllowThreads(__tstate);
37901 if (PyErr_Occurred()) SWIG_fail;
37902 }
37903 {
37904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37905 }
37906 return resultobj;
37907 fail:
37908 return NULL;
37909 }
37910
37911
37912 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37913 PyObject *resultobj = 0;
37914 wxWindow *arg1 = (wxWindow *) 0 ;
37915 void *argp1 = 0 ;
37916 int res1 = 0 ;
37917 PyObject *swig_obj[1] ;
37918
37919 if (!args) SWIG_fail;
37920 swig_obj[0] = args;
37921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37922 if (!SWIG_IsOK(res1)) {
37923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37924 }
37925 arg1 = reinterpret_cast< wxWindow * >(argp1);
37926 {
37927 PyThreadState* __tstate = wxPyBeginAllowThreads();
37928 (arg1)->InitDialog();
37929 wxPyEndAllowThreads(__tstate);
37930 if (PyErr_Occurred()) SWIG_fail;
37931 }
37932 resultobj = SWIG_Py_Void();
37933 return resultobj;
37934 fail:
37935 return NULL;
37936 }
37937
37938
37939 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37940 PyObject *resultobj = 0;
37941 wxWindow *arg1 = (wxWindow *) 0 ;
37942 wxAcceleratorTable *arg2 = 0 ;
37943 void *argp1 = 0 ;
37944 int res1 = 0 ;
37945 void *argp2 = 0 ;
37946 int res2 = 0 ;
37947 PyObject * obj0 = 0 ;
37948 PyObject * obj1 = 0 ;
37949 char * kwnames[] = {
37950 (char *) "self",(char *) "accel", NULL
37951 };
37952
37953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
37954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37955 if (!SWIG_IsOK(res1)) {
37956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37957 }
37958 arg1 = reinterpret_cast< wxWindow * >(argp1);
37959 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
37960 if (!SWIG_IsOK(res2)) {
37961 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37962 }
37963 if (!argp2) {
37964 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37965 }
37966 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
37967 {
37968 PyThreadState* __tstate = wxPyBeginAllowThreads();
37969 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
37970 wxPyEndAllowThreads(__tstate);
37971 if (PyErr_Occurred()) SWIG_fail;
37972 }
37973 resultobj = SWIG_Py_Void();
37974 return resultobj;
37975 fail:
37976 return NULL;
37977 }
37978
37979
37980 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37981 PyObject *resultobj = 0;
37982 wxWindow *arg1 = (wxWindow *) 0 ;
37983 wxAcceleratorTable *result = 0 ;
37984 void *argp1 = 0 ;
37985 int res1 = 0 ;
37986 PyObject *swig_obj[1] ;
37987
37988 if (!args) SWIG_fail;
37989 swig_obj[0] = args;
37990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37991 if (!SWIG_IsOK(res1)) {
37992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37993 }
37994 arg1 = reinterpret_cast< wxWindow * >(argp1);
37995 {
37996 PyThreadState* __tstate = wxPyBeginAllowThreads();
37997 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
37998 wxPyEndAllowThreads(__tstate);
37999 if (PyErr_Occurred()) SWIG_fail;
38000 }
38001 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
38002 return resultobj;
38003 fail:
38004 return NULL;
38005 }
38006
38007
38008 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38009 PyObject *resultobj = 0;
38010 wxWindow *arg1 = (wxWindow *) 0 ;
38011 int arg2 ;
38012 int arg3 ;
38013 int arg4 ;
38014 bool result;
38015 void *argp1 = 0 ;
38016 int res1 = 0 ;
38017 int val2 ;
38018 int ecode2 = 0 ;
38019 int val3 ;
38020 int ecode3 = 0 ;
38021 int val4 ;
38022 int ecode4 = 0 ;
38023 PyObject * obj0 = 0 ;
38024 PyObject * obj1 = 0 ;
38025 PyObject * obj2 = 0 ;
38026 PyObject * obj3 = 0 ;
38027 char * kwnames[] = {
38028 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
38029 };
38030
38031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38033 if (!SWIG_IsOK(res1)) {
38034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
38035 }
38036 arg1 = reinterpret_cast< wxWindow * >(argp1);
38037 ecode2 = SWIG_AsVal_int(obj1, &val2);
38038 if (!SWIG_IsOK(ecode2)) {
38039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
38040 }
38041 arg2 = static_cast< int >(val2);
38042 ecode3 = SWIG_AsVal_int(obj2, &val3);
38043 if (!SWIG_IsOK(ecode3)) {
38044 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
38045 }
38046 arg3 = static_cast< int >(val3);
38047 ecode4 = SWIG_AsVal_int(obj3, &val4);
38048 if (!SWIG_IsOK(ecode4)) {
38049 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
38050 }
38051 arg4 = static_cast< int >(val4);
38052 {
38053 PyThreadState* __tstate = wxPyBeginAllowThreads();
38054 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
38055 wxPyEndAllowThreads(__tstate);
38056 if (PyErr_Occurred()) SWIG_fail;
38057 }
38058 {
38059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38060 }
38061 return resultobj;
38062 fail:
38063 return NULL;
38064 }
38065
38066
38067 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38068 PyObject *resultobj = 0;
38069 wxWindow *arg1 = (wxWindow *) 0 ;
38070 int arg2 ;
38071 bool result;
38072 void *argp1 = 0 ;
38073 int res1 = 0 ;
38074 int val2 ;
38075 int ecode2 = 0 ;
38076 PyObject * obj0 = 0 ;
38077 PyObject * obj1 = 0 ;
38078 char * kwnames[] = {
38079 (char *) "self",(char *) "hotkeyId", NULL
38080 };
38081
38082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
38083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38084 if (!SWIG_IsOK(res1)) {
38085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
38086 }
38087 arg1 = reinterpret_cast< wxWindow * >(argp1);
38088 ecode2 = SWIG_AsVal_int(obj1, &val2);
38089 if (!SWIG_IsOK(ecode2)) {
38090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
38091 }
38092 arg2 = static_cast< int >(val2);
38093 {
38094 PyThreadState* __tstate = wxPyBeginAllowThreads();
38095 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
38096 wxPyEndAllowThreads(__tstate);
38097 if (PyErr_Occurred()) SWIG_fail;
38098 }
38099 {
38100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38101 }
38102 return resultobj;
38103 fail:
38104 return NULL;
38105 }
38106
38107
38108 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38109 PyObject *resultobj = 0;
38110 wxWindow *arg1 = (wxWindow *) 0 ;
38111 wxPoint *arg2 = 0 ;
38112 wxPoint result;
38113 void *argp1 = 0 ;
38114 int res1 = 0 ;
38115 wxPoint temp2 ;
38116 PyObject * obj0 = 0 ;
38117 PyObject * obj1 = 0 ;
38118 char * kwnames[] = {
38119 (char *) "self",(char *) "pt", NULL
38120 };
38121
38122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
38123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38124 if (!SWIG_IsOK(res1)) {
38125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
38126 }
38127 arg1 = reinterpret_cast< wxWindow * >(argp1);
38128 {
38129 arg2 = &temp2;
38130 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38131 }
38132 {
38133 PyThreadState* __tstate = wxPyBeginAllowThreads();
38134 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
38135 wxPyEndAllowThreads(__tstate);
38136 if (PyErr_Occurred()) SWIG_fail;
38137 }
38138 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
38139 return resultobj;
38140 fail:
38141 return NULL;
38142 }
38143
38144
38145 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38146 PyObject *resultobj = 0;
38147 wxWindow *arg1 = (wxWindow *) 0 ;
38148 wxSize *arg2 = 0 ;
38149 wxSize result;
38150 void *argp1 = 0 ;
38151 int res1 = 0 ;
38152 wxSize temp2 ;
38153 PyObject * obj0 = 0 ;
38154 PyObject * obj1 = 0 ;
38155 char * kwnames[] = {
38156 (char *) "self",(char *) "sz", NULL
38157 };
38158
38159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
38160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38161 if (!SWIG_IsOK(res1)) {
38162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
38163 }
38164 arg1 = reinterpret_cast< wxWindow * >(argp1);
38165 {
38166 arg2 = &temp2;
38167 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38168 }
38169 {
38170 PyThreadState* __tstate = wxPyBeginAllowThreads();
38171 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
38172 wxPyEndAllowThreads(__tstate);
38173 if (PyErr_Occurred()) SWIG_fail;
38174 }
38175 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
38176 return resultobj;
38177 fail:
38178 return NULL;
38179 }
38180
38181
38182 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38183 PyObject *resultobj = 0;
38184 wxWindow *arg1 = (wxWindow *) 0 ;
38185 wxPoint *arg2 = 0 ;
38186 wxPoint result;
38187 void *argp1 = 0 ;
38188 int res1 = 0 ;
38189 wxPoint temp2 ;
38190 PyObject * obj0 = 0 ;
38191 PyObject * obj1 = 0 ;
38192 char * kwnames[] = {
38193 (char *) "self",(char *) "pt", NULL
38194 };
38195
38196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
38197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38198 if (!SWIG_IsOK(res1)) {
38199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
38200 }
38201 arg1 = reinterpret_cast< wxWindow * >(argp1);
38202 {
38203 arg2 = &temp2;
38204 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38205 }
38206 {
38207 PyThreadState* __tstate = wxPyBeginAllowThreads();
38208 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
38209 wxPyEndAllowThreads(__tstate);
38210 if (PyErr_Occurred()) SWIG_fail;
38211 }
38212 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
38213 return resultobj;
38214 fail:
38215 return NULL;
38216 }
38217
38218
38219 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38220 PyObject *resultobj = 0;
38221 wxWindow *arg1 = (wxWindow *) 0 ;
38222 wxSize *arg2 = 0 ;
38223 wxSize result;
38224 void *argp1 = 0 ;
38225 int res1 = 0 ;
38226 wxSize temp2 ;
38227 PyObject * obj0 = 0 ;
38228 PyObject * obj1 = 0 ;
38229 char * kwnames[] = {
38230 (char *) "self",(char *) "sz", NULL
38231 };
38232
38233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
38234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38235 if (!SWIG_IsOK(res1)) {
38236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
38237 }
38238 arg1 = reinterpret_cast< wxWindow * >(argp1);
38239 {
38240 arg2 = &temp2;
38241 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38242 }
38243 {
38244 PyThreadState* __tstate = wxPyBeginAllowThreads();
38245 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
38246 wxPyEndAllowThreads(__tstate);
38247 if (PyErr_Occurred()) SWIG_fail;
38248 }
38249 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
38250 return resultobj;
38251 fail:
38252 return NULL;
38253 }
38254
38255
38256 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38257 PyObject *resultobj = 0;
38258 wxWindow *arg1 = (wxWindow *) 0 ;
38259 wxPoint *arg2 = 0 ;
38260 wxPoint result;
38261 void *argp1 = 0 ;
38262 int res1 = 0 ;
38263 wxPoint temp2 ;
38264 PyObject * obj0 = 0 ;
38265 PyObject * obj1 = 0 ;
38266 char * kwnames[] = {
38267 (char *) "self",(char *) "pt", NULL
38268 };
38269
38270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
38271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38272 if (!SWIG_IsOK(res1)) {
38273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
38274 }
38275 arg1 = reinterpret_cast< wxWindow * >(argp1);
38276 {
38277 arg2 = &temp2;
38278 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38279 }
38280 {
38281 PyThreadState* __tstate = wxPyBeginAllowThreads();
38282 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
38283 wxPyEndAllowThreads(__tstate);
38284 if (PyErr_Occurred()) SWIG_fail;
38285 }
38286 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
38287 return resultobj;
38288 fail:
38289 return NULL;
38290 }
38291
38292
38293 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38294 PyObject *resultobj = 0;
38295 wxWindow *arg1 = (wxWindow *) 0 ;
38296 wxSize *arg2 = 0 ;
38297 wxSize result;
38298 void *argp1 = 0 ;
38299 int res1 = 0 ;
38300 wxSize temp2 ;
38301 PyObject * obj0 = 0 ;
38302 PyObject * obj1 = 0 ;
38303 char * kwnames[] = {
38304 (char *) "self",(char *) "sz", NULL
38305 };
38306
38307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
38308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38309 if (!SWIG_IsOK(res1)) {
38310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
38311 }
38312 arg1 = reinterpret_cast< wxWindow * >(argp1);
38313 {
38314 arg2 = &temp2;
38315 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38316 }
38317 {
38318 PyThreadState* __tstate = wxPyBeginAllowThreads();
38319 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
38320 wxPyEndAllowThreads(__tstate);
38321 if (PyErr_Occurred()) SWIG_fail;
38322 }
38323 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
38324 return resultobj;
38325 fail:
38326 return NULL;
38327 }
38328
38329
38330 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38331 PyObject *resultobj = 0;
38332 wxWindow *arg1 = (wxWindow *) 0 ;
38333 int arg2 ;
38334 int arg3 ;
38335 void *argp1 = 0 ;
38336 int res1 = 0 ;
38337 int val2 ;
38338 int ecode2 = 0 ;
38339 int val3 ;
38340 int ecode3 = 0 ;
38341 PyObject * obj0 = 0 ;
38342 PyObject * obj1 = 0 ;
38343 PyObject * obj2 = 0 ;
38344 char * kwnames[] = {
38345 (char *) "self",(char *) "x",(char *) "y", NULL
38346 };
38347
38348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38350 if (!SWIG_IsOK(res1)) {
38351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
38352 }
38353 arg1 = reinterpret_cast< wxWindow * >(argp1);
38354 ecode2 = SWIG_AsVal_int(obj1, &val2);
38355 if (!SWIG_IsOK(ecode2)) {
38356 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
38357 }
38358 arg2 = static_cast< int >(val2);
38359 ecode3 = SWIG_AsVal_int(obj2, &val3);
38360 if (!SWIG_IsOK(ecode3)) {
38361 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
38362 }
38363 arg3 = static_cast< int >(val3);
38364 {
38365 PyThreadState* __tstate = wxPyBeginAllowThreads();
38366 (arg1)->WarpPointer(arg2,arg3);
38367 wxPyEndAllowThreads(__tstate);
38368 if (PyErr_Occurred()) SWIG_fail;
38369 }
38370 resultobj = SWIG_Py_Void();
38371 return resultobj;
38372 fail:
38373 return NULL;
38374 }
38375
38376
38377 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38378 PyObject *resultobj = 0;
38379 wxWindow *arg1 = (wxWindow *) 0 ;
38380 void *argp1 = 0 ;
38381 int res1 = 0 ;
38382 PyObject *swig_obj[1] ;
38383
38384 if (!args) SWIG_fail;
38385 swig_obj[0] = args;
38386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38387 if (!SWIG_IsOK(res1)) {
38388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
38389 }
38390 arg1 = reinterpret_cast< wxWindow * >(argp1);
38391 {
38392 PyThreadState* __tstate = wxPyBeginAllowThreads();
38393 (arg1)->CaptureMouse();
38394 wxPyEndAllowThreads(__tstate);
38395 if (PyErr_Occurred()) SWIG_fail;
38396 }
38397 resultobj = SWIG_Py_Void();
38398 return resultobj;
38399 fail:
38400 return NULL;
38401 }
38402
38403
38404 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38405 PyObject *resultobj = 0;
38406 wxWindow *arg1 = (wxWindow *) 0 ;
38407 void *argp1 = 0 ;
38408 int res1 = 0 ;
38409 PyObject *swig_obj[1] ;
38410
38411 if (!args) SWIG_fail;
38412 swig_obj[0] = args;
38413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38414 if (!SWIG_IsOK(res1)) {
38415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
38416 }
38417 arg1 = reinterpret_cast< wxWindow * >(argp1);
38418 {
38419 PyThreadState* __tstate = wxPyBeginAllowThreads();
38420 (arg1)->ReleaseMouse();
38421 wxPyEndAllowThreads(__tstate);
38422 if (PyErr_Occurred()) SWIG_fail;
38423 }
38424 resultobj = SWIG_Py_Void();
38425 return resultobj;
38426 fail:
38427 return NULL;
38428 }
38429
38430
38431 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38432 PyObject *resultobj = 0;
38433 wxWindow *result = 0 ;
38434
38435 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
38436 {
38437 if (!wxPyCheckForApp()) SWIG_fail;
38438 PyThreadState* __tstate = wxPyBeginAllowThreads();
38439 result = (wxWindow *)wxWindow::GetCapture();
38440 wxPyEndAllowThreads(__tstate);
38441 if (PyErr_Occurred()) SWIG_fail;
38442 }
38443 {
38444 resultobj = wxPyMake_wxObject(result, 0);
38445 }
38446 return resultobj;
38447 fail:
38448 return NULL;
38449 }
38450
38451
38452 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38453 PyObject *resultobj = 0;
38454 wxWindow *arg1 = (wxWindow *) 0 ;
38455 bool result;
38456 void *argp1 = 0 ;
38457 int res1 = 0 ;
38458 PyObject *swig_obj[1] ;
38459
38460 if (!args) SWIG_fail;
38461 swig_obj[0] = args;
38462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38463 if (!SWIG_IsOK(res1)) {
38464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
38465 }
38466 arg1 = reinterpret_cast< wxWindow * >(argp1);
38467 {
38468 PyThreadState* __tstate = wxPyBeginAllowThreads();
38469 result = (bool)((wxWindow const *)arg1)->HasCapture();
38470 wxPyEndAllowThreads(__tstate);
38471 if (PyErr_Occurred()) SWIG_fail;
38472 }
38473 {
38474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38475 }
38476 return resultobj;
38477 fail:
38478 return NULL;
38479 }
38480
38481
38482 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38483 PyObject *resultobj = 0;
38484 wxWindow *arg1 = (wxWindow *) 0 ;
38485 bool arg2 = (bool) true ;
38486 wxRect *arg3 = (wxRect *) NULL ;
38487 void *argp1 = 0 ;
38488 int res1 = 0 ;
38489 bool val2 ;
38490 int ecode2 = 0 ;
38491 void *argp3 = 0 ;
38492 int res3 = 0 ;
38493 PyObject * obj0 = 0 ;
38494 PyObject * obj1 = 0 ;
38495 PyObject * obj2 = 0 ;
38496 char * kwnames[] = {
38497 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
38498 };
38499
38500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38502 if (!SWIG_IsOK(res1)) {
38503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
38504 }
38505 arg1 = reinterpret_cast< wxWindow * >(argp1);
38506 if (obj1) {
38507 ecode2 = SWIG_AsVal_bool(obj1, &val2);
38508 if (!SWIG_IsOK(ecode2)) {
38509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
38510 }
38511 arg2 = static_cast< bool >(val2);
38512 }
38513 if (obj2) {
38514 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
38515 if (!SWIG_IsOK(res3)) {
38516 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
38517 }
38518 arg3 = reinterpret_cast< wxRect * >(argp3);
38519 }
38520 {
38521 PyThreadState* __tstate = wxPyBeginAllowThreads();
38522 (arg1)->Refresh(arg2,(wxRect const *)arg3);
38523 wxPyEndAllowThreads(__tstate);
38524 if (PyErr_Occurred()) SWIG_fail;
38525 }
38526 resultobj = SWIG_Py_Void();
38527 return resultobj;
38528 fail:
38529 return NULL;
38530 }
38531
38532
38533 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38534 PyObject *resultobj = 0;
38535 wxWindow *arg1 = (wxWindow *) 0 ;
38536 wxRect *arg2 = 0 ;
38537 bool arg3 = (bool) true ;
38538 void *argp1 = 0 ;
38539 int res1 = 0 ;
38540 wxRect temp2 ;
38541 bool val3 ;
38542 int ecode3 = 0 ;
38543 PyObject * obj0 = 0 ;
38544 PyObject * obj1 = 0 ;
38545 PyObject * obj2 = 0 ;
38546 char * kwnames[] = {
38547 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
38548 };
38549
38550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38552 if (!SWIG_IsOK(res1)) {
38553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
38554 }
38555 arg1 = reinterpret_cast< wxWindow * >(argp1);
38556 {
38557 arg2 = &temp2;
38558 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38559 }
38560 if (obj2) {
38561 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38562 if (!SWIG_IsOK(ecode3)) {
38563 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
38564 }
38565 arg3 = static_cast< bool >(val3);
38566 }
38567 {
38568 PyThreadState* __tstate = wxPyBeginAllowThreads();
38569 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
38570 wxPyEndAllowThreads(__tstate);
38571 if (PyErr_Occurred()) SWIG_fail;
38572 }
38573 resultobj = SWIG_Py_Void();
38574 return resultobj;
38575 fail:
38576 return NULL;
38577 }
38578
38579
38580 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38581 PyObject *resultobj = 0;
38582 wxWindow *arg1 = (wxWindow *) 0 ;
38583 void *argp1 = 0 ;
38584 int res1 = 0 ;
38585 PyObject *swig_obj[1] ;
38586
38587 if (!args) SWIG_fail;
38588 swig_obj[0] = args;
38589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38590 if (!SWIG_IsOK(res1)) {
38591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
38592 }
38593 arg1 = reinterpret_cast< wxWindow * >(argp1);
38594 {
38595 PyThreadState* __tstate = wxPyBeginAllowThreads();
38596 (arg1)->Update();
38597 wxPyEndAllowThreads(__tstate);
38598 if (PyErr_Occurred()) SWIG_fail;
38599 }
38600 resultobj = SWIG_Py_Void();
38601 return resultobj;
38602 fail:
38603 return NULL;
38604 }
38605
38606
38607 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38608 PyObject *resultobj = 0;
38609 wxWindow *arg1 = (wxWindow *) 0 ;
38610 void *argp1 = 0 ;
38611 int res1 = 0 ;
38612 PyObject *swig_obj[1] ;
38613
38614 if (!args) SWIG_fail;
38615 swig_obj[0] = args;
38616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38617 if (!SWIG_IsOK(res1)) {
38618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
38619 }
38620 arg1 = reinterpret_cast< wxWindow * >(argp1);
38621 {
38622 PyThreadState* __tstate = wxPyBeginAllowThreads();
38623 (arg1)->ClearBackground();
38624 wxPyEndAllowThreads(__tstate);
38625 if (PyErr_Occurred()) SWIG_fail;
38626 }
38627 resultobj = SWIG_Py_Void();
38628 return resultobj;
38629 fail:
38630 return NULL;
38631 }
38632
38633
38634 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38635 PyObject *resultobj = 0;
38636 wxWindow *arg1 = (wxWindow *) 0 ;
38637 void *argp1 = 0 ;
38638 int res1 = 0 ;
38639 PyObject *swig_obj[1] ;
38640
38641 if (!args) SWIG_fail;
38642 swig_obj[0] = args;
38643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38644 if (!SWIG_IsOK(res1)) {
38645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
38646 }
38647 arg1 = reinterpret_cast< wxWindow * >(argp1);
38648 {
38649 PyThreadState* __tstate = wxPyBeginAllowThreads();
38650 (arg1)->Freeze();
38651 wxPyEndAllowThreads(__tstate);
38652 if (PyErr_Occurred()) SWIG_fail;
38653 }
38654 resultobj = SWIG_Py_Void();
38655 return resultobj;
38656 fail:
38657 return NULL;
38658 }
38659
38660
38661 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38662 PyObject *resultobj = 0;
38663 wxWindow *arg1 = (wxWindow *) 0 ;
38664 bool result;
38665 void *argp1 = 0 ;
38666 int res1 = 0 ;
38667 PyObject *swig_obj[1] ;
38668
38669 if (!args) SWIG_fail;
38670 swig_obj[0] = args;
38671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38672 if (!SWIG_IsOK(res1)) {
38673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
38674 }
38675 arg1 = reinterpret_cast< wxWindow * >(argp1);
38676 {
38677 PyThreadState* __tstate = wxPyBeginAllowThreads();
38678 result = (bool)((wxWindow const *)arg1)->IsFrozen();
38679 wxPyEndAllowThreads(__tstate);
38680 if (PyErr_Occurred()) SWIG_fail;
38681 }
38682 {
38683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38684 }
38685 return resultobj;
38686 fail:
38687 return NULL;
38688 }
38689
38690
38691 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38692 PyObject *resultobj = 0;
38693 wxWindow *arg1 = (wxWindow *) 0 ;
38694 void *argp1 = 0 ;
38695 int res1 = 0 ;
38696 PyObject *swig_obj[1] ;
38697
38698 if (!args) SWIG_fail;
38699 swig_obj[0] = args;
38700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38701 if (!SWIG_IsOK(res1)) {
38702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
38703 }
38704 arg1 = reinterpret_cast< wxWindow * >(argp1);
38705 {
38706 PyThreadState* __tstate = wxPyBeginAllowThreads();
38707 (arg1)->Thaw();
38708 wxPyEndAllowThreads(__tstate);
38709 if (PyErr_Occurred()) SWIG_fail;
38710 }
38711 resultobj = SWIG_Py_Void();
38712 return resultobj;
38713 fail:
38714 return NULL;
38715 }
38716
38717
38718 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38719 PyObject *resultobj = 0;
38720 wxWindow *arg1 = (wxWindow *) 0 ;
38721 wxDC *arg2 = 0 ;
38722 void *argp1 = 0 ;
38723 int res1 = 0 ;
38724 void *argp2 = 0 ;
38725 int res2 = 0 ;
38726 PyObject * obj0 = 0 ;
38727 PyObject * obj1 = 0 ;
38728 char * kwnames[] = {
38729 (char *) "self",(char *) "dc", NULL
38730 };
38731
38732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
38733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38734 if (!SWIG_IsOK(res1)) {
38735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
38736 }
38737 arg1 = reinterpret_cast< wxWindow * >(argp1);
38738 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
38739 if (!SWIG_IsOK(res2)) {
38740 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
38741 }
38742 if (!argp2) {
38743 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
38744 }
38745 arg2 = reinterpret_cast< wxDC * >(argp2);
38746 {
38747 PyThreadState* __tstate = wxPyBeginAllowThreads();
38748 (arg1)->PrepareDC(*arg2);
38749 wxPyEndAllowThreads(__tstate);
38750 if (PyErr_Occurred()) SWIG_fail;
38751 }
38752 resultobj = SWIG_Py_Void();
38753 return resultobj;
38754 fail:
38755 return NULL;
38756 }
38757
38758
38759 SWIGINTERN PyObject *_wrap_Window_IsDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38760 PyObject *resultobj = 0;
38761 wxWindow *arg1 = (wxWindow *) 0 ;
38762 bool result;
38763 void *argp1 = 0 ;
38764 int res1 = 0 ;
38765 PyObject *swig_obj[1] ;
38766
38767 if (!args) SWIG_fail;
38768 swig_obj[0] = args;
38769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38770 if (!SWIG_IsOK(res1)) {
38771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow const *""'");
38772 }
38773 arg1 = reinterpret_cast< wxWindow * >(argp1);
38774 {
38775 PyThreadState* __tstate = wxPyBeginAllowThreads();
38776 result = (bool)((wxWindow const *)arg1)->IsDoubleBuffered();
38777 wxPyEndAllowThreads(__tstate);
38778 if (PyErr_Occurred()) SWIG_fail;
38779 }
38780 {
38781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38782 }
38783 return resultobj;
38784 fail:
38785 return NULL;
38786 }
38787
38788
38789 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38790 PyObject *resultobj = 0;
38791 wxWindow *arg1 = (wxWindow *) 0 ;
38792 wxRegion *result = 0 ;
38793 void *argp1 = 0 ;
38794 int res1 = 0 ;
38795 PyObject *swig_obj[1] ;
38796
38797 if (!args) SWIG_fail;
38798 swig_obj[0] = args;
38799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38800 if (!SWIG_IsOK(res1)) {
38801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
38802 }
38803 arg1 = reinterpret_cast< wxWindow * >(argp1);
38804 {
38805 PyThreadState* __tstate = wxPyBeginAllowThreads();
38806 {
38807 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
38808 result = (wxRegion *) &_result_ref;
38809 }
38810 wxPyEndAllowThreads(__tstate);
38811 if (PyErr_Occurred()) SWIG_fail;
38812 }
38813 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
38814 return resultobj;
38815 fail:
38816 return NULL;
38817 }
38818
38819
38820 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38821 PyObject *resultobj = 0;
38822 wxWindow *arg1 = (wxWindow *) 0 ;
38823 wxRect result;
38824 void *argp1 = 0 ;
38825 int res1 = 0 ;
38826 PyObject *swig_obj[1] ;
38827
38828 if (!args) SWIG_fail;
38829 swig_obj[0] = args;
38830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38831 if (!SWIG_IsOK(res1)) {
38832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38833 }
38834 arg1 = reinterpret_cast< wxWindow * >(argp1);
38835 {
38836 PyThreadState* __tstate = wxPyBeginAllowThreads();
38837 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
38838 wxPyEndAllowThreads(__tstate);
38839 if (PyErr_Occurred()) SWIG_fail;
38840 }
38841 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
38842 return resultobj;
38843 fail:
38844 return NULL;
38845 }
38846
38847
38848 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38849 PyObject *resultobj = 0;
38850 wxWindow *arg1 = (wxWindow *) 0 ;
38851 int arg2 ;
38852 int arg3 ;
38853 int arg4 = (int) 1 ;
38854 int arg5 = (int) 1 ;
38855 bool result;
38856 void *argp1 = 0 ;
38857 int res1 = 0 ;
38858 int val2 ;
38859 int ecode2 = 0 ;
38860 int val3 ;
38861 int ecode3 = 0 ;
38862 int val4 ;
38863 int ecode4 = 0 ;
38864 int val5 ;
38865 int ecode5 = 0 ;
38866 PyObject * obj0 = 0 ;
38867 PyObject * obj1 = 0 ;
38868 PyObject * obj2 = 0 ;
38869 PyObject * obj3 = 0 ;
38870 PyObject * obj4 = 0 ;
38871 char * kwnames[] = {
38872 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
38873 };
38874
38875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38877 if (!SWIG_IsOK(res1)) {
38878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
38879 }
38880 arg1 = reinterpret_cast< wxWindow * >(argp1);
38881 ecode2 = SWIG_AsVal_int(obj1, &val2);
38882 if (!SWIG_IsOK(ecode2)) {
38883 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
38884 }
38885 arg2 = static_cast< int >(val2);
38886 ecode3 = SWIG_AsVal_int(obj2, &val3);
38887 if (!SWIG_IsOK(ecode3)) {
38888 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
38889 }
38890 arg3 = static_cast< int >(val3);
38891 if (obj3) {
38892 ecode4 = SWIG_AsVal_int(obj3, &val4);
38893 if (!SWIG_IsOK(ecode4)) {
38894 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
38895 }
38896 arg4 = static_cast< int >(val4);
38897 }
38898 if (obj4) {
38899 ecode5 = SWIG_AsVal_int(obj4, &val5);
38900 if (!SWIG_IsOK(ecode5)) {
38901 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
38902 }
38903 arg5 = static_cast< int >(val5);
38904 }
38905 {
38906 PyThreadState* __tstate = wxPyBeginAllowThreads();
38907 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
38908 wxPyEndAllowThreads(__tstate);
38909 if (PyErr_Occurred()) SWIG_fail;
38910 }
38911 {
38912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38913 }
38914 return resultobj;
38915 fail:
38916 return NULL;
38917 }
38918
38919
38920 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38921 PyObject *resultobj = 0;
38922 wxWindow *arg1 = (wxWindow *) 0 ;
38923 wxPoint *arg2 = 0 ;
38924 bool result;
38925 void *argp1 = 0 ;
38926 int res1 = 0 ;
38927 wxPoint temp2 ;
38928 PyObject * obj0 = 0 ;
38929 PyObject * obj1 = 0 ;
38930 char * kwnames[] = {
38931 (char *) "self",(char *) "pt", NULL
38932 };
38933
38934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
38935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38936 if (!SWIG_IsOK(res1)) {
38937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
38938 }
38939 arg1 = reinterpret_cast< wxWindow * >(argp1);
38940 {
38941 arg2 = &temp2;
38942 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38943 }
38944 {
38945 PyThreadState* __tstate = wxPyBeginAllowThreads();
38946 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
38947 wxPyEndAllowThreads(__tstate);
38948 if (PyErr_Occurred()) SWIG_fail;
38949 }
38950 {
38951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38952 }
38953 return resultobj;
38954 fail:
38955 return NULL;
38956 }
38957
38958
38959 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38960 PyObject *resultobj = 0;
38961 wxWindow *arg1 = (wxWindow *) 0 ;
38962 wxRect *arg2 = 0 ;
38963 bool result;
38964 void *argp1 = 0 ;
38965 int res1 = 0 ;
38966 wxRect temp2 ;
38967 PyObject * obj0 = 0 ;
38968 PyObject * obj1 = 0 ;
38969 char * kwnames[] = {
38970 (char *) "self",(char *) "rect", NULL
38971 };
38972
38973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
38974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38975 if (!SWIG_IsOK(res1)) {
38976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38977 }
38978 arg1 = reinterpret_cast< wxWindow * >(argp1);
38979 {
38980 arg2 = &temp2;
38981 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38982 }
38983 {
38984 PyThreadState* __tstate = wxPyBeginAllowThreads();
38985 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
38986 wxPyEndAllowThreads(__tstate);
38987 if (PyErr_Occurred()) SWIG_fail;
38988 }
38989 {
38990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38991 }
38992 return resultobj;
38993 fail:
38994 return NULL;
38995 }
38996
38997
38998 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38999 PyObject *resultobj = 0;
39000 wxWindow *arg1 = (wxWindow *) 0 ;
39001 SwigValueWrapper<wxVisualAttributes > result;
39002 void *argp1 = 0 ;
39003 int res1 = 0 ;
39004 PyObject *swig_obj[1] ;
39005
39006 if (!args) SWIG_fail;
39007 swig_obj[0] = args;
39008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39009 if (!SWIG_IsOK(res1)) {
39010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
39011 }
39012 arg1 = reinterpret_cast< wxWindow * >(argp1);
39013 {
39014 PyThreadState* __tstate = wxPyBeginAllowThreads();
39015 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
39016 wxPyEndAllowThreads(__tstate);
39017 if (PyErr_Occurred()) SWIG_fail;
39018 }
39019 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
39020 return resultobj;
39021 fail:
39022 return NULL;
39023 }
39024
39025
39026 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39027 PyObject *resultobj = 0;
39028 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
39029 SwigValueWrapper<wxVisualAttributes > result;
39030 int val1 ;
39031 int ecode1 = 0 ;
39032 PyObject * obj0 = 0 ;
39033 char * kwnames[] = {
39034 (char *) "variant", NULL
39035 };
39036
39037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
39038 if (obj0) {
39039 ecode1 = SWIG_AsVal_int(obj0, &val1);
39040 if (!SWIG_IsOK(ecode1)) {
39041 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
39042 }
39043 arg1 = static_cast< wxWindowVariant >(val1);
39044 }
39045 {
39046 if (!wxPyCheckForApp()) SWIG_fail;
39047 PyThreadState* __tstate = wxPyBeginAllowThreads();
39048 result = wxWindow::GetClassDefaultAttributes(arg1);
39049 wxPyEndAllowThreads(__tstate);
39050 if (PyErr_Occurred()) SWIG_fail;
39051 }
39052 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
39053 return resultobj;
39054 fail:
39055 return NULL;
39056 }
39057
39058
39059 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39060 PyObject *resultobj = 0;
39061 wxWindow *arg1 = (wxWindow *) 0 ;
39062 wxColour *arg2 = 0 ;
39063 bool result;
39064 void *argp1 = 0 ;
39065 int res1 = 0 ;
39066 wxColour temp2 ;
39067 PyObject * obj0 = 0 ;
39068 PyObject * obj1 = 0 ;
39069 char * kwnames[] = {
39070 (char *) "self",(char *) "colour", NULL
39071 };
39072
39073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
39074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39075 if (!SWIG_IsOK(res1)) {
39076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
39077 }
39078 arg1 = reinterpret_cast< wxWindow * >(argp1);
39079 {
39080 arg2 = &temp2;
39081 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
39082 }
39083 {
39084 PyThreadState* __tstate = wxPyBeginAllowThreads();
39085 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
39086 wxPyEndAllowThreads(__tstate);
39087 if (PyErr_Occurred()) SWIG_fail;
39088 }
39089 {
39090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39091 }
39092 return resultobj;
39093 fail:
39094 return NULL;
39095 }
39096
39097
39098 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39099 PyObject *resultobj = 0;
39100 wxWindow *arg1 = (wxWindow *) 0 ;
39101 wxColour *arg2 = 0 ;
39102 void *argp1 = 0 ;
39103 int res1 = 0 ;
39104 wxColour temp2 ;
39105 PyObject * obj0 = 0 ;
39106 PyObject * obj1 = 0 ;
39107 char * kwnames[] = {
39108 (char *) "self",(char *) "colour", NULL
39109 };
39110
39111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
39112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39113 if (!SWIG_IsOK(res1)) {
39114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
39115 }
39116 arg1 = reinterpret_cast< wxWindow * >(argp1);
39117 {
39118 arg2 = &temp2;
39119 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
39120 }
39121 {
39122 PyThreadState* __tstate = wxPyBeginAllowThreads();
39123 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
39124 wxPyEndAllowThreads(__tstate);
39125 if (PyErr_Occurred()) SWIG_fail;
39126 }
39127 resultobj = SWIG_Py_Void();
39128 return resultobj;
39129 fail:
39130 return NULL;
39131 }
39132
39133
39134 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39135 PyObject *resultobj = 0;
39136 wxWindow *arg1 = (wxWindow *) 0 ;
39137 wxColour *arg2 = 0 ;
39138 bool result;
39139 void *argp1 = 0 ;
39140 int res1 = 0 ;
39141 wxColour temp2 ;
39142 PyObject * obj0 = 0 ;
39143 PyObject * obj1 = 0 ;
39144 char * kwnames[] = {
39145 (char *) "self",(char *) "colour", NULL
39146 };
39147
39148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
39149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39150 if (!SWIG_IsOK(res1)) {
39151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
39152 }
39153 arg1 = reinterpret_cast< wxWindow * >(argp1);
39154 {
39155 arg2 = &temp2;
39156 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
39157 }
39158 {
39159 PyThreadState* __tstate = wxPyBeginAllowThreads();
39160 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
39161 wxPyEndAllowThreads(__tstate);
39162 if (PyErr_Occurred()) SWIG_fail;
39163 }
39164 {
39165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39166 }
39167 return resultobj;
39168 fail:
39169 return NULL;
39170 }
39171
39172
39173 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39174 PyObject *resultobj = 0;
39175 wxWindow *arg1 = (wxWindow *) 0 ;
39176 wxColour *arg2 = 0 ;
39177 void *argp1 = 0 ;
39178 int res1 = 0 ;
39179 wxColour temp2 ;
39180 PyObject * obj0 = 0 ;
39181 PyObject * obj1 = 0 ;
39182 char * kwnames[] = {
39183 (char *) "self",(char *) "colour", NULL
39184 };
39185
39186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
39187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39188 if (!SWIG_IsOK(res1)) {
39189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
39190 }
39191 arg1 = reinterpret_cast< wxWindow * >(argp1);
39192 {
39193 arg2 = &temp2;
39194 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
39195 }
39196 {
39197 PyThreadState* __tstate = wxPyBeginAllowThreads();
39198 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
39199 wxPyEndAllowThreads(__tstate);
39200 if (PyErr_Occurred()) SWIG_fail;
39201 }
39202 resultobj = SWIG_Py_Void();
39203 return resultobj;
39204 fail:
39205 return NULL;
39206 }
39207
39208
39209 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39210 PyObject *resultobj = 0;
39211 wxWindow *arg1 = (wxWindow *) 0 ;
39212 wxColour result;
39213 void *argp1 = 0 ;
39214 int res1 = 0 ;
39215 PyObject *swig_obj[1] ;
39216
39217 if (!args) SWIG_fail;
39218 swig_obj[0] = args;
39219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39220 if (!SWIG_IsOK(res1)) {
39221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
39222 }
39223 arg1 = reinterpret_cast< wxWindow * >(argp1);
39224 {
39225 PyThreadState* __tstate = wxPyBeginAllowThreads();
39226 result = ((wxWindow const *)arg1)->GetBackgroundColour();
39227 wxPyEndAllowThreads(__tstate);
39228 if (PyErr_Occurred()) SWIG_fail;
39229 }
39230 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
39231 return resultobj;
39232 fail:
39233 return NULL;
39234 }
39235
39236
39237 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39238 PyObject *resultobj = 0;
39239 wxWindow *arg1 = (wxWindow *) 0 ;
39240 wxColour result;
39241 void *argp1 = 0 ;
39242 int res1 = 0 ;
39243 PyObject *swig_obj[1] ;
39244
39245 if (!args) SWIG_fail;
39246 swig_obj[0] = args;
39247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39248 if (!SWIG_IsOK(res1)) {
39249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
39250 }
39251 arg1 = reinterpret_cast< wxWindow * >(argp1);
39252 {
39253 PyThreadState* __tstate = wxPyBeginAllowThreads();
39254 result = ((wxWindow const *)arg1)->GetForegroundColour();
39255 wxPyEndAllowThreads(__tstate);
39256 if (PyErr_Occurred()) SWIG_fail;
39257 }
39258 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
39259 return resultobj;
39260 fail:
39261 return NULL;
39262 }
39263
39264
39265 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39266 PyObject *resultobj = 0;
39267 wxWindow *arg1 = (wxWindow *) 0 ;
39268 bool result;
39269 void *argp1 = 0 ;
39270 int res1 = 0 ;
39271 PyObject *swig_obj[1] ;
39272
39273 if (!args) SWIG_fail;
39274 swig_obj[0] = args;
39275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39276 if (!SWIG_IsOK(res1)) {
39277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
39278 }
39279 arg1 = reinterpret_cast< wxWindow * >(argp1);
39280 {
39281 PyThreadState* __tstate = wxPyBeginAllowThreads();
39282 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
39283 wxPyEndAllowThreads(__tstate);
39284 if (PyErr_Occurred()) SWIG_fail;
39285 }
39286 {
39287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39288 }
39289 return resultobj;
39290 fail:
39291 return NULL;
39292 }
39293
39294
39295 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39296 PyObject *resultobj = 0;
39297 wxWindow *arg1 = (wxWindow *) 0 ;
39298 bool result;
39299 void *argp1 = 0 ;
39300 int res1 = 0 ;
39301 PyObject *swig_obj[1] ;
39302
39303 if (!args) SWIG_fail;
39304 swig_obj[0] = args;
39305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39306 if (!SWIG_IsOK(res1)) {
39307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
39308 }
39309 arg1 = reinterpret_cast< wxWindow * >(argp1);
39310 {
39311 PyThreadState* __tstate = wxPyBeginAllowThreads();
39312 result = (bool)((wxWindow const *)arg1)->UseBgCol();
39313 wxPyEndAllowThreads(__tstate);
39314 if (PyErr_Occurred()) SWIG_fail;
39315 }
39316 {
39317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39318 }
39319 return resultobj;
39320 fail:
39321 return NULL;
39322 }
39323
39324
39325 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39326 PyObject *resultobj = 0;
39327 wxWindow *arg1 = (wxWindow *) 0 ;
39328 wxBackgroundStyle arg2 ;
39329 bool result;
39330 void *argp1 = 0 ;
39331 int res1 = 0 ;
39332 int val2 ;
39333 int ecode2 = 0 ;
39334 PyObject * obj0 = 0 ;
39335 PyObject * obj1 = 0 ;
39336 char * kwnames[] = {
39337 (char *) "self",(char *) "style", NULL
39338 };
39339
39340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
39341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39342 if (!SWIG_IsOK(res1)) {
39343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
39344 }
39345 arg1 = reinterpret_cast< wxWindow * >(argp1);
39346 ecode2 = SWIG_AsVal_int(obj1, &val2);
39347 if (!SWIG_IsOK(ecode2)) {
39348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
39349 }
39350 arg2 = static_cast< wxBackgroundStyle >(val2);
39351 {
39352 PyThreadState* __tstate = wxPyBeginAllowThreads();
39353 result = (bool)(arg1)->SetBackgroundStyle(arg2);
39354 wxPyEndAllowThreads(__tstate);
39355 if (PyErr_Occurred()) SWIG_fail;
39356 }
39357 {
39358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39359 }
39360 return resultobj;
39361 fail:
39362 return NULL;
39363 }
39364
39365
39366 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39367 PyObject *resultobj = 0;
39368 wxWindow *arg1 = (wxWindow *) 0 ;
39369 wxBackgroundStyle result;
39370 void *argp1 = 0 ;
39371 int res1 = 0 ;
39372 PyObject *swig_obj[1] ;
39373
39374 if (!args) SWIG_fail;
39375 swig_obj[0] = args;
39376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39377 if (!SWIG_IsOK(res1)) {
39378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
39379 }
39380 arg1 = reinterpret_cast< wxWindow * >(argp1);
39381 {
39382 PyThreadState* __tstate = wxPyBeginAllowThreads();
39383 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
39384 wxPyEndAllowThreads(__tstate);
39385 if (PyErr_Occurred()) SWIG_fail;
39386 }
39387 resultobj = SWIG_From_int(static_cast< int >(result));
39388 return resultobj;
39389 fail:
39390 return NULL;
39391 }
39392
39393
39394 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39395 PyObject *resultobj = 0;
39396 wxWindow *arg1 = (wxWindow *) 0 ;
39397 bool result;
39398 void *argp1 = 0 ;
39399 int res1 = 0 ;
39400 PyObject *swig_obj[1] ;
39401
39402 if (!args) SWIG_fail;
39403 swig_obj[0] = args;
39404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39405 if (!SWIG_IsOK(res1)) {
39406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
39407 }
39408 arg1 = reinterpret_cast< wxWindow * >(argp1);
39409 {
39410 PyThreadState* __tstate = wxPyBeginAllowThreads();
39411 result = (bool)(arg1)->HasTransparentBackground();
39412 wxPyEndAllowThreads(__tstate);
39413 if (PyErr_Occurred()) SWIG_fail;
39414 }
39415 {
39416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39417 }
39418 return resultobj;
39419 fail:
39420 return NULL;
39421 }
39422
39423
39424 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39425 PyObject *resultobj = 0;
39426 wxWindow *arg1 = (wxWindow *) 0 ;
39427 wxCursor *arg2 = 0 ;
39428 bool result;
39429 void *argp1 = 0 ;
39430 int res1 = 0 ;
39431 void *argp2 = 0 ;
39432 int res2 = 0 ;
39433 PyObject * obj0 = 0 ;
39434 PyObject * obj1 = 0 ;
39435 char * kwnames[] = {
39436 (char *) "self",(char *) "cursor", NULL
39437 };
39438
39439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
39440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39441 if (!SWIG_IsOK(res1)) {
39442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
39443 }
39444 arg1 = reinterpret_cast< wxWindow * >(argp1);
39445 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
39446 if (!SWIG_IsOK(res2)) {
39447 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
39448 }
39449 if (!argp2) {
39450 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
39451 }
39452 arg2 = reinterpret_cast< wxCursor * >(argp2);
39453 {
39454 PyThreadState* __tstate = wxPyBeginAllowThreads();
39455 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
39456 wxPyEndAllowThreads(__tstate);
39457 if (PyErr_Occurred()) SWIG_fail;
39458 }
39459 {
39460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39461 }
39462 return resultobj;
39463 fail:
39464 return NULL;
39465 }
39466
39467
39468 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39469 PyObject *resultobj = 0;
39470 wxWindow *arg1 = (wxWindow *) 0 ;
39471 wxCursor result;
39472 void *argp1 = 0 ;
39473 int res1 = 0 ;
39474 PyObject *swig_obj[1] ;
39475
39476 if (!args) SWIG_fail;
39477 swig_obj[0] = args;
39478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39479 if (!SWIG_IsOK(res1)) {
39480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
39481 }
39482 arg1 = reinterpret_cast< wxWindow * >(argp1);
39483 {
39484 PyThreadState* __tstate = wxPyBeginAllowThreads();
39485 result = (arg1)->GetCursor();
39486 wxPyEndAllowThreads(__tstate);
39487 if (PyErr_Occurred()) SWIG_fail;
39488 }
39489 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
39490 return resultobj;
39491 fail:
39492 return NULL;
39493 }
39494
39495
39496 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39497 PyObject *resultobj = 0;
39498 wxWindow *arg1 = (wxWindow *) 0 ;
39499 wxFont *arg2 = 0 ;
39500 bool result;
39501 void *argp1 = 0 ;
39502 int res1 = 0 ;
39503 void *argp2 = 0 ;
39504 int res2 = 0 ;
39505 PyObject * obj0 = 0 ;
39506 PyObject * obj1 = 0 ;
39507 char * kwnames[] = {
39508 (char *) "self",(char *) "font", NULL
39509 };
39510
39511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
39512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39513 if (!SWIG_IsOK(res1)) {
39514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
39515 }
39516 arg1 = reinterpret_cast< wxWindow * >(argp1);
39517 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
39518 if (!SWIG_IsOK(res2)) {
39519 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
39520 }
39521 if (!argp2) {
39522 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
39523 }
39524 arg2 = reinterpret_cast< wxFont * >(argp2);
39525 {
39526 PyThreadState* __tstate = wxPyBeginAllowThreads();
39527 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
39528 wxPyEndAllowThreads(__tstate);
39529 if (PyErr_Occurred()) SWIG_fail;
39530 }
39531 {
39532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39533 }
39534 return resultobj;
39535 fail:
39536 return NULL;
39537 }
39538
39539
39540 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39541 PyObject *resultobj = 0;
39542 wxWindow *arg1 = (wxWindow *) 0 ;
39543 wxFont *arg2 = 0 ;
39544 void *argp1 = 0 ;
39545 int res1 = 0 ;
39546 void *argp2 = 0 ;
39547 int res2 = 0 ;
39548 PyObject * obj0 = 0 ;
39549 PyObject * obj1 = 0 ;
39550 char * kwnames[] = {
39551 (char *) "self",(char *) "font", NULL
39552 };
39553
39554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
39555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39556 if (!SWIG_IsOK(res1)) {
39557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
39558 }
39559 arg1 = reinterpret_cast< wxWindow * >(argp1);
39560 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
39561 if (!SWIG_IsOK(res2)) {
39562 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
39563 }
39564 if (!argp2) {
39565 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
39566 }
39567 arg2 = reinterpret_cast< wxFont * >(argp2);
39568 {
39569 PyThreadState* __tstate = wxPyBeginAllowThreads();
39570 (arg1)->SetOwnFont((wxFont const &)*arg2);
39571 wxPyEndAllowThreads(__tstate);
39572 if (PyErr_Occurred()) SWIG_fail;
39573 }
39574 resultobj = SWIG_Py_Void();
39575 return resultobj;
39576 fail:
39577 return NULL;
39578 }
39579
39580
39581 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39582 PyObject *resultobj = 0;
39583 wxWindow *arg1 = (wxWindow *) 0 ;
39584 wxFont result;
39585 void *argp1 = 0 ;
39586 int res1 = 0 ;
39587 PyObject *swig_obj[1] ;
39588
39589 if (!args) SWIG_fail;
39590 swig_obj[0] = args;
39591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39592 if (!SWIG_IsOK(res1)) {
39593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
39594 }
39595 arg1 = reinterpret_cast< wxWindow * >(argp1);
39596 {
39597 PyThreadState* __tstate = wxPyBeginAllowThreads();
39598 result = (arg1)->GetFont();
39599 wxPyEndAllowThreads(__tstate);
39600 if (PyErr_Occurred()) SWIG_fail;
39601 }
39602 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
39603 return resultobj;
39604 fail:
39605 return NULL;
39606 }
39607
39608
39609 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39610 PyObject *resultobj = 0;
39611 wxWindow *arg1 = (wxWindow *) 0 ;
39612 wxCaret *arg2 = (wxCaret *) 0 ;
39613 void *argp1 = 0 ;
39614 int res1 = 0 ;
39615 int res2 = 0 ;
39616 PyObject * obj0 = 0 ;
39617 PyObject * obj1 = 0 ;
39618 char * kwnames[] = {
39619 (char *) "self",(char *) "caret", NULL
39620 };
39621
39622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
39623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39624 if (!SWIG_IsOK(res1)) {
39625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
39626 }
39627 arg1 = reinterpret_cast< wxWindow * >(argp1);
39628 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
39629 if (!SWIG_IsOK(res2)) {
39630 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
39631 }
39632 {
39633 PyThreadState* __tstate = wxPyBeginAllowThreads();
39634 (arg1)->SetCaret(arg2);
39635 wxPyEndAllowThreads(__tstate);
39636 if (PyErr_Occurred()) SWIG_fail;
39637 }
39638 resultobj = SWIG_Py_Void();
39639 return resultobj;
39640 fail:
39641 return NULL;
39642 }
39643
39644
39645 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39646 PyObject *resultobj = 0;
39647 wxWindow *arg1 = (wxWindow *) 0 ;
39648 wxCaret *result = 0 ;
39649 void *argp1 = 0 ;
39650 int res1 = 0 ;
39651 PyObject *swig_obj[1] ;
39652
39653 if (!args) SWIG_fail;
39654 swig_obj[0] = args;
39655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39656 if (!SWIG_IsOK(res1)) {
39657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
39658 }
39659 arg1 = reinterpret_cast< wxWindow * >(argp1);
39660 {
39661 PyThreadState* __tstate = wxPyBeginAllowThreads();
39662 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
39663 wxPyEndAllowThreads(__tstate);
39664 if (PyErr_Occurred()) SWIG_fail;
39665 }
39666 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
39667 return resultobj;
39668 fail:
39669 return NULL;
39670 }
39671
39672
39673 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39674 PyObject *resultobj = 0;
39675 wxWindow *arg1 = (wxWindow *) 0 ;
39676 int result;
39677 void *argp1 = 0 ;
39678 int res1 = 0 ;
39679 PyObject *swig_obj[1] ;
39680
39681 if (!args) SWIG_fail;
39682 swig_obj[0] = args;
39683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39684 if (!SWIG_IsOK(res1)) {
39685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
39686 }
39687 arg1 = reinterpret_cast< wxWindow * >(argp1);
39688 {
39689 PyThreadState* __tstate = wxPyBeginAllowThreads();
39690 result = (int)((wxWindow const *)arg1)->GetCharHeight();
39691 wxPyEndAllowThreads(__tstate);
39692 if (PyErr_Occurred()) SWIG_fail;
39693 }
39694 resultobj = SWIG_From_int(static_cast< int >(result));
39695 return resultobj;
39696 fail:
39697 return NULL;
39698 }
39699
39700
39701 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39702 PyObject *resultobj = 0;
39703 wxWindow *arg1 = (wxWindow *) 0 ;
39704 int result;
39705 void *argp1 = 0 ;
39706 int res1 = 0 ;
39707 PyObject *swig_obj[1] ;
39708
39709 if (!args) SWIG_fail;
39710 swig_obj[0] = args;
39711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39712 if (!SWIG_IsOK(res1)) {
39713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
39714 }
39715 arg1 = reinterpret_cast< wxWindow * >(argp1);
39716 {
39717 PyThreadState* __tstate = wxPyBeginAllowThreads();
39718 result = (int)((wxWindow const *)arg1)->GetCharWidth();
39719 wxPyEndAllowThreads(__tstate);
39720 if (PyErr_Occurred()) SWIG_fail;
39721 }
39722 resultobj = SWIG_From_int(static_cast< int >(result));
39723 return resultobj;
39724 fail:
39725 return NULL;
39726 }
39727
39728
39729 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39730 PyObject *resultobj = 0;
39731 wxWindow *arg1 = (wxWindow *) 0 ;
39732 wxString *arg2 = 0 ;
39733 int *arg3 = (int *) 0 ;
39734 int *arg4 = (int *) 0 ;
39735 void *argp1 = 0 ;
39736 int res1 = 0 ;
39737 bool temp2 = false ;
39738 int temp3 ;
39739 int res3 = SWIG_TMPOBJ ;
39740 int temp4 ;
39741 int res4 = SWIG_TMPOBJ ;
39742 PyObject * obj0 = 0 ;
39743 PyObject * obj1 = 0 ;
39744 char * kwnames[] = {
39745 (char *) "self",(char *) "string", NULL
39746 };
39747
39748 arg3 = &temp3;
39749 arg4 = &temp4;
39750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
39751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39752 if (!SWIG_IsOK(res1)) {
39753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
39754 }
39755 arg1 = reinterpret_cast< wxWindow * >(argp1);
39756 {
39757 arg2 = wxString_in_helper(obj1);
39758 if (arg2 == NULL) SWIG_fail;
39759 temp2 = true;
39760 }
39761 {
39762 PyThreadState* __tstate = wxPyBeginAllowThreads();
39763 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
39764 wxPyEndAllowThreads(__tstate);
39765 if (PyErr_Occurred()) SWIG_fail;
39766 }
39767 resultobj = SWIG_Py_Void();
39768 if (SWIG_IsTmpObj(res3)) {
39769 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39770 } else {
39771 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39772 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39773 }
39774 if (SWIG_IsTmpObj(res4)) {
39775 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
39776 } else {
39777 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39778 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
39779 }
39780 {
39781 if (temp2)
39782 delete arg2;
39783 }
39784 return resultobj;
39785 fail:
39786 {
39787 if (temp2)
39788 delete arg2;
39789 }
39790 return NULL;
39791 }
39792
39793
39794 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39795 PyObject *resultobj = 0;
39796 wxWindow *arg1 = (wxWindow *) 0 ;
39797 wxString *arg2 = 0 ;
39798 int *arg3 = (int *) 0 ;
39799 int *arg4 = (int *) 0 ;
39800 int *arg5 = (int *) 0 ;
39801 int *arg6 = (int *) 0 ;
39802 wxFont *arg7 = (wxFont *) NULL ;
39803 void *argp1 = 0 ;
39804 int res1 = 0 ;
39805 bool temp2 = false ;
39806 int temp3 ;
39807 int res3 = SWIG_TMPOBJ ;
39808 int temp4 ;
39809 int res4 = SWIG_TMPOBJ ;
39810 int temp5 ;
39811 int res5 = SWIG_TMPOBJ ;
39812 int temp6 ;
39813 int res6 = SWIG_TMPOBJ ;
39814 void *argp7 = 0 ;
39815 int res7 = 0 ;
39816 PyObject * obj0 = 0 ;
39817 PyObject * obj1 = 0 ;
39818 PyObject * obj2 = 0 ;
39819 char * kwnames[] = {
39820 (char *) "self",(char *) "string",(char *) "font", NULL
39821 };
39822
39823 arg3 = &temp3;
39824 arg4 = &temp4;
39825 arg5 = &temp5;
39826 arg6 = &temp6;
39827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39829 if (!SWIG_IsOK(res1)) {
39830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
39831 }
39832 arg1 = reinterpret_cast< wxWindow * >(argp1);
39833 {
39834 arg2 = wxString_in_helper(obj1);
39835 if (arg2 == NULL) SWIG_fail;
39836 temp2 = true;
39837 }
39838 if (obj2) {
39839 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
39840 if (!SWIG_IsOK(res7)) {
39841 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
39842 }
39843 arg7 = reinterpret_cast< wxFont * >(argp7);
39844 }
39845 {
39846 PyThreadState* __tstate = wxPyBeginAllowThreads();
39847 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
39848 wxPyEndAllowThreads(__tstate);
39849 if (PyErr_Occurred()) SWIG_fail;
39850 }
39851 resultobj = SWIG_Py_Void();
39852 if (SWIG_IsTmpObj(res3)) {
39853 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39854 } else {
39855 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39856 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39857 }
39858 if (SWIG_IsTmpObj(res4)) {
39859 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
39860 } else {
39861 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39862 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
39863 }
39864 if (SWIG_IsTmpObj(res5)) {
39865 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
39866 } else {
39867 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39868 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
39869 }
39870 if (SWIG_IsTmpObj(res6)) {
39871 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
39872 } else {
39873 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39874 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
39875 }
39876 {
39877 if (temp2)
39878 delete arg2;
39879 }
39880 return resultobj;
39881 fail:
39882 {
39883 if (temp2)
39884 delete arg2;
39885 }
39886 return NULL;
39887 }
39888
39889
39890 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39891 PyObject *resultobj = 0;
39892 wxWindow *arg1 = (wxWindow *) 0 ;
39893 int *arg2 = (int *) 0 ;
39894 int *arg3 = (int *) 0 ;
39895 void *argp1 = 0 ;
39896 int res1 = 0 ;
39897 int temp2 ;
39898 int res2 = 0 ;
39899 int temp3 ;
39900 int res3 = 0 ;
39901 PyObject * obj0 = 0 ;
39902 PyObject * obj1 = 0 ;
39903 PyObject * obj2 = 0 ;
39904 char * kwnames[] = {
39905 (char *) "self",(char *) "x",(char *) "y", NULL
39906 };
39907
39908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39910 if (!SWIG_IsOK(res1)) {
39911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39912 }
39913 arg1 = reinterpret_cast< wxWindow * >(argp1);
39914 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39915 int val;
39916 int ecode = SWIG_AsVal_int(obj1, &val);
39917 if (!SWIG_IsOK(ecode)) {
39918 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
39919 }
39920 temp2 = static_cast< int >(val);
39921 arg2 = &temp2;
39922 res2 = SWIG_AddTmpMask(ecode);
39923 }
39924 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39925 int val;
39926 int ecode = SWIG_AsVal_int(obj2, &val);
39927 if (!SWIG_IsOK(ecode)) {
39928 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
39929 }
39930 temp3 = static_cast< int >(val);
39931 arg3 = &temp3;
39932 res3 = SWIG_AddTmpMask(ecode);
39933 }
39934 {
39935 PyThreadState* __tstate = wxPyBeginAllowThreads();
39936 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
39937 wxPyEndAllowThreads(__tstate);
39938 if (PyErr_Occurred()) SWIG_fail;
39939 }
39940 resultobj = SWIG_Py_Void();
39941 if (SWIG_IsTmpObj(res2)) {
39942 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39943 } else {
39944 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39945 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39946 }
39947 if (SWIG_IsTmpObj(res3)) {
39948 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39949 } else {
39950 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39951 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39952 }
39953 return resultobj;
39954 fail:
39955 return NULL;
39956 }
39957
39958
39959 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39960 PyObject *resultobj = 0;
39961 wxWindow *arg1 = (wxWindow *) 0 ;
39962 int *arg2 = (int *) 0 ;
39963 int *arg3 = (int *) 0 ;
39964 void *argp1 = 0 ;
39965 int res1 = 0 ;
39966 int temp2 ;
39967 int res2 = 0 ;
39968 int temp3 ;
39969 int res3 = 0 ;
39970 PyObject * obj0 = 0 ;
39971 PyObject * obj1 = 0 ;
39972 PyObject * obj2 = 0 ;
39973 char * kwnames[] = {
39974 (char *) "self",(char *) "x",(char *) "y", NULL
39975 };
39976
39977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39979 if (!SWIG_IsOK(res1)) {
39980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39981 }
39982 arg1 = reinterpret_cast< wxWindow * >(argp1);
39983 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39984 int val;
39985 int ecode = SWIG_AsVal_int(obj1, &val);
39986 if (!SWIG_IsOK(ecode)) {
39987 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
39988 }
39989 temp2 = static_cast< int >(val);
39990 arg2 = &temp2;
39991 res2 = SWIG_AddTmpMask(ecode);
39992 }
39993 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39994 int val;
39995 int ecode = SWIG_AsVal_int(obj2, &val);
39996 if (!SWIG_IsOK(ecode)) {
39997 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
39998 }
39999 temp3 = static_cast< int >(val);
40000 arg3 = &temp3;
40001 res3 = SWIG_AddTmpMask(ecode);
40002 }
40003 {
40004 PyThreadState* __tstate = wxPyBeginAllowThreads();
40005 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
40006 wxPyEndAllowThreads(__tstate);
40007 if (PyErr_Occurred()) SWIG_fail;
40008 }
40009 resultobj = SWIG_Py_Void();
40010 if (SWIG_IsTmpObj(res2)) {
40011 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
40012 } else {
40013 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
40014 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
40015 }
40016 if (SWIG_IsTmpObj(res3)) {
40017 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
40018 } else {
40019 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
40020 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
40021 }
40022 return resultobj;
40023 fail:
40024 return NULL;
40025 }
40026
40027
40028 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40029 PyObject *resultobj = 0;
40030 wxWindow *arg1 = (wxWindow *) 0 ;
40031 wxPoint *arg2 = 0 ;
40032 wxPoint result;
40033 void *argp1 = 0 ;
40034 int res1 = 0 ;
40035 wxPoint temp2 ;
40036 PyObject * obj0 = 0 ;
40037 PyObject * obj1 = 0 ;
40038 char * kwnames[] = {
40039 (char *) "self",(char *) "pt", NULL
40040 };
40041
40042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
40043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40044 if (!SWIG_IsOK(res1)) {
40045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
40046 }
40047 arg1 = reinterpret_cast< wxWindow * >(argp1);
40048 {
40049 arg2 = &temp2;
40050 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40051 }
40052 {
40053 PyThreadState* __tstate = wxPyBeginAllowThreads();
40054 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
40055 wxPyEndAllowThreads(__tstate);
40056 if (PyErr_Occurred()) SWIG_fail;
40057 }
40058 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
40059 return resultobj;
40060 fail:
40061 return NULL;
40062 }
40063
40064
40065 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40066 PyObject *resultobj = 0;
40067 wxWindow *arg1 = (wxWindow *) 0 ;
40068 wxPoint *arg2 = 0 ;
40069 wxPoint result;
40070 void *argp1 = 0 ;
40071 int res1 = 0 ;
40072 wxPoint temp2 ;
40073 PyObject * obj0 = 0 ;
40074 PyObject * obj1 = 0 ;
40075 char * kwnames[] = {
40076 (char *) "self",(char *) "pt", NULL
40077 };
40078
40079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
40080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40081 if (!SWIG_IsOK(res1)) {
40082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
40083 }
40084 arg1 = reinterpret_cast< wxWindow * >(argp1);
40085 {
40086 arg2 = &temp2;
40087 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40088 }
40089 {
40090 PyThreadState* __tstate = wxPyBeginAllowThreads();
40091 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
40092 wxPyEndAllowThreads(__tstate);
40093 if (PyErr_Occurred()) SWIG_fail;
40094 }
40095 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
40096 return resultobj;
40097 fail:
40098 return NULL;
40099 }
40100
40101
40102 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40103 PyObject *resultobj = 0;
40104 wxWindow *arg1 = (wxWindow *) 0 ;
40105 int arg2 ;
40106 int arg3 ;
40107 wxHitTest result;
40108 void *argp1 = 0 ;
40109 int res1 = 0 ;
40110 int val2 ;
40111 int ecode2 = 0 ;
40112 int val3 ;
40113 int ecode3 = 0 ;
40114 PyObject * obj0 = 0 ;
40115 PyObject * obj1 = 0 ;
40116 PyObject * obj2 = 0 ;
40117 char * kwnames[] = {
40118 (char *) "self",(char *) "x",(char *) "y", NULL
40119 };
40120
40121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40123 if (!SWIG_IsOK(res1)) {
40124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
40125 }
40126 arg1 = reinterpret_cast< wxWindow * >(argp1);
40127 ecode2 = SWIG_AsVal_int(obj1, &val2);
40128 if (!SWIG_IsOK(ecode2)) {
40129 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
40130 }
40131 arg2 = static_cast< int >(val2);
40132 ecode3 = SWIG_AsVal_int(obj2, &val3);
40133 if (!SWIG_IsOK(ecode3)) {
40134 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
40135 }
40136 arg3 = static_cast< int >(val3);
40137 {
40138 PyThreadState* __tstate = wxPyBeginAllowThreads();
40139 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
40140 wxPyEndAllowThreads(__tstate);
40141 if (PyErr_Occurred()) SWIG_fail;
40142 }
40143 resultobj = SWIG_From_int(static_cast< int >(result));
40144 return resultobj;
40145 fail:
40146 return NULL;
40147 }
40148
40149
40150 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40151 PyObject *resultobj = 0;
40152 wxWindow *arg1 = (wxWindow *) 0 ;
40153 wxPoint *arg2 = 0 ;
40154 wxHitTest result;
40155 void *argp1 = 0 ;
40156 int res1 = 0 ;
40157 wxPoint temp2 ;
40158 PyObject * obj0 = 0 ;
40159 PyObject * obj1 = 0 ;
40160 char * kwnames[] = {
40161 (char *) "self",(char *) "pt", NULL
40162 };
40163
40164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
40165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40166 if (!SWIG_IsOK(res1)) {
40167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
40168 }
40169 arg1 = reinterpret_cast< wxWindow * >(argp1);
40170 {
40171 arg2 = &temp2;
40172 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40173 }
40174 {
40175 PyThreadState* __tstate = wxPyBeginAllowThreads();
40176 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
40177 wxPyEndAllowThreads(__tstate);
40178 if (PyErr_Occurred()) SWIG_fail;
40179 }
40180 resultobj = SWIG_From_int(static_cast< int >(result));
40181 return resultobj;
40182 fail:
40183 return NULL;
40184 }
40185
40186
40187 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
40188 PyObject *resultobj = 0;
40189 wxWindow *arg1 = (wxWindow *) 0 ;
40190 long arg2 ;
40191 wxBorder result;
40192 void *argp1 = 0 ;
40193 int res1 = 0 ;
40194 long val2 ;
40195 int ecode2 = 0 ;
40196
40197 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
40198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40199 if (!SWIG_IsOK(res1)) {
40200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
40201 }
40202 arg1 = reinterpret_cast< wxWindow * >(argp1);
40203 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
40204 if (!SWIG_IsOK(ecode2)) {
40205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
40206 }
40207 arg2 = static_cast< long >(val2);
40208 {
40209 PyThreadState* __tstate = wxPyBeginAllowThreads();
40210 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
40211 wxPyEndAllowThreads(__tstate);
40212 if (PyErr_Occurred()) SWIG_fail;
40213 }
40214 resultobj = SWIG_From_int(static_cast< int >(result));
40215 return resultobj;
40216 fail:
40217 return NULL;
40218 }
40219
40220
40221 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
40222 PyObject *resultobj = 0;
40223 wxWindow *arg1 = (wxWindow *) 0 ;
40224 wxBorder result;
40225 void *argp1 = 0 ;
40226 int res1 = 0 ;
40227
40228 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
40229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40230 if (!SWIG_IsOK(res1)) {
40231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
40232 }
40233 arg1 = reinterpret_cast< wxWindow * >(argp1);
40234 {
40235 PyThreadState* __tstate = wxPyBeginAllowThreads();
40236 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
40237 wxPyEndAllowThreads(__tstate);
40238 if (PyErr_Occurred()) SWIG_fail;
40239 }
40240 resultobj = SWIG_From_int(static_cast< int >(result));
40241 return resultobj;
40242 fail:
40243 return NULL;
40244 }
40245
40246
40247 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
40248 int argc;
40249 PyObject *argv[3];
40250
40251 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
40252 --argc;
40253 if (argc == 1) {
40254 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
40255 }
40256 if (argc == 2) {
40257 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
40258 }
40259
40260 fail:
40261 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
40262 return NULL;
40263 }
40264
40265
40266 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40267 PyObject *resultobj = 0;
40268 wxWindow *arg1 = (wxWindow *) 0 ;
40269 long arg2 = (long) wxUPDATE_UI_NONE ;
40270 void *argp1 = 0 ;
40271 int res1 = 0 ;
40272 long val2 ;
40273 int ecode2 = 0 ;
40274 PyObject * obj0 = 0 ;
40275 PyObject * obj1 = 0 ;
40276 char * kwnames[] = {
40277 (char *) "self",(char *) "flags", NULL
40278 };
40279
40280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
40281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40282 if (!SWIG_IsOK(res1)) {
40283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
40284 }
40285 arg1 = reinterpret_cast< wxWindow * >(argp1);
40286 if (obj1) {
40287 ecode2 = SWIG_AsVal_long(obj1, &val2);
40288 if (!SWIG_IsOK(ecode2)) {
40289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
40290 }
40291 arg2 = static_cast< long >(val2);
40292 }
40293 {
40294 PyThreadState* __tstate = wxPyBeginAllowThreads();
40295 (arg1)->UpdateWindowUI(arg2);
40296 wxPyEndAllowThreads(__tstate);
40297 if (PyErr_Occurred()) SWIG_fail;
40298 }
40299 resultobj = SWIG_Py_Void();
40300 return resultobj;
40301 fail:
40302 return NULL;
40303 }
40304
40305
40306 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40307 PyObject *resultobj = 0;
40308 wxWindow *arg1 = (wxWindow *) 0 ;
40309 wxMenu *arg2 = (wxMenu *) 0 ;
40310 int arg3 = (int) -1 ;
40311 int arg4 = (int) -1 ;
40312 bool result;
40313 void *argp1 = 0 ;
40314 int res1 = 0 ;
40315 void *argp2 = 0 ;
40316 int res2 = 0 ;
40317 int val3 ;
40318 int ecode3 = 0 ;
40319 int val4 ;
40320 int ecode4 = 0 ;
40321 PyObject * obj0 = 0 ;
40322 PyObject * obj1 = 0 ;
40323 PyObject * obj2 = 0 ;
40324 PyObject * obj3 = 0 ;
40325 char * kwnames[] = {
40326 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
40327 };
40328
40329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40331 if (!SWIG_IsOK(res1)) {
40332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
40333 }
40334 arg1 = reinterpret_cast< wxWindow * >(argp1);
40335 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40336 if (!SWIG_IsOK(res2)) {
40337 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
40338 }
40339 arg2 = reinterpret_cast< wxMenu * >(argp2);
40340 if (obj2) {
40341 ecode3 = SWIG_AsVal_int(obj2, &val3);
40342 if (!SWIG_IsOK(ecode3)) {
40343 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
40344 }
40345 arg3 = static_cast< int >(val3);
40346 }
40347 if (obj3) {
40348 ecode4 = SWIG_AsVal_int(obj3, &val4);
40349 if (!SWIG_IsOK(ecode4)) {
40350 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
40351 }
40352 arg4 = static_cast< int >(val4);
40353 }
40354 {
40355 PyThreadState* __tstate = wxPyBeginAllowThreads();
40356 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
40357 wxPyEndAllowThreads(__tstate);
40358 if (PyErr_Occurred()) SWIG_fail;
40359 }
40360 {
40361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40362 }
40363 return resultobj;
40364 fail:
40365 return NULL;
40366 }
40367
40368
40369 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40370 PyObject *resultobj = 0;
40371 wxWindow *arg1 = (wxWindow *) 0 ;
40372 wxMenu *arg2 = (wxMenu *) 0 ;
40373 wxPoint const &arg3_defvalue = wxDefaultPosition ;
40374 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
40375 bool result;
40376 void *argp1 = 0 ;
40377 int res1 = 0 ;
40378 void *argp2 = 0 ;
40379 int res2 = 0 ;
40380 wxPoint temp3 ;
40381 PyObject * obj0 = 0 ;
40382 PyObject * obj1 = 0 ;
40383 PyObject * obj2 = 0 ;
40384 char * kwnames[] = {
40385 (char *) "self",(char *) "menu",(char *) "pos", NULL
40386 };
40387
40388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40390 if (!SWIG_IsOK(res1)) {
40391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
40392 }
40393 arg1 = reinterpret_cast< wxWindow * >(argp1);
40394 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40395 if (!SWIG_IsOK(res2)) {
40396 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
40397 }
40398 arg2 = reinterpret_cast< wxMenu * >(argp2);
40399 if (obj2) {
40400 {
40401 arg3 = &temp3;
40402 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
40403 }
40404 }
40405 {
40406 PyThreadState* __tstate = wxPyBeginAllowThreads();
40407 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
40408 wxPyEndAllowThreads(__tstate);
40409 if (PyErr_Occurred()) SWIG_fail;
40410 }
40411 {
40412 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40413 }
40414 return resultobj;
40415 fail:
40416 return NULL;
40417 }
40418
40419
40420 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40421 PyObject *resultobj = 0;
40422 wxWindow *arg1 = (wxWindow *) 0 ;
40423 bool result;
40424 void *argp1 = 0 ;
40425 int res1 = 0 ;
40426 PyObject *swig_obj[1] ;
40427
40428 if (!args) SWIG_fail;
40429 swig_obj[0] = args;
40430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40431 if (!SWIG_IsOK(res1)) {
40432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
40433 }
40434 arg1 = reinterpret_cast< wxWindow * >(argp1);
40435 {
40436 PyThreadState* __tstate = wxPyBeginAllowThreads();
40437 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
40438 wxPyEndAllowThreads(__tstate);
40439 if (PyErr_Occurred()) SWIG_fail;
40440 }
40441 {
40442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40443 }
40444 return resultobj;
40445 fail:
40446 return NULL;
40447 }
40448
40449
40450 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40451 PyObject *resultobj = 0;
40452 wxWindow *arg1 = (wxWindow *) 0 ;
40453 long result;
40454 void *argp1 = 0 ;
40455 int res1 = 0 ;
40456 PyObject *swig_obj[1] ;
40457
40458 if (!args) SWIG_fail;
40459 swig_obj[0] = args;
40460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40461 if (!SWIG_IsOK(res1)) {
40462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
40463 }
40464 arg1 = reinterpret_cast< wxWindow * >(argp1);
40465 {
40466 PyThreadState* __tstate = wxPyBeginAllowThreads();
40467 result = (long)wxWindow_GetHandle(arg1);
40468 wxPyEndAllowThreads(__tstate);
40469 if (PyErr_Occurred()) SWIG_fail;
40470 }
40471 resultobj = SWIG_From_long(static_cast< long >(result));
40472 return resultobj;
40473 fail:
40474 return NULL;
40475 }
40476
40477
40478 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40479 PyObject *resultobj = 0;
40480 wxWindow *arg1 = (wxWindow *) 0 ;
40481 long arg2 ;
40482 void *argp1 = 0 ;
40483 int res1 = 0 ;
40484 long val2 ;
40485 int ecode2 = 0 ;
40486 PyObject * obj0 = 0 ;
40487 PyObject * obj1 = 0 ;
40488 char * kwnames[] = {
40489 (char *) "self",(char *) "handle", NULL
40490 };
40491
40492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
40493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40494 if (!SWIG_IsOK(res1)) {
40495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
40496 }
40497 arg1 = reinterpret_cast< wxWindow * >(argp1);
40498 ecode2 = SWIG_AsVal_long(obj1, &val2);
40499 if (!SWIG_IsOK(ecode2)) {
40500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
40501 }
40502 arg2 = static_cast< long >(val2);
40503 {
40504 PyThreadState* __tstate = wxPyBeginAllowThreads();
40505 wxWindow_AssociateHandle(arg1,arg2);
40506 wxPyEndAllowThreads(__tstate);
40507 if (PyErr_Occurred()) SWIG_fail;
40508 }
40509 resultobj = SWIG_Py_Void();
40510 return resultobj;
40511 fail:
40512 return NULL;
40513 }
40514
40515
40516 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40517 PyObject *resultobj = 0;
40518 wxWindow *arg1 = (wxWindow *) 0 ;
40519 void *argp1 = 0 ;
40520 int res1 = 0 ;
40521 PyObject *swig_obj[1] ;
40522
40523 if (!args) SWIG_fail;
40524 swig_obj[0] = args;
40525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40526 if (!SWIG_IsOK(res1)) {
40527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
40528 }
40529 arg1 = reinterpret_cast< wxWindow * >(argp1);
40530 {
40531 PyThreadState* __tstate = wxPyBeginAllowThreads();
40532 (arg1)->DissociateHandle();
40533 wxPyEndAllowThreads(__tstate);
40534 if (PyErr_Occurred()) SWIG_fail;
40535 }
40536 resultobj = SWIG_Py_Void();
40537 return resultobj;
40538 fail:
40539 return NULL;
40540 }
40541
40542
40543 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40544 PyObject *resultobj = 0;
40545 wxWindow *arg1 = (wxWindow *) 0 ;
40546 int arg2 ;
40547 bool result;
40548 void *argp1 = 0 ;
40549 int res1 = 0 ;
40550 int val2 ;
40551 int ecode2 = 0 ;
40552 PyObject * obj0 = 0 ;
40553 PyObject * obj1 = 0 ;
40554 char * kwnames[] = {
40555 (char *) "self",(char *) "orient", NULL
40556 };
40557
40558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
40559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40560 if (!SWIG_IsOK(res1)) {
40561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
40562 }
40563 arg1 = reinterpret_cast< wxWindow * >(argp1);
40564 ecode2 = SWIG_AsVal_int(obj1, &val2);
40565 if (!SWIG_IsOK(ecode2)) {
40566 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
40567 }
40568 arg2 = static_cast< int >(val2);
40569 {
40570 PyThreadState* __tstate = wxPyBeginAllowThreads();
40571 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
40572 wxPyEndAllowThreads(__tstate);
40573 if (PyErr_Occurred()) SWIG_fail;
40574 }
40575 {
40576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40577 }
40578 return resultobj;
40579 fail:
40580 return NULL;
40581 }
40582
40583
40584 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40585 PyObject *resultobj = 0;
40586 wxWindow *arg1 = (wxWindow *) 0 ;
40587 int arg2 ;
40588 int arg3 ;
40589 int arg4 ;
40590 int arg5 ;
40591 bool arg6 = (bool) true ;
40592 void *argp1 = 0 ;
40593 int res1 = 0 ;
40594 int val2 ;
40595 int ecode2 = 0 ;
40596 int val3 ;
40597 int ecode3 = 0 ;
40598 int val4 ;
40599 int ecode4 = 0 ;
40600 int val5 ;
40601 int ecode5 = 0 ;
40602 bool val6 ;
40603 int ecode6 = 0 ;
40604 PyObject * obj0 = 0 ;
40605 PyObject * obj1 = 0 ;
40606 PyObject * obj2 = 0 ;
40607 PyObject * obj3 = 0 ;
40608 PyObject * obj4 = 0 ;
40609 PyObject * obj5 = 0 ;
40610 char * kwnames[] = {
40611 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
40612 };
40613
40614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
40615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40616 if (!SWIG_IsOK(res1)) {
40617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
40618 }
40619 arg1 = reinterpret_cast< wxWindow * >(argp1);
40620 ecode2 = SWIG_AsVal_int(obj1, &val2);
40621 if (!SWIG_IsOK(ecode2)) {
40622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
40623 }
40624 arg2 = static_cast< int >(val2);
40625 ecode3 = SWIG_AsVal_int(obj2, &val3);
40626 if (!SWIG_IsOK(ecode3)) {
40627 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
40628 }
40629 arg3 = static_cast< int >(val3);
40630 ecode4 = SWIG_AsVal_int(obj3, &val4);
40631 if (!SWIG_IsOK(ecode4)) {
40632 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
40633 }
40634 arg4 = static_cast< int >(val4);
40635 ecode5 = SWIG_AsVal_int(obj4, &val5);
40636 if (!SWIG_IsOK(ecode5)) {
40637 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
40638 }
40639 arg5 = static_cast< int >(val5);
40640 if (obj5) {
40641 ecode6 = SWIG_AsVal_bool(obj5, &val6);
40642 if (!SWIG_IsOK(ecode6)) {
40643 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
40644 }
40645 arg6 = static_cast< bool >(val6);
40646 }
40647 {
40648 PyThreadState* __tstate = wxPyBeginAllowThreads();
40649 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
40650 wxPyEndAllowThreads(__tstate);
40651 if (PyErr_Occurred()) SWIG_fail;
40652 }
40653 resultobj = SWIG_Py_Void();
40654 return resultobj;
40655 fail:
40656 return NULL;
40657 }
40658
40659
40660 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40661 PyObject *resultobj = 0;
40662 wxWindow *arg1 = (wxWindow *) 0 ;
40663 int arg2 ;
40664 int arg3 ;
40665 bool arg4 = (bool) true ;
40666 void *argp1 = 0 ;
40667 int res1 = 0 ;
40668 int val2 ;
40669 int ecode2 = 0 ;
40670 int val3 ;
40671 int ecode3 = 0 ;
40672 bool val4 ;
40673 int ecode4 = 0 ;
40674 PyObject * obj0 = 0 ;
40675 PyObject * obj1 = 0 ;
40676 PyObject * obj2 = 0 ;
40677 PyObject * obj3 = 0 ;
40678 char * kwnames[] = {
40679 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
40680 };
40681
40682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40684 if (!SWIG_IsOK(res1)) {
40685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
40686 }
40687 arg1 = reinterpret_cast< wxWindow * >(argp1);
40688 ecode2 = SWIG_AsVal_int(obj1, &val2);
40689 if (!SWIG_IsOK(ecode2)) {
40690 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
40691 }
40692 arg2 = static_cast< int >(val2);
40693 ecode3 = SWIG_AsVal_int(obj2, &val3);
40694 if (!SWIG_IsOK(ecode3)) {
40695 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
40696 }
40697 arg3 = static_cast< int >(val3);
40698 if (obj3) {
40699 ecode4 = SWIG_AsVal_bool(obj3, &val4);
40700 if (!SWIG_IsOK(ecode4)) {
40701 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
40702 }
40703 arg4 = static_cast< bool >(val4);
40704 }
40705 {
40706 PyThreadState* __tstate = wxPyBeginAllowThreads();
40707 (arg1)->SetScrollPos(arg2,arg3,arg4);
40708 wxPyEndAllowThreads(__tstate);
40709 if (PyErr_Occurred()) SWIG_fail;
40710 }
40711 resultobj = SWIG_Py_Void();
40712 return resultobj;
40713 fail:
40714 return NULL;
40715 }
40716
40717
40718 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40719 PyObject *resultobj = 0;
40720 wxWindow *arg1 = (wxWindow *) 0 ;
40721 int arg2 ;
40722 int result;
40723 void *argp1 = 0 ;
40724 int res1 = 0 ;
40725 int val2 ;
40726 int ecode2 = 0 ;
40727 PyObject * obj0 = 0 ;
40728 PyObject * obj1 = 0 ;
40729 char * kwnames[] = {
40730 (char *) "self",(char *) "orientation", NULL
40731 };
40732
40733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
40734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40735 if (!SWIG_IsOK(res1)) {
40736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
40737 }
40738 arg1 = reinterpret_cast< wxWindow * >(argp1);
40739 ecode2 = SWIG_AsVal_int(obj1, &val2);
40740 if (!SWIG_IsOK(ecode2)) {
40741 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
40742 }
40743 arg2 = static_cast< int >(val2);
40744 {
40745 PyThreadState* __tstate = wxPyBeginAllowThreads();
40746 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
40747 wxPyEndAllowThreads(__tstate);
40748 if (PyErr_Occurred()) SWIG_fail;
40749 }
40750 resultobj = SWIG_From_int(static_cast< int >(result));
40751 return resultobj;
40752 fail:
40753 return NULL;
40754 }
40755
40756
40757 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40758 PyObject *resultobj = 0;
40759 wxWindow *arg1 = (wxWindow *) 0 ;
40760 int arg2 ;
40761 int result;
40762 void *argp1 = 0 ;
40763 int res1 = 0 ;
40764 int val2 ;
40765 int ecode2 = 0 ;
40766 PyObject * obj0 = 0 ;
40767 PyObject * obj1 = 0 ;
40768 char * kwnames[] = {
40769 (char *) "self",(char *) "orientation", NULL
40770 };
40771
40772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
40773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40774 if (!SWIG_IsOK(res1)) {
40775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
40776 }
40777 arg1 = reinterpret_cast< wxWindow * >(argp1);
40778 ecode2 = SWIG_AsVal_int(obj1, &val2);
40779 if (!SWIG_IsOK(ecode2)) {
40780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
40781 }
40782 arg2 = static_cast< int >(val2);
40783 {
40784 PyThreadState* __tstate = wxPyBeginAllowThreads();
40785 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
40786 wxPyEndAllowThreads(__tstate);
40787 if (PyErr_Occurred()) SWIG_fail;
40788 }
40789 resultobj = SWIG_From_int(static_cast< int >(result));
40790 return resultobj;
40791 fail:
40792 return NULL;
40793 }
40794
40795
40796 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40797 PyObject *resultobj = 0;
40798 wxWindow *arg1 = (wxWindow *) 0 ;
40799 int arg2 ;
40800 int result;
40801 void *argp1 = 0 ;
40802 int res1 = 0 ;
40803 int val2 ;
40804 int ecode2 = 0 ;
40805 PyObject * obj0 = 0 ;
40806 PyObject * obj1 = 0 ;
40807 char * kwnames[] = {
40808 (char *) "self",(char *) "orientation", NULL
40809 };
40810
40811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
40812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40813 if (!SWIG_IsOK(res1)) {
40814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
40815 }
40816 arg1 = reinterpret_cast< wxWindow * >(argp1);
40817 ecode2 = SWIG_AsVal_int(obj1, &val2);
40818 if (!SWIG_IsOK(ecode2)) {
40819 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
40820 }
40821 arg2 = static_cast< int >(val2);
40822 {
40823 PyThreadState* __tstate = wxPyBeginAllowThreads();
40824 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
40825 wxPyEndAllowThreads(__tstate);
40826 if (PyErr_Occurred()) SWIG_fail;
40827 }
40828 resultobj = SWIG_From_int(static_cast< int >(result));
40829 return resultobj;
40830 fail:
40831 return NULL;
40832 }
40833
40834
40835 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40836 PyObject *resultobj = 0;
40837 wxWindow *arg1 = (wxWindow *) 0 ;
40838 int arg2 ;
40839 int arg3 ;
40840 wxRect *arg4 = (wxRect *) NULL ;
40841 void *argp1 = 0 ;
40842 int res1 = 0 ;
40843 int val2 ;
40844 int ecode2 = 0 ;
40845 int val3 ;
40846 int ecode3 = 0 ;
40847 void *argp4 = 0 ;
40848 int res4 = 0 ;
40849 PyObject * obj0 = 0 ;
40850 PyObject * obj1 = 0 ;
40851 PyObject * obj2 = 0 ;
40852 PyObject * obj3 = 0 ;
40853 char * kwnames[] = {
40854 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
40855 };
40856
40857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40859 if (!SWIG_IsOK(res1)) {
40860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
40861 }
40862 arg1 = reinterpret_cast< wxWindow * >(argp1);
40863 ecode2 = SWIG_AsVal_int(obj1, &val2);
40864 if (!SWIG_IsOK(ecode2)) {
40865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
40866 }
40867 arg2 = static_cast< int >(val2);
40868 ecode3 = SWIG_AsVal_int(obj2, &val3);
40869 if (!SWIG_IsOK(ecode3)) {
40870 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
40871 }
40872 arg3 = static_cast< int >(val3);
40873 if (obj3) {
40874 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
40875 if (!SWIG_IsOK(res4)) {
40876 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
40877 }
40878 arg4 = reinterpret_cast< wxRect * >(argp4);
40879 }
40880 {
40881 PyThreadState* __tstate = wxPyBeginAllowThreads();
40882 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
40883 wxPyEndAllowThreads(__tstate);
40884 if (PyErr_Occurred()) SWIG_fail;
40885 }
40886 resultobj = SWIG_Py_Void();
40887 return resultobj;
40888 fail:
40889 return NULL;
40890 }
40891
40892
40893 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40894 PyObject *resultobj = 0;
40895 wxWindow *arg1 = (wxWindow *) 0 ;
40896 int arg2 ;
40897 bool result;
40898 void *argp1 = 0 ;
40899 int res1 = 0 ;
40900 int val2 ;
40901 int ecode2 = 0 ;
40902 PyObject * obj0 = 0 ;
40903 PyObject * obj1 = 0 ;
40904 char * kwnames[] = {
40905 (char *) "self",(char *) "lines", NULL
40906 };
40907
40908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
40909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40910 if (!SWIG_IsOK(res1)) {
40911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
40912 }
40913 arg1 = reinterpret_cast< wxWindow * >(argp1);
40914 ecode2 = SWIG_AsVal_int(obj1, &val2);
40915 if (!SWIG_IsOK(ecode2)) {
40916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
40917 }
40918 arg2 = static_cast< int >(val2);
40919 {
40920 PyThreadState* __tstate = wxPyBeginAllowThreads();
40921 result = (bool)(arg1)->ScrollLines(arg2);
40922 wxPyEndAllowThreads(__tstate);
40923 if (PyErr_Occurred()) SWIG_fail;
40924 }
40925 {
40926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40927 }
40928 return resultobj;
40929 fail:
40930 return NULL;
40931 }
40932
40933
40934 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40935 PyObject *resultobj = 0;
40936 wxWindow *arg1 = (wxWindow *) 0 ;
40937 int arg2 ;
40938 bool result;
40939 void *argp1 = 0 ;
40940 int res1 = 0 ;
40941 int val2 ;
40942 int ecode2 = 0 ;
40943 PyObject * obj0 = 0 ;
40944 PyObject * obj1 = 0 ;
40945 char * kwnames[] = {
40946 (char *) "self",(char *) "pages", NULL
40947 };
40948
40949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
40950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40951 if (!SWIG_IsOK(res1)) {
40952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
40953 }
40954 arg1 = reinterpret_cast< wxWindow * >(argp1);
40955 ecode2 = SWIG_AsVal_int(obj1, &val2);
40956 if (!SWIG_IsOK(ecode2)) {
40957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
40958 }
40959 arg2 = static_cast< int >(val2);
40960 {
40961 PyThreadState* __tstate = wxPyBeginAllowThreads();
40962 result = (bool)(arg1)->ScrollPages(arg2);
40963 wxPyEndAllowThreads(__tstate);
40964 if (PyErr_Occurred()) SWIG_fail;
40965 }
40966 {
40967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40968 }
40969 return resultobj;
40970 fail:
40971 return NULL;
40972 }
40973
40974
40975 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40976 PyObject *resultobj = 0;
40977 wxWindow *arg1 = (wxWindow *) 0 ;
40978 bool result;
40979 void *argp1 = 0 ;
40980 int res1 = 0 ;
40981 PyObject *swig_obj[1] ;
40982
40983 if (!args) SWIG_fail;
40984 swig_obj[0] = args;
40985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40986 if (!SWIG_IsOK(res1)) {
40987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40988 }
40989 arg1 = reinterpret_cast< wxWindow * >(argp1);
40990 {
40991 PyThreadState* __tstate = wxPyBeginAllowThreads();
40992 result = (bool)(arg1)->LineUp();
40993 wxPyEndAllowThreads(__tstate);
40994 if (PyErr_Occurred()) SWIG_fail;
40995 }
40996 {
40997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40998 }
40999 return resultobj;
41000 fail:
41001 return NULL;
41002 }
41003
41004
41005 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41006 PyObject *resultobj = 0;
41007 wxWindow *arg1 = (wxWindow *) 0 ;
41008 bool result;
41009 void *argp1 = 0 ;
41010 int res1 = 0 ;
41011 PyObject *swig_obj[1] ;
41012
41013 if (!args) SWIG_fail;
41014 swig_obj[0] = args;
41015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41016 if (!SWIG_IsOK(res1)) {
41017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
41018 }
41019 arg1 = reinterpret_cast< wxWindow * >(argp1);
41020 {
41021 PyThreadState* __tstate = wxPyBeginAllowThreads();
41022 result = (bool)(arg1)->LineDown();
41023 wxPyEndAllowThreads(__tstate);
41024 if (PyErr_Occurred()) SWIG_fail;
41025 }
41026 {
41027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41028 }
41029 return resultobj;
41030 fail:
41031 return NULL;
41032 }
41033
41034
41035 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41036 PyObject *resultobj = 0;
41037 wxWindow *arg1 = (wxWindow *) 0 ;
41038 bool result;
41039 void *argp1 = 0 ;
41040 int res1 = 0 ;
41041 PyObject *swig_obj[1] ;
41042
41043 if (!args) SWIG_fail;
41044 swig_obj[0] = args;
41045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41046 if (!SWIG_IsOK(res1)) {
41047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
41048 }
41049 arg1 = reinterpret_cast< wxWindow * >(argp1);
41050 {
41051 PyThreadState* __tstate = wxPyBeginAllowThreads();
41052 result = (bool)(arg1)->PageUp();
41053 wxPyEndAllowThreads(__tstate);
41054 if (PyErr_Occurred()) SWIG_fail;
41055 }
41056 {
41057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41058 }
41059 return resultobj;
41060 fail:
41061 return NULL;
41062 }
41063
41064
41065 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41066 PyObject *resultobj = 0;
41067 wxWindow *arg1 = (wxWindow *) 0 ;
41068 bool result;
41069 void *argp1 = 0 ;
41070 int res1 = 0 ;
41071 PyObject *swig_obj[1] ;
41072
41073 if (!args) SWIG_fail;
41074 swig_obj[0] = args;
41075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41076 if (!SWIG_IsOK(res1)) {
41077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
41078 }
41079 arg1 = reinterpret_cast< wxWindow * >(argp1);
41080 {
41081 PyThreadState* __tstate = wxPyBeginAllowThreads();
41082 result = (bool)(arg1)->PageDown();
41083 wxPyEndAllowThreads(__tstate);
41084 if (PyErr_Occurred()) SWIG_fail;
41085 }
41086 {
41087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41088 }
41089 return resultobj;
41090 fail:
41091 return NULL;
41092 }
41093
41094
41095 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41096 PyObject *resultobj = 0;
41097 wxWindow *arg1 = (wxWindow *) 0 ;
41098 wxString *arg2 = 0 ;
41099 void *argp1 = 0 ;
41100 int res1 = 0 ;
41101 bool temp2 = false ;
41102 PyObject * obj0 = 0 ;
41103 PyObject * obj1 = 0 ;
41104 char * kwnames[] = {
41105 (char *) "self",(char *) "text", NULL
41106 };
41107
41108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
41109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41110 if (!SWIG_IsOK(res1)) {
41111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
41112 }
41113 arg1 = reinterpret_cast< wxWindow * >(argp1);
41114 {
41115 arg2 = wxString_in_helper(obj1);
41116 if (arg2 == NULL) SWIG_fail;
41117 temp2 = true;
41118 }
41119 {
41120 PyThreadState* __tstate = wxPyBeginAllowThreads();
41121 (arg1)->SetHelpText((wxString const &)*arg2);
41122 wxPyEndAllowThreads(__tstate);
41123 if (PyErr_Occurred()) SWIG_fail;
41124 }
41125 resultobj = SWIG_Py_Void();
41126 {
41127 if (temp2)
41128 delete arg2;
41129 }
41130 return resultobj;
41131 fail:
41132 {
41133 if (temp2)
41134 delete arg2;
41135 }
41136 return NULL;
41137 }
41138
41139
41140 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41141 PyObject *resultobj = 0;
41142 wxWindow *arg1 = (wxWindow *) 0 ;
41143 wxString *arg2 = 0 ;
41144 void *argp1 = 0 ;
41145 int res1 = 0 ;
41146 bool temp2 = false ;
41147 PyObject * obj0 = 0 ;
41148 PyObject * obj1 = 0 ;
41149 char * kwnames[] = {
41150 (char *) "self",(char *) "text", NULL
41151 };
41152
41153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
41154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41155 if (!SWIG_IsOK(res1)) {
41156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
41157 }
41158 arg1 = reinterpret_cast< wxWindow * >(argp1);
41159 {
41160 arg2 = wxString_in_helper(obj1);
41161 if (arg2 == NULL) SWIG_fail;
41162 temp2 = true;
41163 }
41164 {
41165 PyThreadState* __tstate = wxPyBeginAllowThreads();
41166 (arg1)->SetHelpTextForId((wxString const &)*arg2);
41167 wxPyEndAllowThreads(__tstate);
41168 if (PyErr_Occurred()) SWIG_fail;
41169 }
41170 resultobj = SWIG_Py_Void();
41171 {
41172 if (temp2)
41173 delete arg2;
41174 }
41175 return resultobj;
41176 fail:
41177 {
41178 if (temp2)
41179 delete arg2;
41180 }
41181 return NULL;
41182 }
41183
41184
41185 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41186 PyObject *resultobj = 0;
41187 wxWindow *arg1 = (wxWindow *) 0 ;
41188 wxPoint *arg2 = 0 ;
41189 wxHelpEvent::Origin arg3 ;
41190 wxString result;
41191 void *argp1 = 0 ;
41192 int res1 = 0 ;
41193 wxPoint temp2 ;
41194 void *argp3 ;
41195 int res3 = 0 ;
41196 PyObject * obj0 = 0 ;
41197 PyObject * obj1 = 0 ;
41198 PyObject * obj2 = 0 ;
41199 char * kwnames[] = {
41200 (char *) "self",(char *) "pt",(char *) "origin", NULL
41201 };
41202
41203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41205 if (!SWIG_IsOK(res1)) {
41206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
41207 }
41208 arg1 = reinterpret_cast< wxWindow * >(argp1);
41209 {
41210 arg2 = &temp2;
41211 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
41212 }
41213 {
41214 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
41215 if (!SWIG_IsOK(res3)) {
41216 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
41217 }
41218 if (!argp3) {
41219 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
41220 } else {
41221 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
41222 arg3 = *temp;
41223 if (SWIG_IsNewObj(res3)) delete temp;
41224 }
41225 }
41226 {
41227 PyThreadState* __tstate = wxPyBeginAllowThreads();
41228 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
41229 wxPyEndAllowThreads(__tstate);
41230 if (PyErr_Occurred()) SWIG_fail;
41231 }
41232 {
41233 #if wxUSE_UNICODE
41234 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41235 #else
41236 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41237 #endif
41238 }
41239 return resultobj;
41240 fail:
41241 return NULL;
41242 }
41243
41244
41245 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41246 PyObject *resultobj = 0;
41247 wxWindow *arg1 = (wxWindow *) 0 ;
41248 wxString result;
41249 void *argp1 = 0 ;
41250 int res1 = 0 ;
41251 PyObject *swig_obj[1] ;
41252
41253 if (!args) SWIG_fail;
41254 swig_obj[0] = args;
41255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41256 if (!SWIG_IsOK(res1)) {
41257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
41258 }
41259 arg1 = reinterpret_cast< wxWindow * >(argp1);
41260 {
41261 PyThreadState* __tstate = wxPyBeginAllowThreads();
41262 result = ((wxWindow const *)arg1)->GetHelpText();
41263 wxPyEndAllowThreads(__tstate);
41264 if (PyErr_Occurred()) SWIG_fail;
41265 }
41266 {
41267 #if wxUSE_UNICODE
41268 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41269 #else
41270 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41271 #endif
41272 }
41273 return resultobj;
41274 fail:
41275 return NULL;
41276 }
41277
41278
41279 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41280 PyObject *resultobj = 0;
41281 wxWindow *arg1 = (wxWindow *) 0 ;
41282 wxString *arg2 = 0 ;
41283 void *argp1 = 0 ;
41284 int res1 = 0 ;
41285 bool temp2 = false ;
41286 PyObject * obj0 = 0 ;
41287 PyObject * obj1 = 0 ;
41288 char * kwnames[] = {
41289 (char *) "self",(char *) "tip", NULL
41290 };
41291
41292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
41293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41294 if (!SWIG_IsOK(res1)) {
41295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
41296 }
41297 arg1 = reinterpret_cast< wxWindow * >(argp1);
41298 {
41299 arg2 = wxString_in_helper(obj1);
41300 if (arg2 == NULL) SWIG_fail;
41301 temp2 = true;
41302 }
41303 {
41304 PyThreadState* __tstate = wxPyBeginAllowThreads();
41305 (arg1)->SetToolTip((wxString const &)*arg2);
41306 wxPyEndAllowThreads(__tstate);
41307 if (PyErr_Occurred()) SWIG_fail;
41308 }
41309 resultobj = SWIG_Py_Void();
41310 {
41311 if (temp2)
41312 delete arg2;
41313 }
41314 return resultobj;
41315 fail:
41316 {
41317 if (temp2)
41318 delete arg2;
41319 }
41320 return NULL;
41321 }
41322
41323
41324 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41325 PyObject *resultobj = 0;
41326 wxWindow *arg1 = (wxWindow *) 0 ;
41327 wxToolTip *arg2 = (wxToolTip *) 0 ;
41328 void *argp1 = 0 ;
41329 int res1 = 0 ;
41330 int res2 = 0 ;
41331 PyObject * obj0 = 0 ;
41332 PyObject * obj1 = 0 ;
41333 char * kwnames[] = {
41334 (char *) "self",(char *) "tip", NULL
41335 };
41336
41337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
41338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41339 if (!SWIG_IsOK(res1)) {
41340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
41341 }
41342 arg1 = reinterpret_cast< wxWindow * >(argp1);
41343 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
41344 if (!SWIG_IsOK(res2)) {
41345 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
41346 }
41347 {
41348 PyThreadState* __tstate = wxPyBeginAllowThreads();
41349 (arg1)->SetToolTip(arg2);
41350 wxPyEndAllowThreads(__tstate);
41351 if (PyErr_Occurred()) SWIG_fail;
41352 }
41353 resultobj = SWIG_Py_Void();
41354 return resultobj;
41355 fail:
41356 return NULL;
41357 }
41358
41359
41360 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41361 PyObject *resultobj = 0;
41362 wxWindow *arg1 = (wxWindow *) 0 ;
41363 wxToolTip *result = 0 ;
41364 void *argp1 = 0 ;
41365 int res1 = 0 ;
41366 PyObject *swig_obj[1] ;
41367
41368 if (!args) SWIG_fail;
41369 swig_obj[0] = args;
41370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41371 if (!SWIG_IsOK(res1)) {
41372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
41373 }
41374 arg1 = reinterpret_cast< wxWindow * >(argp1);
41375 {
41376 PyThreadState* __tstate = wxPyBeginAllowThreads();
41377 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
41378 wxPyEndAllowThreads(__tstate);
41379 if (PyErr_Occurred()) SWIG_fail;
41380 }
41381 {
41382 resultobj = wxPyMake_wxObject(result, (bool)0);
41383 }
41384 return resultobj;
41385 fail:
41386 return NULL;
41387 }
41388
41389
41390 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41391 PyObject *resultobj = 0;
41392 wxWindow *arg1 = (wxWindow *) 0 ;
41393 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
41394 void *argp1 = 0 ;
41395 int res1 = 0 ;
41396 int res2 = 0 ;
41397 PyObject * obj0 = 0 ;
41398 PyObject * obj1 = 0 ;
41399 char * kwnames[] = {
41400 (char *) "self",(char *) "dropTarget", NULL
41401 };
41402
41403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
41404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41405 if (!SWIG_IsOK(res1)) {
41406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
41407 }
41408 arg1 = reinterpret_cast< wxWindow * >(argp1);
41409 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
41410 if (!SWIG_IsOK(res2)) {
41411 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
41412 }
41413 {
41414 PyThreadState* __tstate = wxPyBeginAllowThreads();
41415 (arg1)->SetDropTarget(arg2);
41416 wxPyEndAllowThreads(__tstate);
41417 if (PyErr_Occurred()) SWIG_fail;
41418 }
41419 resultobj = SWIG_Py_Void();
41420 return resultobj;
41421 fail:
41422 return NULL;
41423 }
41424
41425
41426 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41427 PyObject *resultobj = 0;
41428 wxWindow *arg1 = (wxWindow *) 0 ;
41429 wxPyDropTarget *result = 0 ;
41430 void *argp1 = 0 ;
41431 int res1 = 0 ;
41432 PyObject *swig_obj[1] ;
41433
41434 if (!args) SWIG_fail;
41435 swig_obj[0] = args;
41436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41437 if (!SWIG_IsOK(res1)) {
41438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
41439 }
41440 arg1 = reinterpret_cast< wxWindow * >(argp1);
41441 {
41442 PyThreadState* __tstate = wxPyBeginAllowThreads();
41443 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
41444 wxPyEndAllowThreads(__tstate);
41445 if (PyErr_Occurred()) SWIG_fail;
41446 }
41447 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
41448 return resultobj;
41449 fail:
41450 return NULL;
41451 }
41452
41453
41454 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41455 PyObject *resultobj = 0;
41456 wxWindow *arg1 = (wxWindow *) 0 ;
41457 bool arg2 ;
41458 void *argp1 = 0 ;
41459 int res1 = 0 ;
41460 bool val2 ;
41461 int ecode2 = 0 ;
41462 PyObject * obj0 = 0 ;
41463 PyObject * obj1 = 0 ;
41464 char * kwnames[] = {
41465 (char *) "self",(char *) "accept", NULL
41466 };
41467
41468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
41469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41470 if (!SWIG_IsOK(res1)) {
41471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
41472 }
41473 arg1 = reinterpret_cast< wxWindow * >(argp1);
41474 ecode2 = SWIG_AsVal_bool(obj1, &val2);
41475 if (!SWIG_IsOK(ecode2)) {
41476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
41477 }
41478 arg2 = static_cast< bool >(val2);
41479 {
41480 PyThreadState* __tstate = wxPyBeginAllowThreads();
41481 wxWindow_DragAcceptFiles(arg1,arg2);
41482 wxPyEndAllowThreads(__tstate);
41483 if (PyErr_Occurred()) SWIG_fail;
41484 }
41485 resultobj = SWIG_Py_Void();
41486 return resultobj;
41487 fail:
41488 return NULL;
41489 }
41490
41491
41492 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41493 PyObject *resultobj = 0;
41494 wxWindow *arg1 = (wxWindow *) 0 ;
41495 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
41496 void *argp1 = 0 ;
41497 int res1 = 0 ;
41498 int res2 = 0 ;
41499 PyObject * obj0 = 0 ;
41500 PyObject * obj1 = 0 ;
41501 char * kwnames[] = {
41502 (char *) "self",(char *) "constraints", NULL
41503 };
41504
41505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
41506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41507 if (!SWIG_IsOK(res1)) {
41508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
41509 }
41510 arg1 = reinterpret_cast< wxWindow * >(argp1);
41511 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
41512 if (!SWIG_IsOK(res2)) {
41513 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
41514 }
41515 {
41516 PyThreadState* __tstate = wxPyBeginAllowThreads();
41517 (arg1)->SetConstraints(arg2);
41518 wxPyEndAllowThreads(__tstate);
41519 if (PyErr_Occurred()) SWIG_fail;
41520 }
41521 resultobj = SWIG_Py_Void();
41522 return resultobj;
41523 fail:
41524 return NULL;
41525 }
41526
41527
41528 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41529 PyObject *resultobj = 0;
41530 wxWindow *arg1 = (wxWindow *) 0 ;
41531 wxLayoutConstraints *result = 0 ;
41532 void *argp1 = 0 ;
41533 int res1 = 0 ;
41534 PyObject *swig_obj[1] ;
41535
41536 if (!args) SWIG_fail;
41537 swig_obj[0] = args;
41538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41539 if (!SWIG_IsOK(res1)) {
41540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
41541 }
41542 arg1 = reinterpret_cast< wxWindow * >(argp1);
41543 {
41544 PyThreadState* __tstate = wxPyBeginAllowThreads();
41545 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
41546 wxPyEndAllowThreads(__tstate);
41547 if (PyErr_Occurred()) SWIG_fail;
41548 }
41549 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
41550 return resultobj;
41551 fail:
41552 return NULL;
41553 }
41554
41555
41556 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41557 PyObject *resultobj = 0;
41558 wxWindow *arg1 = (wxWindow *) 0 ;
41559 bool arg2 ;
41560 void *argp1 = 0 ;
41561 int res1 = 0 ;
41562 bool val2 ;
41563 int ecode2 = 0 ;
41564 PyObject * obj0 = 0 ;
41565 PyObject * obj1 = 0 ;
41566 char * kwnames[] = {
41567 (char *) "self",(char *) "autoLayout", NULL
41568 };
41569
41570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
41571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41572 if (!SWIG_IsOK(res1)) {
41573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
41574 }
41575 arg1 = reinterpret_cast< wxWindow * >(argp1);
41576 ecode2 = SWIG_AsVal_bool(obj1, &val2);
41577 if (!SWIG_IsOK(ecode2)) {
41578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
41579 }
41580 arg2 = static_cast< bool >(val2);
41581 {
41582 PyThreadState* __tstate = wxPyBeginAllowThreads();
41583 (arg1)->SetAutoLayout(arg2);
41584 wxPyEndAllowThreads(__tstate);
41585 if (PyErr_Occurred()) SWIG_fail;
41586 }
41587 resultobj = SWIG_Py_Void();
41588 return resultobj;
41589 fail:
41590 return NULL;
41591 }
41592
41593
41594 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41595 PyObject *resultobj = 0;
41596 wxWindow *arg1 = (wxWindow *) 0 ;
41597 bool result;
41598 void *argp1 = 0 ;
41599 int res1 = 0 ;
41600 PyObject *swig_obj[1] ;
41601
41602 if (!args) SWIG_fail;
41603 swig_obj[0] = args;
41604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41605 if (!SWIG_IsOK(res1)) {
41606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
41607 }
41608 arg1 = reinterpret_cast< wxWindow * >(argp1);
41609 {
41610 PyThreadState* __tstate = wxPyBeginAllowThreads();
41611 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
41612 wxPyEndAllowThreads(__tstate);
41613 if (PyErr_Occurred()) SWIG_fail;
41614 }
41615 {
41616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41617 }
41618 return resultobj;
41619 fail:
41620 return NULL;
41621 }
41622
41623
41624 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41625 PyObject *resultobj = 0;
41626 wxWindow *arg1 = (wxWindow *) 0 ;
41627 bool result;
41628 void *argp1 = 0 ;
41629 int res1 = 0 ;
41630 PyObject *swig_obj[1] ;
41631
41632 if (!args) SWIG_fail;
41633 swig_obj[0] = args;
41634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41635 if (!SWIG_IsOK(res1)) {
41636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
41637 }
41638 arg1 = reinterpret_cast< wxWindow * >(argp1);
41639 {
41640 PyThreadState* __tstate = wxPyBeginAllowThreads();
41641 result = (bool)(arg1)->Layout();
41642 wxPyEndAllowThreads(__tstate);
41643 if (PyErr_Occurred()) SWIG_fail;
41644 }
41645 {
41646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41647 }
41648 return resultobj;
41649 fail:
41650 return NULL;
41651 }
41652
41653
41654 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41655 PyObject *resultobj = 0;
41656 wxWindow *arg1 = (wxWindow *) 0 ;
41657 wxSizer *arg2 = (wxSizer *) 0 ;
41658 bool arg3 = (bool) true ;
41659 void *argp1 = 0 ;
41660 int res1 = 0 ;
41661 int res2 = 0 ;
41662 bool val3 ;
41663 int ecode3 = 0 ;
41664 PyObject * obj0 = 0 ;
41665 PyObject * obj1 = 0 ;
41666 PyObject * obj2 = 0 ;
41667 char * kwnames[] = {
41668 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
41669 };
41670
41671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41673 if (!SWIG_IsOK(res1)) {
41674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
41675 }
41676 arg1 = reinterpret_cast< wxWindow * >(argp1);
41677 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
41678 if (!SWIG_IsOK(res2)) {
41679 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
41680 }
41681 if (obj2) {
41682 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41683 if (!SWIG_IsOK(ecode3)) {
41684 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
41685 }
41686 arg3 = static_cast< bool >(val3);
41687 }
41688 {
41689 PyThreadState* __tstate = wxPyBeginAllowThreads();
41690 (arg1)->SetSizer(arg2,arg3);
41691 wxPyEndAllowThreads(__tstate);
41692 if (PyErr_Occurred()) SWIG_fail;
41693 }
41694 resultobj = SWIG_Py_Void();
41695 return resultobj;
41696 fail:
41697 return NULL;
41698 }
41699
41700
41701 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41702 PyObject *resultobj = 0;
41703 wxWindow *arg1 = (wxWindow *) 0 ;
41704 wxSizer *arg2 = (wxSizer *) 0 ;
41705 bool arg3 = (bool) true ;
41706 void *argp1 = 0 ;
41707 int res1 = 0 ;
41708 int res2 = 0 ;
41709 bool val3 ;
41710 int ecode3 = 0 ;
41711 PyObject * obj0 = 0 ;
41712 PyObject * obj1 = 0 ;
41713 PyObject * obj2 = 0 ;
41714 char * kwnames[] = {
41715 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
41716 };
41717
41718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41720 if (!SWIG_IsOK(res1)) {
41721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
41722 }
41723 arg1 = reinterpret_cast< wxWindow * >(argp1);
41724 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
41725 if (!SWIG_IsOK(res2)) {
41726 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
41727 }
41728 if (obj2) {
41729 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41730 if (!SWIG_IsOK(ecode3)) {
41731 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
41732 }
41733 arg3 = static_cast< bool >(val3);
41734 }
41735 {
41736 PyThreadState* __tstate = wxPyBeginAllowThreads();
41737 (arg1)->SetSizerAndFit(arg2,arg3);
41738 wxPyEndAllowThreads(__tstate);
41739 if (PyErr_Occurred()) SWIG_fail;
41740 }
41741 resultobj = SWIG_Py_Void();
41742 return resultobj;
41743 fail:
41744 return NULL;
41745 }
41746
41747
41748 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41749 PyObject *resultobj = 0;
41750 wxWindow *arg1 = (wxWindow *) 0 ;
41751 wxSizer *result = 0 ;
41752 void *argp1 = 0 ;
41753 int res1 = 0 ;
41754 PyObject *swig_obj[1] ;
41755
41756 if (!args) SWIG_fail;
41757 swig_obj[0] = args;
41758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41759 if (!SWIG_IsOK(res1)) {
41760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
41761 }
41762 arg1 = reinterpret_cast< wxWindow * >(argp1);
41763 {
41764 PyThreadState* __tstate = wxPyBeginAllowThreads();
41765 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
41766 wxPyEndAllowThreads(__tstate);
41767 if (PyErr_Occurred()) SWIG_fail;
41768 }
41769 {
41770 resultobj = wxPyMake_wxObject(result, (bool)0);
41771 }
41772 return resultobj;
41773 fail:
41774 return NULL;
41775 }
41776
41777
41778 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41779 PyObject *resultobj = 0;
41780 wxWindow *arg1 = (wxWindow *) 0 ;
41781 wxSizer *arg2 = (wxSizer *) 0 ;
41782 void *argp1 = 0 ;
41783 int res1 = 0 ;
41784 void *argp2 = 0 ;
41785 int res2 = 0 ;
41786 PyObject * obj0 = 0 ;
41787 PyObject * obj1 = 0 ;
41788 char * kwnames[] = {
41789 (char *) "self",(char *) "sizer", NULL
41790 };
41791
41792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
41793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41794 if (!SWIG_IsOK(res1)) {
41795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
41796 }
41797 arg1 = reinterpret_cast< wxWindow * >(argp1);
41798 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
41799 if (!SWIG_IsOK(res2)) {
41800 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
41801 }
41802 arg2 = reinterpret_cast< wxSizer * >(argp2);
41803 {
41804 PyThreadState* __tstate = wxPyBeginAllowThreads();
41805 (arg1)->SetContainingSizer(arg2);
41806 wxPyEndAllowThreads(__tstate);
41807 if (PyErr_Occurred()) SWIG_fail;
41808 }
41809 resultobj = SWIG_Py_Void();
41810 return resultobj;
41811 fail:
41812 return NULL;
41813 }
41814
41815
41816 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41817 PyObject *resultobj = 0;
41818 wxWindow *arg1 = (wxWindow *) 0 ;
41819 wxSizer *result = 0 ;
41820 void *argp1 = 0 ;
41821 int res1 = 0 ;
41822 PyObject *swig_obj[1] ;
41823
41824 if (!args) SWIG_fail;
41825 swig_obj[0] = args;
41826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41827 if (!SWIG_IsOK(res1)) {
41828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
41829 }
41830 arg1 = reinterpret_cast< wxWindow * >(argp1);
41831 {
41832 PyThreadState* __tstate = wxPyBeginAllowThreads();
41833 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
41834 wxPyEndAllowThreads(__tstate);
41835 if (PyErr_Occurred()) SWIG_fail;
41836 }
41837 {
41838 resultobj = wxPyMake_wxObject(result, (bool)0);
41839 }
41840 return resultobj;
41841 fail:
41842 return NULL;
41843 }
41844
41845
41846 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41847 PyObject *resultobj = 0;
41848 wxWindow *arg1 = (wxWindow *) 0 ;
41849 void *argp1 = 0 ;
41850 int res1 = 0 ;
41851 PyObject *swig_obj[1] ;
41852
41853 if (!args) SWIG_fail;
41854 swig_obj[0] = args;
41855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41856 if (!SWIG_IsOK(res1)) {
41857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
41858 }
41859 arg1 = reinterpret_cast< wxWindow * >(argp1);
41860 {
41861 PyThreadState* __tstate = wxPyBeginAllowThreads();
41862 (arg1)->InheritAttributes();
41863 wxPyEndAllowThreads(__tstate);
41864 if (PyErr_Occurred()) SWIG_fail;
41865 }
41866 resultobj = SWIG_Py_Void();
41867 return resultobj;
41868 fail:
41869 return NULL;
41870 }
41871
41872
41873 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41874 PyObject *resultobj = 0;
41875 wxWindow *arg1 = (wxWindow *) 0 ;
41876 bool result;
41877 void *argp1 = 0 ;
41878 int res1 = 0 ;
41879 PyObject *swig_obj[1] ;
41880
41881 if (!args) SWIG_fail;
41882 swig_obj[0] = args;
41883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41884 if (!SWIG_IsOK(res1)) {
41885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
41886 }
41887 arg1 = reinterpret_cast< wxWindow * >(argp1);
41888 {
41889 PyThreadState* __tstate = wxPyBeginAllowThreads();
41890 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
41891 wxPyEndAllowThreads(__tstate);
41892 if (PyErr_Occurred()) SWIG_fail;
41893 }
41894 {
41895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41896 }
41897 return resultobj;
41898 fail:
41899 return NULL;
41900 }
41901
41902
41903 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41904 PyObject *resultobj = 0;
41905 wxWindow *arg1 = (wxWindow *) 0 ;
41906 bool result;
41907 void *argp1 = 0 ;
41908 int res1 = 0 ;
41909 PyObject *swig_obj[1] ;
41910
41911 if (!args) SWIG_fail;
41912 swig_obj[0] = args;
41913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41914 if (!SWIG_IsOK(res1)) {
41915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41916 }
41917 arg1 = reinterpret_cast< wxWindow * >(argp1);
41918 {
41919 PyThreadState* __tstate = wxPyBeginAllowThreads();
41920 result = (bool)(arg1)->CanSetTransparent();
41921 wxPyEndAllowThreads(__tstate);
41922 if (PyErr_Occurred()) SWIG_fail;
41923 }
41924 {
41925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41926 }
41927 return resultobj;
41928 fail:
41929 return NULL;
41930 }
41931
41932
41933 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41934 PyObject *resultobj = 0;
41935 wxWindow *arg1 = (wxWindow *) 0 ;
41936 byte arg2 ;
41937 bool result;
41938 void *argp1 = 0 ;
41939 int res1 = 0 ;
41940 unsigned char val2 ;
41941 int ecode2 = 0 ;
41942 PyObject * obj0 = 0 ;
41943 PyObject * obj1 = 0 ;
41944 char * kwnames[] = {
41945 (char *) "self",(char *) "alpha", NULL
41946 };
41947
41948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
41949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41950 if (!SWIG_IsOK(res1)) {
41951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41952 }
41953 arg1 = reinterpret_cast< wxWindow * >(argp1);
41954 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
41955 if (!SWIG_IsOK(ecode2)) {
41956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
41957 }
41958 arg2 = static_cast< byte >(val2);
41959 {
41960 PyThreadState* __tstate = wxPyBeginAllowThreads();
41961 result = (bool)(arg1)->SetTransparent(arg2);
41962 wxPyEndAllowThreads(__tstate);
41963 if (PyErr_Occurred()) SWIG_fail;
41964 }
41965 {
41966 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41967 }
41968 return resultobj;
41969 fail:
41970 return NULL;
41971 }
41972
41973
41974 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41975 PyObject *obj;
41976 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41977 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
41978 return SWIG_Py_Void();
41979 }
41980
41981 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41982 return SWIG_Python_InitShadowInstance(args);
41983 }
41984
41985 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41986 PyObject *resultobj = 0;
41987 long arg1 ;
41988 wxWindow *arg2 = (wxWindow *) NULL ;
41989 wxWindow *result = 0 ;
41990 long val1 ;
41991 int ecode1 = 0 ;
41992 void *argp2 = 0 ;
41993 int res2 = 0 ;
41994 PyObject * obj0 = 0 ;
41995 PyObject * obj1 = 0 ;
41996 char * kwnames[] = {
41997 (char *) "id",(char *) "parent", NULL
41998 };
41999
42000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
42001 ecode1 = SWIG_AsVal_long(obj0, &val1);
42002 if (!SWIG_IsOK(ecode1)) {
42003 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
42004 }
42005 arg1 = static_cast< long >(val1);
42006 if (obj1) {
42007 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
42008 if (!SWIG_IsOK(res2)) {
42009 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
42010 }
42011 arg2 = reinterpret_cast< wxWindow * >(argp2);
42012 }
42013 {
42014 if (!wxPyCheckForApp()) SWIG_fail;
42015 PyThreadState* __tstate = wxPyBeginAllowThreads();
42016 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
42017 wxPyEndAllowThreads(__tstate);
42018 if (PyErr_Occurred()) SWIG_fail;
42019 }
42020 {
42021 resultobj = wxPyMake_wxObject(result, 0);
42022 }
42023 return resultobj;
42024 fail:
42025 return NULL;
42026 }
42027
42028
42029 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42030 PyObject *resultobj = 0;
42031 wxString *arg1 = 0 ;
42032 wxWindow *arg2 = (wxWindow *) NULL ;
42033 wxWindow *result = 0 ;
42034 bool temp1 = false ;
42035 void *argp2 = 0 ;
42036 int res2 = 0 ;
42037 PyObject * obj0 = 0 ;
42038 PyObject * obj1 = 0 ;
42039 char * kwnames[] = {
42040 (char *) "name",(char *) "parent", NULL
42041 };
42042
42043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
42044 {
42045 arg1 = wxString_in_helper(obj0);
42046 if (arg1 == NULL) SWIG_fail;
42047 temp1 = true;
42048 }
42049 if (obj1) {
42050 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
42051 if (!SWIG_IsOK(res2)) {
42052 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
42053 }
42054 arg2 = reinterpret_cast< wxWindow * >(argp2);
42055 }
42056 {
42057 if (!wxPyCheckForApp()) SWIG_fail;
42058 PyThreadState* __tstate = wxPyBeginAllowThreads();
42059 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
42060 wxPyEndAllowThreads(__tstate);
42061 if (PyErr_Occurred()) SWIG_fail;
42062 }
42063 {
42064 resultobj = wxPyMake_wxObject(result, 0);
42065 }
42066 {
42067 if (temp1)
42068 delete arg1;
42069 }
42070 return resultobj;
42071 fail:
42072 {
42073 if (temp1)
42074 delete arg1;
42075 }
42076 return NULL;
42077 }
42078
42079
42080 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42081 PyObject *resultobj = 0;
42082 wxString *arg1 = 0 ;
42083 wxWindow *arg2 = (wxWindow *) NULL ;
42084 wxWindow *result = 0 ;
42085 bool temp1 = false ;
42086 void *argp2 = 0 ;
42087 int res2 = 0 ;
42088 PyObject * obj0 = 0 ;
42089 PyObject * obj1 = 0 ;
42090 char * kwnames[] = {
42091 (char *) "label",(char *) "parent", NULL
42092 };
42093
42094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
42095 {
42096 arg1 = wxString_in_helper(obj0);
42097 if (arg1 == NULL) SWIG_fail;
42098 temp1 = true;
42099 }
42100 if (obj1) {
42101 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
42102 if (!SWIG_IsOK(res2)) {
42103 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
42104 }
42105 arg2 = reinterpret_cast< wxWindow * >(argp2);
42106 }
42107 {
42108 if (!wxPyCheckForApp()) SWIG_fail;
42109 PyThreadState* __tstate = wxPyBeginAllowThreads();
42110 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
42111 wxPyEndAllowThreads(__tstate);
42112 if (PyErr_Occurred()) SWIG_fail;
42113 }
42114 {
42115 resultobj = wxPyMake_wxObject(result, 0);
42116 }
42117 {
42118 if (temp1)
42119 delete arg1;
42120 }
42121 return resultobj;
42122 fail:
42123 {
42124 if (temp1)
42125 delete arg1;
42126 }
42127 return NULL;
42128 }
42129
42130
42131 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42132 PyObject *resultobj = 0;
42133 wxWindow *arg1 = (wxWindow *) 0 ;
42134 unsigned long arg2 ;
42135 wxWindow *result = 0 ;
42136 void *argp1 = 0 ;
42137 int res1 = 0 ;
42138 unsigned long val2 ;
42139 int ecode2 = 0 ;
42140 PyObject * obj0 = 0 ;
42141 PyObject * obj1 = 0 ;
42142 char * kwnames[] = {
42143 (char *) "parent",(char *) "_hWnd", NULL
42144 };
42145
42146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
42147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
42148 if (!SWIG_IsOK(res1)) {
42149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
42150 }
42151 arg1 = reinterpret_cast< wxWindow * >(argp1);
42152 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
42153 if (!SWIG_IsOK(ecode2)) {
42154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
42155 }
42156 arg2 = static_cast< unsigned long >(val2);
42157 {
42158 if (!wxPyCheckForApp()) SWIG_fail;
42159 PyThreadState* __tstate = wxPyBeginAllowThreads();
42160 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
42161 wxPyEndAllowThreads(__tstate);
42162 if (PyErr_Occurred()) SWIG_fail;
42163 }
42164 {
42165 resultobj = wxPyMake_wxObject(result, 0);
42166 }
42167 return resultobj;
42168 fail:
42169 return NULL;
42170 }
42171
42172
42173 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42174 PyObject *resultobj = 0;
42175 PyObject *result = 0 ;
42176
42177 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
42178 {
42179 PyThreadState* __tstate = wxPyBeginAllowThreads();
42180 result = (PyObject *)GetTopLevelWindows();
42181 wxPyEndAllowThreads(__tstate);
42182 if (PyErr_Occurred()) SWIG_fail;
42183 }
42184 resultobj = result;
42185 return resultobj;
42186 fail:
42187 return NULL;
42188 }
42189
42190
42191 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42192 PyObject *resultobj = 0;
42193 wxValidator *result = 0 ;
42194
42195 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
42196 {
42197 PyThreadState* __tstate = wxPyBeginAllowThreads();
42198 result = (wxValidator *)new wxValidator();
42199 wxPyEndAllowThreads(__tstate);
42200 if (PyErr_Occurred()) SWIG_fail;
42201 }
42202 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
42203 return resultobj;
42204 fail:
42205 return NULL;
42206 }
42207
42208
42209 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42210 PyObject *resultobj = 0;
42211 wxValidator *arg1 = (wxValidator *) 0 ;
42212 wxValidator *result = 0 ;
42213 void *argp1 = 0 ;
42214 int res1 = 0 ;
42215 PyObject *swig_obj[1] ;
42216
42217 if (!args) SWIG_fail;
42218 swig_obj[0] = args;
42219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
42220 if (!SWIG_IsOK(res1)) {
42221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
42222 }
42223 arg1 = reinterpret_cast< wxValidator * >(argp1);
42224 {
42225 PyThreadState* __tstate = wxPyBeginAllowThreads();
42226 result = (wxValidator *)(arg1)->Clone();
42227 wxPyEndAllowThreads(__tstate);
42228 if (PyErr_Occurred()) SWIG_fail;
42229 }
42230 {
42231 resultobj = wxPyMake_wxObject(result, 0);
42232 }
42233 return resultobj;
42234 fail:
42235 return NULL;
42236 }
42237
42238
42239 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42240 PyObject *resultobj = 0;
42241 wxValidator *arg1 = (wxValidator *) 0 ;
42242 wxWindow *arg2 = (wxWindow *) 0 ;
42243 bool result;
42244 void *argp1 = 0 ;
42245 int res1 = 0 ;
42246 void *argp2 = 0 ;
42247 int res2 = 0 ;
42248 PyObject * obj0 = 0 ;
42249 PyObject * obj1 = 0 ;
42250 char * kwnames[] = {
42251 (char *) "self",(char *) "parent", NULL
42252 };
42253
42254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
42255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
42256 if (!SWIG_IsOK(res1)) {
42257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
42258 }
42259 arg1 = reinterpret_cast< wxValidator * >(argp1);
42260 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
42261 if (!SWIG_IsOK(res2)) {
42262 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
42263 }
42264 arg2 = reinterpret_cast< wxWindow * >(argp2);
42265 {
42266 PyThreadState* __tstate = wxPyBeginAllowThreads();
42267 result = (bool)(arg1)->Validate(arg2);
42268 wxPyEndAllowThreads(__tstate);
42269 if (PyErr_Occurred()) SWIG_fail;
42270 }
42271 {
42272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42273 }
42274 return resultobj;
42275 fail:
42276 return NULL;
42277 }
42278
42279
42280 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42281 PyObject *resultobj = 0;
42282 wxValidator *arg1 = (wxValidator *) 0 ;
42283 bool result;
42284 void *argp1 = 0 ;
42285 int res1 = 0 ;
42286 PyObject *swig_obj[1] ;
42287
42288 if (!args) SWIG_fail;
42289 swig_obj[0] = args;
42290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
42291 if (!SWIG_IsOK(res1)) {
42292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
42293 }
42294 arg1 = reinterpret_cast< wxValidator * >(argp1);
42295 {
42296 PyThreadState* __tstate = wxPyBeginAllowThreads();
42297 result = (bool)(arg1)->TransferToWindow();
42298 wxPyEndAllowThreads(__tstate);
42299 if (PyErr_Occurred()) SWIG_fail;
42300 }
42301 {
42302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42303 }
42304 return resultobj;
42305 fail:
42306 return NULL;
42307 }
42308
42309
42310 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42311 PyObject *resultobj = 0;
42312 wxValidator *arg1 = (wxValidator *) 0 ;
42313 bool result;
42314 void *argp1 = 0 ;
42315 int res1 = 0 ;
42316 PyObject *swig_obj[1] ;
42317
42318 if (!args) SWIG_fail;
42319 swig_obj[0] = args;
42320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
42321 if (!SWIG_IsOK(res1)) {
42322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
42323 }
42324 arg1 = reinterpret_cast< wxValidator * >(argp1);
42325 {
42326 PyThreadState* __tstate = wxPyBeginAllowThreads();
42327 result = (bool)(arg1)->TransferFromWindow();
42328 wxPyEndAllowThreads(__tstate);
42329 if (PyErr_Occurred()) SWIG_fail;
42330 }
42331 {
42332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42333 }
42334 return resultobj;
42335 fail:
42336 return NULL;
42337 }
42338
42339
42340 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42341 PyObject *resultobj = 0;
42342 wxValidator *arg1 = (wxValidator *) 0 ;
42343 wxWindow *result = 0 ;
42344 void *argp1 = 0 ;
42345 int res1 = 0 ;
42346 PyObject *swig_obj[1] ;
42347
42348 if (!args) SWIG_fail;
42349 swig_obj[0] = args;
42350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
42351 if (!SWIG_IsOK(res1)) {
42352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
42353 }
42354 arg1 = reinterpret_cast< wxValidator * >(argp1);
42355 {
42356 PyThreadState* __tstate = wxPyBeginAllowThreads();
42357 result = (wxWindow *)(arg1)->GetWindow();
42358 wxPyEndAllowThreads(__tstate);
42359 if (PyErr_Occurred()) SWIG_fail;
42360 }
42361 {
42362 resultobj = wxPyMake_wxObject(result, 0);
42363 }
42364 return resultobj;
42365 fail:
42366 return NULL;
42367 }
42368
42369
42370 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42371 PyObject *resultobj = 0;
42372 wxValidator *arg1 = (wxValidator *) 0 ;
42373 wxWindow *arg2 = (wxWindow *) 0 ;
42374 void *argp1 = 0 ;
42375 int res1 = 0 ;
42376 void *argp2 = 0 ;
42377 int res2 = 0 ;
42378 PyObject * obj0 = 0 ;
42379 PyObject * obj1 = 0 ;
42380 char * kwnames[] = {
42381 (char *) "self",(char *) "window", NULL
42382 };
42383
42384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
42385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
42386 if (!SWIG_IsOK(res1)) {
42387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
42388 }
42389 arg1 = reinterpret_cast< wxValidator * >(argp1);
42390 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
42391 if (!SWIG_IsOK(res2)) {
42392 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
42393 }
42394 arg2 = reinterpret_cast< wxWindow * >(argp2);
42395 {
42396 PyThreadState* __tstate = wxPyBeginAllowThreads();
42397 (arg1)->SetWindow(arg2);
42398 wxPyEndAllowThreads(__tstate);
42399 if (PyErr_Occurred()) SWIG_fail;
42400 }
42401 resultobj = SWIG_Py_Void();
42402 return resultobj;
42403 fail:
42404 return NULL;
42405 }
42406
42407
42408 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42409 PyObject *resultobj = 0;
42410 bool result;
42411
42412 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
42413 {
42414 PyThreadState* __tstate = wxPyBeginAllowThreads();
42415 result = (bool)wxValidator::IsSilent();
42416 wxPyEndAllowThreads(__tstate);
42417 if (PyErr_Occurred()) SWIG_fail;
42418 }
42419 {
42420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42421 }
42422 return resultobj;
42423 fail:
42424 return NULL;
42425 }
42426
42427
42428 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42429 PyObject *resultobj = 0;
42430 int arg1 = (int) true ;
42431 int val1 ;
42432 int ecode1 = 0 ;
42433 PyObject * obj0 = 0 ;
42434 char * kwnames[] = {
42435 (char *) "doIt", NULL
42436 };
42437
42438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
42439 if (obj0) {
42440 ecode1 = SWIG_AsVal_int(obj0, &val1);
42441 if (!SWIG_IsOK(ecode1)) {
42442 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
42443 }
42444 arg1 = static_cast< int >(val1);
42445 }
42446 {
42447 PyThreadState* __tstate = wxPyBeginAllowThreads();
42448 wxValidator::SetBellOnError(arg1);
42449 wxPyEndAllowThreads(__tstate);
42450 if (PyErr_Occurred()) SWIG_fail;
42451 }
42452 resultobj = SWIG_Py_Void();
42453 return resultobj;
42454 fail:
42455 return NULL;
42456 }
42457
42458
42459 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42460 PyObject *obj;
42461 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42462 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
42463 return SWIG_Py_Void();
42464 }
42465
42466 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42467 return SWIG_Python_InitShadowInstance(args);
42468 }
42469
42470 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42471 PyObject *resultobj = 0;
42472 wxPyValidator *result = 0 ;
42473
42474 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
42475 {
42476 PyThreadState* __tstate = wxPyBeginAllowThreads();
42477 result = (wxPyValidator *)new wxPyValidator();
42478 wxPyEndAllowThreads(__tstate);
42479 if (PyErr_Occurred()) SWIG_fail;
42480 }
42481 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
42482 return resultobj;
42483 fail:
42484 return NULL;
42485 }
42486
42487
42488 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42489 PyObject *resultobj = 0;
42490 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
42491 PyObject *arg2 = (PyObject *) 0 ;
42492 PyObject *arg3 = (PyObject *) 0 ;
42493 int arg4 = (int) 1 ;
42494 void *argp1 = 0 ;
42495 int res1 = 0 ;
42496 int val4 ;
42497 int ecode4 = 0 ;
42498 PyObject * obj0 = 0 ;
42499 PyObject * obj1 = 0 ;
42500 PyObject * obj2 = 0 ;
42501 PyObject * obj3 = 0 ;
42502 char * kwnames[] = {
42503 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
42504 };
42505
42506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
42508 if (!SWIG_IsOK(res1)) {
42509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
42510 }
42511 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
42512 arg2 = obj1;
42513 arg3 = obj2;
42514 if (obj3) {
42515 ecode4 = SWIG_AsVal_int(obj3, &val4);
42516 if (!SWIG_IsOK(ecode4)) {
42517 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
42518 }
42519 arg4 = static_cast< int >(val4);
42520 }
42521 {
42522 PyThreadState* __tstate = wxPyBeginAllowThreads();
42523 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
42524 wxPyEndAllowThreads(__tstate);
42525 if (PyErr_Occurred()) SWIG_fail;
42526 }
42527 resultobj = SWIG_Py_Void();
42528 return resultobj;
42529 fail:
42530 return NULL;
42531 }
42532
42533
42534 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42535 PyObject *obj;
42536 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42537 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
42538 return SWIG_Py_Void();
42539 }
42540
42541 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42542 return SWIG_Python_InitShadowInstance(args);
42543 }
42544
42545 SWIGINTERN int DefaultValidator_set(PyObject *) {
42546 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
42547 return 1;
42548 }
42549
42550
42551 SWIGINTERN PyObject *DefaultValidator_get(void) {
42552 PyObject *pyobj = 0;
42553
42554 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
42555 return pyobj;
42556 }
42557
42558
42559 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42560 PyObject *resultobj = 0;
42561 wxString const &arg1_defvalue = wxPyEmptyString ;
42562 wxString *arg1 = (wxString *) &arg1_defvalue ;
42563 long arg2 = (long) 0 ;
42564 wxMenu *result = 0 ;
42565 bool temp1 = false ;
42566 long val2 ;
42567 int ecode2 = 0 ;
42568 PyObject * obj0 = 0 ;
42569 PyObject * obj1 = 0 ;
42570 char * kwnames[] = {
42571 (char *) "title",(char *) "style", NULL
42572 };
42573
42574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
42575 if (obj0) {
42576 {
42577 arg1 = wxString_in_helper(obj0);
42578 if (arg1 == NULL) SWIG_fail;
42579 temp1 = true;
42580 }
42581 }
42582 if (obj1) {
42583 ecode2 = SWIG_AsVal_long(obj1, &val2);
42584 if (!SWIG_IsOK(ecode2)) {
42585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
42586 }
42587 arg2 = static_cast< long >(val2);
42588 }
42589 {
42590 if (!wxPyCheckForApp()) SWIG_fail;
42591 PyThreadState* __tstate = wxPyBeginAllowThreads();
42592 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
42593 wxPyEndAllowThreads(__tstate);
42594 if (PyErr_Occurred()) SWIG_fail;
42595 }
42596 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
42597 {
42598 if (temp1)
42599 delete arg1;
42600 }
42601 return resultobj;
42602 fail:
42603 {
42604 if (temp1)
42605 delete arg1;
42606 }
42607 return NULL;
42608 }
42609
42610
42611 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42612 PyObject *resultobj = 0;
42613 wxMenu *arg1 = (wxMenu *) 0 ;
42614 int arg2 ;
42615 wxString const &arg3_defvalue = wxPyEmptyString ;
42616 wxString *arg3 = (wxString *) &arg3_defvalue ;
42617 wxString const &arg4_defvalue = wxPyEmptyString ;
42618 wxString *arg4 = (wxString *) &arg4_defvalue ;
42619 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42620 wxMenuItem *result = 0 ;
42621 void *argp1 = 0 ;
42622 int res1 = 0 ;
42623 int val2 ;
42624 int ecode2 = 0 ;
42625 bool temp3 = false ;
42626 bool temp4 = false ;
42627 int val5 ;
42628 int ecode5 = 0 ;
42629 PyObject * obj0 = 0 ;
42630 PyObject * obj1 = 0 ;
42631 PyObject * obj2 = 0 ;
42632 PyObject * obj3 = 0 ;
42633 PyObject * obj4 = 0 ;
42634 char * kwnames[] = {
42635 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42636 };
42637
42638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42640 if (!SWIG_IsOK(res1)) {
42641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
42642 }
42643 arg1 = reinterpret_cast< wxMenu * >(argp1);
42644 ecode2 = SWIG_AsVal_int(obj1, &val2);
42645 if (!SWIG_IsOK(ecode2)) {
42646 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
42647 }
42648 arg2 = static_cast< int >(val2);
42649 if (obj2) {
42650 {
42651 arg3 = wxString_in_helper(obj2);
42652 if (arg3 == NULL) SWIG_fail;
42653 temp3 = true;
42654 }
42655 }
42656 if (obj3) {
42657 {
42658 arg4 = wxString_in_helper(obj3);
42659 if (arg4 == NULL) SWIG_fail;
42660 temp4 = true;
42661 }
42662 }
42663 if (obj4) {
42664 ecode5 = SWIG_AsVal_int(obj4, &val5);
42665 if (!SWIG_IsOK(ecode5)) {
42666 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
42667 }
42668 arg5 = static_cast< wxItemKind >(val5);
42669 }
42670 {
42671 PyThreadState* __tstate = wxPyBeginAllowThreads();
42672 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
42673 wxPyEndAllowThreads(__tstate);
42674 if (PyErr_Occurred()) SWIG_fail;
42675 }
42676 {
42677 resultobj = wxPyMake_wxObject(result, (bool)0);
42678 }
42679 {
42680 if (temp3)
42681 delete arg3;
42682 }
42683 {
42684 if (temp4)
42685 delete arg4;
42686 }
42687 return resultobj;
42688 fail:
42689 {
42690 if (temp3)
42691 delete arg3;
42692 }
42693 {
42694 if (temp4)
42695 delete arg4;
42696 }
42697 return NULL;
42698 }
42699
42700
42701 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42702 PyObject *resultobj = 0;
42703 wxMenu *arg1 = (wxMenu *) 0 ;
42704 wxMenuItem *result = 0 ;
42705 void *argp1 = 0 ;
42706 int res1 = 0 ;
42707 PyObject *swig_obj[1] ;
42708
42709 if (!args) SWIG_fail;
42710 swig_obj[0] = args;
42711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42712 if (!SWIG_IsOK(res1)) {
42713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42714 }
42715 arg1 = reinterpret_cast< wxMenu * >(argp1);
42716 {
42717 PyThreadState* __tstate = wxPyBeginAllowThreads();
42718 result = (wxMenuItem *)(arg1)->AppendSeparator();
42719 wxPyEndAllowThreads(__tstate);
42720 if (PyErr_Occurred()) SWIG_fail;
42721 }
42722 {
42723 resultobj = wxPyMake_wxObject(result, (bool)0);
42724 }
42725 return resultobj;
42726 fail:
42727 return NULL;
42728 }
42729
42730
42731 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42732 PyObject *resultobj = 0;
42733 wxMenu *arg1 = (wxMenu *) 0 ;
42734 int arg2 ;
42735 wxString *arg3 = 0 ;
42736 wxString const &arg4_defvalue = wxPyEmptyString ;
42737 wxString *arg4 = (wxString *) &arg4_defvalue ;
42738 wxMenuItem *result = 0 ;
42739 void *argp1 = 0 ;
42740 int res1 = 0 ;
42741 int val2 ;
42742 int ecode2 = 0 ;
42743 bool temp3 = false ;
42744 bool temp4 = false ;
42745 PyObject * obj0 = 0 ;
42746 PyObject * obj1 = 0 ;
42747 PyObject * obj2 = 0 ;
42748 PyObject * obj3 = 0 ;
42749 char * kwnames[] = {
42750 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42751 };
42752
42753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42755 if (!SWIG_IsOK(res1)) {
42756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42757 }
42758 arg1 = reinterpret_cast< wxMenu * >(argp1);
42759 ecode2 = SWIG_AsVal_int(obj1, &val2);
42760 if (!SWIG_IsOK(ecode2)) {
42761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
42762 }
42763 arg2 = static_cast< int >(val2);
42764 {
42765 arg3 = wxString_in_helper(obj2);
42766 if (arg3 == NULL) SWIG_fail;
42767 temp3 = true;
42768 }
42769 if (obj3) {
42770 {
42771 arg4 = wxString_in_helper(obj3);
42772 if (arg4 == NULL) SWIG_fail;
42773 temp4 = true;
42774 }
42775 }
42776 {
42777 PyThreadState* __tstate = wxPyBeginAllowThreads();
42778 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42779 wxPyEndAllowThreads(__tstate);
42780 if (PyErr_Occurred()) SWIG_fail;
42781 }
42782 {
42783 resultobj = wxPyMake_wxObject(result, (bool)0);
42784 }
42785 {
42786 if (temp3)
42787 delete arg3;
42788 }
42789 {
42790 if (temp4)
42791 delete arg4;
42792 }
42793 return resultobj;
42794 fail:
42795 {
42796 if (temp3)
42797 delete arg3;
42798 }
42799 {
42800 if (temp4)
42801 delete arg4;
42802 }
42803 return NULL;
42804 }
42805
42806
42807 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42808 PyObject *resultobj = 0;
42809 wxMenu *arg1 = (wxMenu *) 0 ;
42810 int arg2 ;
42811 wxString *arg3 = 0 ;
42812 wxString const &arg4_defvalue = wxPyEmptyString ;
42813 wxString *arg4 = (wxString *) &arg4_defvalue ;
42814 wxMenuItem *result = 0 ;
42815 void *argp1 = 0 ;
42816 int res1 = 0 ;
42817 int val2 ;
42818 int ecode2 = 0 ;
42819 bool temp3 = false ;
42820 bool temp4 = false ;
42821 PyObject * obj0 = 0 ;
42822 PyObject * obj1 = 0 ;
42823 PyObject * obj2 = 0 ;
42824 PyObject * obj3 = 0 ;
42825 char * kwnames[] = {
42826 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42827 };
42828
42829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42831 if (!SWIG_IsOK(res1)) {
42832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42833 }
42834 arg1 = reinterpret_cast< wxMenu * >(argp1);
42835 ecode2 = SWIG_AsVal_int(obj1, &val2);
42836 if (!SWIG_IsOK(ecode2)) {
42837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
42838 }
42839 arg2 = static_cast< int >(val2);
42840 {
42841 arg3 = wxString_in_helper(obj2);
42842 if (arg3 == NULL) SWIG_fail;
42843 temp3 = true;
42844 }
42845 if (obj3) {
42846 {
42847 arg4 = wxString_in_helper(obj3);
42848 if (arg4 == NULL) SWIG_fail;
42849 temp4 = true;
42850 }
42851 }
42852 {
42853 PyThreadState* __tstate = wxPyBeginAllowThreads();
42854 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42855 wxPyEndAllowThreads(__tstate);
42856 if (PyErr_Occurred()) SWIG_fail;
42857 }
42858 {
42859 resultobj = wxPyMake_wxObject(result, (bool)0);
42860 }
42861 {
42862 if (temp3)
42863 delete arg3;
42864 }
42865 {
42866 if (temp4)
42867 delete arg4;
42868 }
42869 return resultobj;
42870 fail:
42871 {
42872 if (temp3)
42873 delete arg3;
42874 }
42875 {
42876 if (temp4)
42877 delete arg4;
42878 }
42879 return NULL;
42880 }
42881
42882
42883 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42884 PyObject *resultobj = 0;
42885 wxMenu *arg1 = (wxMenu *) 0 ;
42886 int arg2 ;
42887 wxString *arg3 = 0 ;
42888 wxMenu *arg4 = (wxMenu *) 0 ;
42889 wxString const &arg5_defvalue = wxPyEmptyString ;
42890 wxString *arg5 = (wxString *) &arg5_defvalue ;
42891 wxMenuItem *result = 0 ;
42892 void *argp1 = 0 ;
42893 int res1 = 0 ;
42894 int val2 ;
42895 int ecode2 = 0 ;
42896 bool temp3 = false ;
42897 void *argp4 = 0 ;
42898 int res4 = 0 ;
42899 bool temp5 = false ;
42900 PyObject * obj0 = 0 ;
42901 PyObject * obj1 = 0 ;
42902 PyObject * obj2 = 0 ;
42903 PyObject * obj3 = 0 ;
42904 PyObject * obj4 = 0 ;
42905 char * kwnames[] = {
42906 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42907 };
42908
42909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42911 if (!SWIG_IsOK(res1)) {
42912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42913 }
42914 arg1 = reinterpret_cast< wxMenu * >(argp1);
42915 ecode2 = SWIG_AsVal_int(obj1, &val2);
42916 if (!SWIG_IsOK(ecode2)) {
42917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
42918 }
42919 arg2 = static_cast< int >(val2);
42920 {
42921 arg3 = wxString_in_helper(obj2);
42922 if (arg3 == NULL) SWIG_fail;
42923 temp3 = true;
42924 }
42925 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
42926 if (!SWIG_IsOK(res4)) {
42927 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
42928 }
42929 arg4 = reinterpret_cast< wxMenu * >(argp4);
42930 if (obj4) {
42931 {
42932 arg5 = wxString_in_helper(obj4);
42933 if (arg5 == NULL) SWIG_fail;
42934 temp5 = true;
42935 }
42936 }
42937 {
42938 PyThreadState* __tstate = wxPyBeginAllowThreads();
42939 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
42940 wxPyEndAllowThreads(__tstate);
42941 if (PyErr_Occurred()) SWIG_fail;
42942 }
42943 {
42944 resultobj = wxPyMake_wxObject(result, (bool)0);
42945 }
42946 {
42947 if (temp3)
42948 delete arg3;
42949 }
42950 {
42951 if (temp5)
42952 delete arg5;
42953 }
42954 return resultobj;
42955 fail:
42956 {
42957 if (temp3)
42958 delete arg3;
42959 }
42960 {
42961 if (temp5)
42962 delete arg5;
42963 }
42964 return NULL;
42965 }
42966
42967
42968 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42969 PyObject *resultobj = 0;
42970 wxMenu *arg1 = (wxMenu *) 0 ;
42971 wxMenu *arg2 = (wxMenu *) 0 ;
42972 wxString *arg3 = 0 ;
42973 wxString const &arg4_defvalue = wxPyEmptyString ;
42974 wxString *arg4 = (wxString *) &arg4_defvalue ;
42975 wxMenuItem *result = 0 ;
42976 void *argp1 = 0 ;
42977 int res1 = 0 ;
42978 void *argp2 = 0 ;
42979 int res2 = 0 ;
42980 bool temp3 = false ;
42981 bool temp4 = false ;
42982 PyObject * obj0 = 0 ;
42983 PyObject * obj1 = 0 ;
42984 PyObject * obj2 = 0 ;
42985 PyObject * obj3 = 0 ;
42986 char * kwnames[] = {
42987 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
42988 };
42989
42990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42992 if (!SWIG_IsOK(res1)) {
42993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42994 }
42995 arg1 = reinterpret_cast< wxMenu * >(argp1);
42996 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42997 if (!SWIG_IsOK(res2)) {
42998 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42999 }
43000 arg2 = reinterpret_cast< wxMenu * >(argp2);
43001 {
43002 arg3 = wxString_in_helper(obj2);
43003 if (arg3 == NULL) SWIG_fail;
43004 temp3 = true;
43005 }
43006 if (obj3) {
43007 {
43008 arg4 = wxString_in_helper(obj3);
43009 if (arg4 == NULL) SWIG_fail;
43010 temp4 = true;
43011 }
43012 }
43013 {
43014 PyThreadState* __tstate = wxPyBeginAllowThreads();
43015 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
43016 wxPyEndAllowThreads(__tstate);
43017 if (PyErr_Occurred()) SWIG_fail;
43018 }
43019 {
43020 resultobj = wxPyMake_wxObject(result, (bool)0);
43021 }
43022 {
43023 if (temp3)
43024 delete arg3;
43025 }
43026 {
43027 if (temp4)
43028 delete arg4;
43029 }
43030 return resultobj;
43031 fail:
43032 {
43033 if (temp3)
43034 delete arg3;
43035 }
43036 {
43037 if (temp4)
43038 delete arg4;
43039 }
43040 return NULL;
43041 }
43042
43043
43044 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43045 PyObject *resultobj = 0;
43046 wxMenu *arg1 = (wxMenu *) 0 ;
43047 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43048 wxMenuItem *result = 0 ;
43049 void *argp1 = 0 ;
43050 int res1 = 0 ;
43051 int res2 = 0 ;
43052 PyObject * obj0 = 0 ;
43053 PyObject * obj1 = 0 ;
43054 char * kwnames[] = {
43055 (char *) "self",(char *) "item", NULL
43056 };
43057
43058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
43059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43060 if (!SWIG_IsOK(res1)) {
43061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43062 }
43063 arg1 = reinterpret_cast< wxMenu * >(argp1);
43064 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
43065 if (!SWIG_IsOK(res2)) {
43066 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43067 }
43068 {
43069 PyThreadState* __tstate = wxPyBeginAllowThreads();
43070 result = (wxMenuItem *)(arg1)->Append(arg2);
43071 wxPyEndAllowThreads(__tstate);
43072 if (PyErr_Occurred()) SWIG_fail;
43073 }
43074 {
43075 resultobj = wxPyMake_wxObject(result, (bool)0);
43076 }
43077 return resultobj;
43078 fail:
43079 return NULL;
43080 }
43081
43082
43083 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43084 PyObject *resultobj = 0;
43085 wxMenu *arg1 = (wxMenu *) 0 ;
43086 size_t arg2 ;
43087 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
43088 wxMenuItem *result = 0 ;
43089 void *argp1 = 0 ;
43090 int res1 = 0 ;
43091 size_t val2 ;
43092 int ecode2 = 0 ;
43093 int res3 = 0 ;
43094 PyObject * obj0 = 0 ;
43095 PyObject * obj1 = 0 ;
43096 PyObject * obj2 = 0 ;
43097 char * kwnames[] = {
43098 (char *) "self",(char *) "pos",(char *) "item", NULL
43099 };
43100
43101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43103 if (!SWIG_IsOK(res1)) {
43104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43105 }
43106 arg1 = reinterpret_cast< wxMenu * >(argp1);
43107 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43108 if (!SWIG_IsOK(ecode2)) {
43109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
43110 }
43111 arg2 = static_cast< size_t >(val2);
43112 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
43113 if (!SWIG_IsOK(res3)) {
43114 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
43115 }
43116 {
43117 PyThreadState* __tstate = wxPyBeginAllowThreads();
43118 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
43119 wxPyEndAllowThreads(__tstate);
43120 if (PyErr_Occurred()) SWIG_fail;
43121 }
43122 {
43123 resultobj = wxPyMake_wxObject(result, (bool)0);
43124 }
43125 return resultobj;
43126 fail:
43127 return NULL;
43128 }
43129
43130
43131 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43132 PyObject *resultobj = 0;
43133 wxMenu *arg1 = (wxMenu *) 0 ;
43134 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43135 wxMenuItem *result = 0 ;
43136 void *argp1 = 0 ;
43137 int res1 = 0 ;
43138 int res2 = 0 ;
43139 PyObject * obj0 = 0 ;
43140 PyObject * obj1 = 0 ;
43141 char * kwnames[] = {
43142 (char *) "self",(char *) "item", NULL
43143 };
43144
43145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
43146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43147 if (!SWIG_IsOK(res1)) {
43148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43149 }
43150 arg1 = reinterpret_cast< wxMenu * >(argp1);
43151 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
43152 if (!SWIG_IsOK(res2)) {
43153 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43154 }
43155 {
43156 PyThreadState* __tstate = wxPyBeginAllowThreads();
43157 result = (wxMenuItem *)(arg1)->Prepend(arg2);
43158 wxPyEndAllowThreads(__tstate);
43159 if (PyErr_Occurred()) SWIG_fail;
43160 }
43161 {
43162 resultobj = wxPyMake_wxObject(result, (bool)0);
43163 }
43164 return resultobj;
43165 fail:
43166 return NULL;
43167 }
43168
43169
43170 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43171 PyObject *resultobj = 0;
43172 wxMenu *arg1 = (wxMenu *) 0 ;
43173 void *argp1 = 0 ;
43174 int res1 = 0 ;
43175 PyObject *swig_obj[1] ;
43176
43177 if (!args) SWIG_fail;
43178 swig_obj[0] = args;
43179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43180 if (!SWIG_IsOK(res1)) {
43181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
43182 }
43183 arg1 = reinterpret_cast< wxMenu * >(argp1);
43184 {
43185 PyThreadState* __tstate = wxPyBeginAllowThreads();
43186 (arg1)->Break();
43187 wxPyEndAllowThreads(__tstate);
43188 if (PyErr_Occurred()) SWIG_fail;
43189 }
43190 resultobj = SWIG_Py_Void();
43191 return resultobj;
43192 fail:
43193 return NULL;
43194 }
43195
43196
43197 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43198 PyObject *resultobj = 0;
43199 wxMenu *arg1 = (wxMenu *) 0 ;
43200 size_t arg2 ;
43201 int arg3 ;
43202 wxString const &arg4_defvalue = wxPyEmptyString ;
43203 wxString *arg4 = (wxString *) &arg4_defvalue ;
43204 wxString const &arg5_defvalue = wxPyEmptyString ;
43205 wxString *arg5 = (wxString *) &arg5_defvalue ;
43206 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
43207 wxMenuItem *result = 0 ;
43208 void *argp1 = 0 ;
43209 int res1 = 0 ;
43210 size_t val2 ;
43211 int ecode2 = 0 ;
43212 int val3 ;
43213 int ecode3 = 0 ;
43214 bool temp4 = false ;
43215 bool temp5 = false ;
43216 int val6 ;
43217 int ecode6 = 0 ;
43218 PyObject * obj0 = 0 ;
43219 PyObject * obj1 = 0 ;
43220 PyObject * obj2 = 0 ;
43221 PyObject * obj3 = 0 ;
43222 PyObject * obj4 = 0 ;
43223 PyObject * obj5 = 0 ;
43224 char * kwnames[] = {
43225 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
43226 };
43227
43228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
43229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43230 if (!SWIG_IsOK(res1)) {
43231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
43232 }
43233 arg1 = reinterpret_cast< wxMenu * >(argp1);
43234 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43235 if (!SWIG_IsOK(ecode2)) {
43236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
43237 }
43238 arg2 = static_cast< size_t >(val2);
43239 ecode3 = SWIG_AsVal_int(obj2, &val3);
43240 if (!SWIG_IsOK(ecode3)) {
43241 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
43242 }
43243 arg3 = static_cast< int >(val3);
43244 if (obj3) {
43245 {
43246 arg4 = wxString_in_helper(obj3);
43247 if (arg4 == NULL) SWIG_fail;
43248 temp4 = true;
43249 }
43250 }
43251 if (obj4) {
43252 {
43253 arg5 = wxString_in_helper(obj4);
43254 if (arg5 == NULL) SWIG_fail;
43255 temp5 = true;
43256 }
43257 }
43258 if (obj5) {
43259 ecode6 = SWIG_AsVal_int(obj5, &val6);
43260 if (!SWIG_IsOK(ecode6)) {
43261 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
43262 }
43263 arg6 = static_cast< wxItemKind >(val6);
43264 }
43265 {
43266 PyThreadState* __tstate = wxPyBeginAllowThreads();
43267 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
43268 wxPyEndAllowThreads(__tstate);
43269 if (PyErr_Occurred()) SWIG_fail;
43270 }
43271 {
43272 resultobj = wxPyMake_wxObject(result, (bool)0);
43273 }
43274 {
43275 if (temp4)
43276 delete arg4;
43277 }
43278 {
43279 if (temp5)
43280 delete arg5;
43281 }
43282 return resultobj;
43283 fail:
43284 {
43285 if (temp4)
43286 delete arg4;
43287 }
43288 {
43289 if (temp5)
43290 delete arg5;
43291 }
43292 return NULL;
43293 }
43294
43295
43296 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43297 PyObject *resultobj = 0;
43298 wxMenu *arg1 = (wxMenu *) 0 ;
43299 size_t arg2 ;
43300 wxMenuItem *result = 0 ;
43301 void *argp1 = 0 ;
43302 int res1 = 0 ;
43303 size_t val2 ;
43304 int ecode2 = 0 ;
43305 PyObject * obj0 = 0 ;
43306 PyObject * obj1 = 0 ;
43307 char * kwnames[] = {
43308 (char *) "self",(char *) "pos", NULL
43309 };
43310
43311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
43312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43313 if (!SWIG_IsOK(res1)) {
43314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
43315 }
43316 arg1 = reinterpret_cast< wxMenu * >(argp1);
43317 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43318 if (!SWIG_IsOK(ecode2)) {
43319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
43320 }
43321 arg2 = static_cast< size_t >(val2);
43322 {
43323 PyThreadState* __tstate = wxPyBeginAllowThreads();
43324 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
43325 wxPyEndAllowThreads(__tstate);
43326 if (PyErr_Occurred()) SWIG_fail;
43327 }
43328 {
43329 resultobj = wxPyMake_wxObject(result, (bool)0);
43330 }
43331 return resultobj;
43332 fail:
43333 return NULL;
43334 }
43335
43336
43337 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43338 PyObject *resultobj = 0;
43339 wxMenu *arg1 = (wxMenu *) 0 ;
43340 size_t arg2 ;
43341 int arg3 ;
43342 wxString *arg4 = 0 ;
43343 wxString const &arg5_defvalue = wxPyEmptyString ;
43344 wxString *arg5 = (wxString *) &arg5_defvalue ;
43345 wxMenuItem *result = 0 ;
43346 void *argp1 = 0 ;
43347 int res1 = 0 ;
43348 size_t val2 ;
43349 int ecode2 = 0 ;
43350 int val3 ;
43351 int ecode3 = 0 ;
43352 bool temp4 = false ;
43353 bool temp5 = false ;
43354 PyObject * obj0 = 0 ;
43355 PyObject * obj1 = 0 ;
43356 PyObject * obj2 = 0 ;
43357 PyObject * obj3 = 0 ;
43358 PyObject * obj4 = 0 ;
43359 char * kwnames[] = {
43360 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
43361 };
43362
43363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43365 if (!SWIG_IsOK(res1)) {
43366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43367 }
43368 arg1 = reinterpret_cast< wxMenu * >(argp1);
43369 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43370 if (!SWIG_IsOK(ecode2)) {
43371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
43372 }
43373 arg2 = static_cast< size_t >(val2);
43374 ecode3 = SWIG_AsVal_int(obj2, &val3);
43375 if (!SWIG_IsOK(ecode3)) {
43376 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
43377 }
43378 arg3 = static_cast< int >(val3);
43379 {
43380 arg4 = wxString_in_helper(obj3);
43381 if (arg4 == NULL) SWIG_fail;
43382 temp4 = true;
43383 }
43384 if (obj4) {
43385 {
43386 arg5 = wxString_in_helper(obj4);
43387 if (arg5 == NULL) SWIG_fail;
43388 temp5 = true;
43389 }
43390 }
43391 {
43392 PyThreadState* __tstate = wxPyBeginAllowThreads();
43393 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
43394 wxPyEndAllowThreads(__tstate);
43395 if (PyErr_Occurred()) SWIG_fail;
43396 }
43397 {
43398 resultobj = wxPyMake_wxObject(result, (bool)0);
43399 }
43400 {
43401 if (temp4)
43402 delete arg4;
43403 }
43404 {
43405 if (temp5)
43406 delete arg5;
43407 }
43408 return resultobj;
43409 fail:
43410 {
43411 if (temp4)
43412 delete arg4;
43413 }
43414 {
43415 if (temp5)
43416 delete arg5;
43417 }
43418 return NULL;
43419 }
43420
43421
43422 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43423 PyObject *resultobj = 0;
43424 wxMenu *arg1 = (wxMenu *) 0 ;
43425 size_t arg2 ;
43426 int arg3 ;
43427 wxString *arg4 = 0 ;
43428 wxString const &arg5_defvalue = wxPyEmptyString ;
43429 wxString *arg5 = (wxString *) &arg5_defvalue ;
43430 wxMenuItem *result = 0 ;
43431 void *argp1 = 0 ;
43432 int res1 = 0 ;
43433 size_t val2 ;
43434 int ecode2 = 0 ;
43435 int val3 ;
43436 int ecode3 = 0 ;
43437 bool temp4 = false ;
43438 bool temp5 = false ;
43439 PyObject * obj0 = 0 ;
43440 PyObject * obj1 = 0 ;
43441 PyObject * obj2 = 0 ;
43442 PyObject * obj3 = 0 ;
43443 PyObject * obj4 = 0 ;
43444 char * kwnames[] = {
43445 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
43446 };
43447
43448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43450 if (!SWIG_IsOK(res1)) {
43451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43452 }
43453 arg1 = reinterpret_cast< wxMenu * >(argp1);
43454 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43455 if (!SWIG_IsOK(ecode2)) {
43456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
43457 }
43458 arg2 = static_cast< size_t >(val2);
43459 ecode3 = SWIG_AsVal_int(obj2, &val3);
43460 if (!SWIG_IsOK(ecode3)) {
43461 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
43462 }
43463 arg3 = static_cast< int >(val3);
43464 {
43465 arg4 = wxString_in_helper(obj3);
43466 if (arg4 == NULL) SWIG_fail;
43467 temp4 = true;
43468 }
43469 if (obj4) {
43470 {
43471 arg5 = wxString_in_helper(obj4);
43472 if (arg5 == NULL) SWIG_fail;
43473 temp5 = true;
43474 }
43475 }
43476 {
43477 PyThreadState* __tstate = wxPyBeginAllowThreads();
43478 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
43479 wxPyEndAllowThreads(__tstate);
43480 if (PyErr_Occurred()) SWIG_fail;
43481 }
43482 {
43483 resultobj = wxPyMake_wxObject(result, (bool)0);
43484 }
43485 {
43486 if (temp4)
43487 delete arg4;
43488 }
43489 {
43490 if (temp5)
43491 delete arg5;
43492 }
43493 return resultobj;
43494 fail:
43495 {
43496 if (temp4)
43497 delete arg4;
43498 }
43499 {
43500 if (temp5)
43501 delete arg5;
43502 }
43503 return NULL;
43504 }
43505
43506
43507 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43508 PyObject *resultobj = 0;
43509 wxMenu *arg1 = (wxMenu *) 0 ;
43510 size_t arg2 ;
43511 int arg3 ;
43512 wxString *arg4 = 0 ;
43513 wxMenu *arg5 = (wxMenu *) 0 ;
43514 wxString const &arg6_defvalue = wxPyEmptyString ;
43515 wxString *arg6 = (wxString *) &arg6_defvalue ;
43516 wxMenuItem *result = 0 ;
43517 void *argp1 = 0 ;
43518 int res1 = 0 ;
43519 size_t val2 ;
43520 int ecode2 = 0 ;
43521 int val3 ;
43522 int ecode3 = 0 ;
43523 bool temp4 = false ;
43524 void *argp5 = 0 ;
43525 int res5 = 0 ;
43526 bool temp6 = false ;
43527 PyObject * obj0 = 0 ;
43528 PyObject * obj1 = 0 ;
43529 PyObject * obj2 = 0 ;
43530 PyObject * obj3 = 0 ;
43531 PyObject * obj4 = 0 ;
43532 PyObject * obj5 = 0 ;
43533 char * kwnames[] = {
43534 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
43535 };
43536
43537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
43538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43539 if (!SWIG_IsOK(res1)) {
43540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
43541 }
43542 arg1 = reinterpret_cast< wxMenu * >(argp1);
43543 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43544 if (!SWIG_IsOK(ecode2)) {
43545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
43546 }
43547 arg2 = static_cast< size_t >(val2);
43548 ecode3 = SWIG_AsVal_int(obj2, &val3);
43549 if (!SWIG_IsOK(ecode3)) {
43550 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
43551 }
43552 arg3 = static_cast< int >(val3);
43553 {
43554 arg4 = wxString_in_helper(obj3);
43555 if (arg4 == NULL) SWIG_fail;
43556 temp4 = true;
43557 }
43558 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
43559 if (!SWIG_IsOK(res5)) {
43560 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
43561 }
43562 arg5 = reinterpret_cast< wxMenu * >(argp5);
43563 if (obj5) {
43564 {
43565 arg6 = wxString_in_helper(obj5);
43566 if (arg6 == NULL) SWIG_fail;
43567 temp6 = true;
43568 }
43569 }
43570 {
43571 PyThreadState* __tstate = wxPyBeginAllowThreads();
43572 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
43573 wxPyEndAllowThreads(__tstate);
43574 if (PyErr_Occurred()) SWIG_fail;
43575 }
43576 {
43577 resultobj = wxPyMake_wxObject(result, (bool)0);
43578 }
43579 {
43580 if (temp4)
43581 delete arg4;
43582 }
43583 {
43584 if (temp6)
43585 delete arg6;
43586 }
43587 return resultobj;
43588 fail:
43589 {
43590 if (temp4)
43591 delete arg4;
43592 }
43593 {
43594 if (temp6)
43595 delete arg6;
43596 }
43597 return NULL;
43598 }
43599
43600
43601 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43602 PyObject *resultobj = 0;
43603 wxMenu *arg1 = (wxMenu *) 0 ;
43604 int arg2 ;
43605 wxString const &arg3_defvalue = wxPyEmptyString ;
43606 wxString *arg3 = (wxString *) &arg3_defvalue ;
43607 wxString const &arg4_defvalue = wxPyEmptyString ;
43608 wxString *arg4 = (wxString *) &arg4_defvalue ;
43609 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
43610 wxMenuItem *result = 0 ;
43611 void *argp1 = 0 ;
43612 int res1 = 0 ;
43613 int val2 ;
43614 int ecode2 = 0 ;
43615 bool temp3 = false ;
43616 bool temp4 = false ;
43617 int val5 ;
43618 int ecode5 = 0 ;
43619 PyObject * obj0 = 0 ;
43620 PyObject * obj1 = 0 ;
43621 PyObject * obj2 = 0 ;
43622 PyObject * obj3 = 0 ;
43623 PyObject * obj4 = 0 ;
43624 char * kwnames[] = {
43625 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
43626 };
43627
43628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43630 if (!SWIG_IsOK(res1)) {
43631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
43632 }
43633 arg1 = reinterpret_cast< wxMenu * >(argp1);
43634 ecode2 = SWIG_AsVal_int(obj1, &val2);
43635 if (!SWIG_IsOK(ecode2)) {
43636 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
43637 }
43638 arg2 = static_cast< int >(val2);
43639 if (obj2) {
43640 {
43641 arg3 = wxString_in_helper(obj2);
43642 if (arg3 == NULL) SWIG_fail;
43643 temp3 = true;
43644 }
43645 }
43646 if (obj3) {
43647 {
43648 arg4 = wxString_in_helper(obj3);
43649 if (arg4 == NULL) SWIG_fail;
43650 temp4 = true;
43651 }
43652 }
43653 if (obj4) {
43654 ecode5 = SWIG_AsVal_int(obj4, &val5);
43655 if (!SWIG_IsOK(ecode5)) {
43656 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
43657 }
43658 arg5 = static_cast< wxItemKind >(val5);
43659 }
43660 {
43661 PyThreadState* __tstate = wxPyBeginAllowThreads();
43662 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
43663 wxPyEndAllowThreads(__tstate);
43664 if (PyErr_Occurred()) SWIG_fail;
43665 }
43666 {
43667 resultobj = wxPyMake_wxObject(result, (bool)0);
43668 }
43669 {
43670 if (temp3)
43671 delete arg3;
43672 }
43673 {
43674 if (temp4)
43675 delete arg4;
43676 }
43677 return resultobj;
43678 fail:
43679 {
43680 if (temp3)
43681 delete arg3;
43682 }
43683 {
43684 if (temp4)
43685 delete arg4;
43686 }
43687 return NULL;
43688 }
43689
43690
43691 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43692 PyObject *resultobj = 0;
43693 wxMenu *arg1 = (wxMenu *) 0 ;
43694 wxMenuItem *result = 0 ;
43695 void *argp1 = 0 ;
43696 int res1 = 0 ;
43697 PyObject *swig_obj[1] ;
43698
43699 if (!args) SWIG_fail;
43700 swig_obj[0] = args;
43701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43702 if (!SWIG_IsOK(res1)) {
43703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
43704 }
43705 arg1 = reinterpret_cast< wxMenu * >(argp1);
43706 {
43707 PyThreadState* __tstate = wxPyBeginAllowThreads();
43708 result = (wxMenuItem *)(arg1)->PrependSeparator();
43709 wxPyEndAllowThreads(__tstate);
43710 if (PyErr_Occurred()) SWIG_fail;
43711 }
43712 {
43713 resultobj = wxPyMake_wxObject(result, (bool)0);
43714 }
43715 return resultobj;
43716 fail:
43717 return NULL;
43718 }
43719
43720
43721 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43722 PyObject *resultobj = 0;
43723 wxMenu *arg1 = (wxMenu *) 0 ;
43724 int arg2 ;
43725 wxString *arg3 = 0 ;
43726 wxString const &arg4_defvalue = wxPyEmptyString ;
43727 wxString *arg4 = (wxString *) &arg4_defvalue ;
43728 wxMenuItem *result = 0 ;
43729 void *argp1 = 0 ;
43730 int res1 = 0 ;
43731 int val2 ;
43732 int ecode2 = 0 ;
43733 bool temp3 = false ;
43734 bool temp4 = false ;
43735 PyObject * obj0 = 0 ;
43736 PyObject * obj1 = 0 ;
43737 PyObject * obj2 = 0 ;
43738 PyObject * obj3 = 0 ;
43739 char * kwnames[] = {
43740 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
43741 };
43742
43743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43745 if (!SWIG_IsOK(res1)) {
43746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43747 }
43748 arg1 = reinterpret_cast< wxMenu * >(argp1);
43749 ecode2 = SWIG_AsVal_int(obj1, &val2);
43750 if (!SWIG_IsOK(ecode2)) {
43751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
43752 }
43753 arg2 = static_cast< int >(val2);
43754 {
43755 arg3 = wxString_in_helper(obj2);
43756 if (arg3 == NULL) SWIG_fail;
43757 temp3 = true;
43758 }
43759 if (obj3) {
43760 {
43761 arg4 = wxString_in_helper(obj3);
43762 if (arg4 == NULL) SWIG_fail;
43763 temp4 = true;
43764 }
43765 }
43766 {
43767 PyThreadState* __tstate = wxPyBeginAllowThreads();
43768 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
43769 wxPyEndAllowThreads(__tstate);
43770 if (PyErr_Occurred()) SWIG_fail;
43771 }
43772 {
43773 resultobj = wxPyMake_wxObject(result, (bool)0);
43774 }
43775 {
43776 if (temp3)
43777 delete arg3;
43778 }
43779 {
43780 if (temp4)
43781 delete arg4;
43782 }
43783 return resultobj;
43784 fail:
43785 {
43786 if (temp3)
43787 delete arg3;
43788 }
43789 {
43790 if (temp4)
43791 delete arg4;
43792 }
43793 return NULL;
43794 }
43795
43796
43797 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43798 PyObject *resultobj = 0;
43799 wxMenu *arg1 = (wxMenu *) 0 ;
43800 int arg2 ;
43801 wxString *arg3 = 0 ;
43802 wxString const &arg4_defvalue = wxPyEmptyString ;
43803 wxString *arg4 = (wxString *) &arg4_defvalue ;
43804 wxMenuItem *result = 0 ;
43805 void *argp1 = 0 ;
43806 int res1 = 0 ;
43807 int val2 ;
43808 int ecode2 = 0 ;
43809 bool temp3 = false ;
43810 bool temp4 = false ;
43811 PyObject * obj0 = 0 ;
43812 PyObject * obj1 = 0 ;
43813 PyObject * obj2 = 0 ;
43814 PyObject * obj3 = 0 ;
43815 char * kwnames[] = {
43816 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
43817 };
43818
43819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43821 if (!SWIG_IsOK(res1)) {
43822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43823 }
43824 arg1 = reinterpret_cast< wxMenu * >(argp1);
43825 ecode2 = SWIG_AsVal_int(obj1, &val2);
43826 if (!SWIG_IsOK(ecode2)) {
43827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
43828 }
43829 arg2 = static_cast< int >(val2);
43830 {
43831 arg3 = wxString_in_helper(obj2);
43832 if (arg3 == NULL) SWIG_fail;
43833 temp3 = true;
43834 }
43835 if (obj3) {
43836 {
43837 arg4 = wxString_in_helper(obj3);
43838 if (arg4 == NULL) SWIG_fail;
43839 temp4 = true;
43840 }
43841 }
43842 {
43843 PyThreadState* __tstate = wxPyBeginAllowThreads();
43844 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
43845 wxPyEndAllowThreads(__tstate);
43846 if (PyErr_Occurred()) SWIG_fail;
43847 }
43848 {
43849 resultobj = wxPyMake_wxObject(result, (bool)0);
43850 }
43851 {
43852 if (temp3)
43853 delete arg3;
43854 }
43855 {
43856 if (temp4)
43857 delete arg4;
43858 }
43859 return resultobj;
43860 fail:
43861 {
43862 if (temp3)
43863 delete arg3;
43864 }
43865 {
43866 if (temp4)
43867 delete arg4;
43868 }
43869 return NULL;
43870 }
43871
43872
43873 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43874 PyObject *resultobj = 0;
43875 wxMenu *arg1 = (wxMenu *) 0 ;
43876 int arg2 ;
43877 wxString *arg3 = 0 ;
43878 wxMenu *arg4 = (wxMenu *) 0 ;
43879 wxString const &arg5_defvalue = wxPyEmptyString ;
43880 wxString *arg5 = (wxString *) &arg5_defvalue ;
43881 wxMenuItem *result = 0 ;
43882 void *argp1 = 0 ;
43883 int res1 = 0 ;
43884 int val2 ;
43885 int ecode2 = 0 ;
43886 bool temp3 = false ;
43887 void *argp4 = 0 ;
43888 int res4 = 0 ;
43889 bool temp5 = false ;
43890 PyObject * obj0 = 0 ;
43891 PyObject * obj1 = 0 ;
43892 PyObject * obj2 = 0 ;
43893 PyObject * obj3 = 0 ;
43894 PyObject * obj4 = 0 ;
43895 char * kwnames[] = {
43896 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
43897 };
43898
43899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43901 if (!SWIG_IsOK(res1)) {
43902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
43903 }
43904 arg1 = reinterpret_cast< wxMenu * >(argp1);
43905 ecode2 = SWIG_AsVal_int(obj1, &val2);
43906 if (!SWIG_IsOK(ecode2)) {
43907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
43908 }
43909 arg2 = static_cast< int >(val2);
43910 {
43911 arg3 = wxString_in_helper(obj2);
43912 if (arg3 == NULL) SWIG_fail;
43913 temp3 = true;
43914 }
43915 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
43916 if (!SWIG_IsOK(res4)) {
43917 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
43918 }
43919 arg4 = reinterpret_cast< wxMenu * >(argp4);
43920 if (obj4) {
43921 {
43922 arg5 = wxString_in_helper(obj4);
43923 if (arg5 == NULL) SWIG_fail;
43924 temp5 = true;
43925 }
43926 }
43927 {
43928 PyThreadState* __tstate = wxPyBeginAllowThreads();
43929 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
43930 wxPyEndAllowThreads(__tstate);
43931 if (PyErr_Occurred()) SWIG_fail;
43932 }
43933 {
43934 resultobj = wxPyMake_wxObject(result, (bool)0);
43935 }
43936 {
43937 if (temp3)
43938 delete arg3;
43939 }
43940 {
43941 if (temp5)
43942 delete arg5;
43943 }
43944 return resultobj;
43945 fail:
43946 {
43947 if (temp3)
43948 delete arg3;
43949 }
43950 {
43951 if (temp5)
43952 delete arg5;
43953 }
43954 return NULL;
43955 }
43956
43957
43958 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43959 PyObject *resultobj = 0;
43960 wxMenu *arg1 = (wxMenu *) 0 ;
43961 int arg2 ;
43962 wxMenuItem *result = 0 ;
43963 void *argp1 = 0 ;
43964 int res1 = 0 ;
43965 int val2 ;
43966 int ecode2 = 0 ;
43967 PyObject * obj0 = 0 ;
43968 PyObject * obj1 = 0 ;
43969 char * kwnames[] = {
43970 (char *) "self",(char *) "id", NULL
43971 };
43972
43973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
43974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43975 if (!SWIG_IsOK(res1)) {
43976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
43977 }
43978 arg1 = reinterpret_cast< wxMenu * >(argp1);
43979 ecode2 = SWIG_AsVal_int(obj1, &val2);
43980 if (!SWIG_IsOK(ecode2)) {
43981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
43982 }
43983 arg2 = static_cast< int >(val2);
43984 {
43985 PyThreadState* __tstate = wxPyBeginAllowThreads();
43986 result = (wxMenuItem *)(arg1)->Remove(arg2);
43987 wxPyEndAllowThreads(__tstate);
43988 if (PyErr_Occurred()) SWIG_fail;
43989 }
43990 {
43991 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43992 }
43993 return resultobj;
43994 fail:
43995 return NULL;
43996 }
43997
43998
43999 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44000 PyObject *resultobj = 0;
44001 wxMenu *arg1 = (wxMenu *) 0 ;
44002 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
44003 wxMenuItem *result = 0 ;
44004 void *argp1 = 0 ;
44005 int res1 = 0 ;
44006 void *argp2 = 0 ;
44007 int res2 = 0 ;
44008 PyObject * obj0 = 0 ;
44009 PyObject * obj1 = 0 ;
44010 char * kwnames[] = {
44011 (char *) "self",(char *) "item", NULL
44012 };
44013
44014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
44015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44016 if (!SWIG_IsOK(res1)) {
44017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
44018 }
44019 arg1 = reinterpret_cast< wxMenu * >(argp1);
44020 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44021 if (!SWIG_IsOK(res2)) {
44022 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
44023 }
44024 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
44025 {
44026 PyThreadState* __tstate = wxPyBeginAllowThreads();
44027 result = (wxMenuItem *)(arg1)->Remove(arg2);
44028 wxPyEndAllowThreads(__tstate);
44029 if (PyErr_Occurred()) SWIG_fail;
44030 }
44031 {
44032 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
44033 }
44034 return resultobj;
44035 fail:
44036 return NULL;
44037 }
44038
44039
44040 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44041 PyObject *resultobj = 0;
44042 wxMenu *arg1 = (wxMenu *) 0 ;
44043 int arg2 ;
44044 bool result;
44045 void *argp1 = 0 ;
44046 int res1 = 0 ;
44047 int val2 ;
44048 int ecode2 = 0 ;
44049 PyObject * obj0 = 0 ;
44050 PyObject * obj1 = 0 ;
44051 char * kwnames[] = {
44052 (char *) "self",(char *) "id", NULL
44053 };
44054
44055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44057 if (!SWIG_IsOK(res1)) {
44058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
44059 }
44060 arg1 = reinterpret_cast< wxMenu * >(argp1);
44061 ecode2 = SWIG_AsVal_int(obj1, &val2);
44062 if (!SWIG_IsOK(ecode2)) {
44063 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
44064 }
44065 arg2 = static_cast< int >(val2);
44066 {
44067 PyThreadState* __tstate = wxPyBeginAllowThreads();
44068 result = (bool)(arg1)->Delete(arg2);
44069 wxPyEndAllowThreads(__tstate);
44070 if (PyErr_Occurred()) SWIG_fail;
44071 }
44072 {
44073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44074 }
44075 return resultobj;
44076 fail:
44077 return NULL;
44078 }
44079
44080
44081 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44082 PyObject *resultobj = 0;
44083 wxMenu *arg1 = (wxMenu *) 0 ;
44084 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
44085 bool result;
44086 void *argp1 = 0 ;
44087 int res1 = 0 ;
44088 void *argp2 = 0 ;
44089 int res2 = 0 ;
44090 PyObject * obj0 = 0 ;
44091 PyObject * obj1 = 0 ;
44092 char * kwnames[] = {
44093 (char *) "self",(char *) "item", NULL
44094 };
44095
44096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
44097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44098 if (!SWIG_IsOK(res1)) {
44099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
44100 }
44101 arg1 = reinterpret_cast< wxMenu * >(argp1);
44102 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44103 if (!SWIG_IsOK(res2)) {
44104 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
44105 }
44106 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
44107 {
44108 PyThreadState* __tstate = wxPyBeginAllowThreads();
44109 result = (bool)(arg1)->Delete(arg2);
44110 wxPyEndAllowThreads(__tstate);
44111 if (PyErr_Occurred()) SWIG_fail;
44112 }
44113 {
44114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44115 }
44116 return resultobj;
44117 fail:
44118 return NULL;
44119 }
44120
44121
44122 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44123 PyObject *resultobj = 0;
44124 wxMenu *arg1 = (wxMenu *) 0 ;
44125 void *argp1 = 0 ;
44126 int res1 = 0 ;
44127 PyObject *swig_obj[1] ;
44128
44129 if (!args) SWIG_fail;
44130 swig_obj[0] = args;
44131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44132 if (!SWIG_IsOK(res1)) {
44133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
44134 }
44135 arg1 = reinterpret_cast< wxMenu * >(argp1);
44136 {
44137 PyThreadState* __tstate = wxPyBeginAllowThreads();
44138 wxMenu_Destroy(arg1);
44139 wxPyEndAllowThreads(__tstate);
44140 if (PyErr_Occurred()) SWIG_fail;
44141 }
44142 resultobj = SWIG_Py_Void();
44143 return resultobj;
44144 fail:
44145 return NULL;
44146 }
44147
44148
44149 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44150 PyObject *resultobj = 0;
44151 wxMenu *arg1 = (wxMenu *) 0 ;
44152 int arg2 ;
44153 bool result;
44154 void *argp1 = 0 ;
44155 int res1 = 0 ;
44156 int val2 ;
44157 int ecode2 = 0 ;
44158 PyObject * obj0 = 0 ;
44159 PyObject * obj1 = 0 ;
44160 char * kwnames[] = {
44161 (char *) "self",(char *) "id", NULL
44162 };
44163
44164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
44165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44166 if (!SWIG_IsOK(res1)) {
44167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
44168 }
44169 arg1 = reinterpret_cast< wxMenu * >(argp1);
44170 ecode2 = SWIG_AsVal_int(obj1, &val2);
44171 if (!SWIG_IsOK(ecode2)) {
44172 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
44173 }
44174 arg2 = static_cast< int >(val2);
44175 {
44176 PyThreadState* __tstate = wxPyBeginAllowThreads();
44177 result = (bool)(arg1)->Destroy(arg2);
44178 wxPyEndAllowThreads(__tstate);
44179 if (PyErr_Occurred()) SWIG_fail;
44180 }
44181 {
44182 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44183 }
44184 return resultobj;
44185 fail:
44186 return NULL;
44187 }
44188
44189
44190 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44191 PyObject *resultobj = 0;
44192 wxMenu *arg1 = (wxMenu *) 0 ;
44193 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
44194 bool result;
44195 void *argp1 = 0 ;
44196 int res1 = 0 ;
44197 void *argp2 = 0 ;
44198 int res2 = 0 ;
44199 PyObject * obj0 = 0 ;
44200 PyObject * obj1 = 0 ;
44201 char * kwnames[] = {
44202 (char *) "self",(char *) "item", NULL
44203 };
44204
44205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
44206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44207 if (!SWIG_IsOK(res1)) {
44208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
44209 }
44210 arg1 = reinterpret_cast< wxMenu * >(argp1);
44211 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44212 if (!SWIG_IsOK(res2)) {
44213 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
44214 }
44215 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
44216 {
44217 PyThreadState* __tstate = wxPyBeginAllowThreads();
44218 result = (bool)(arg1)->Destroy(arg2);
44219 wxPyEndAllowThreads(__tstate);
44220 if (PyErr_Occurred()) SWIG_fail;
44221 }
44222 {
44223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44224 }
44225 return resultobj;
44226 fail:
44227 return NULL;
44228 }
44229
44230
44231 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44232 PyObject *resultobj = 0;
44233 wxMenu *arg1 = (wxMenu *) 0 ;
44234 size_t result;
44235 void *argp1 = 0 ;
44236 int res1 = 0 ;
44237 PyObject *swig_obj[1] ;
44238
44239 if (!args) SWIG_fail;
44240 swig_obj[0] = args;
44241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44242 if (!SWIG_IsOK(res1)) {
44243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
44244 }
44245 arg1 = reinterpret_cast< wxMenu * >(argp1);
44246 {
44247 PyThreadState* __tstate = wxPyBeginAllowThreads();
44248 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
44249 wxPyEndAllowThreads(__tstate);
44250 if (PyErr_Occurred()) SWIG_fail;
44251 }
44252 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
44253 return resultobj;
44254 fail:
44255 return NULL;
44256 }
44257
44258
44259 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44260 PyObject *resultobj = 0;
44261 wxMenu *arg1 = (wxMenu *) 0 ;
44262 PyObject *result = 0 ;
44263 void *argp1 = 0 ;
44264 int res1 = 0 ;
44265 PyObject *swig_obj[1] ;
44266
44267 if (!args) SWIG_fail;
44268 swig_obj[0] = args;
44269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44270 if (!SWIG_IsOK(res1)) {
44271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
44272 }
44273 arg1 = reinterpret_cast< wxMenu * >(argp1);
44274 {
44275 PyThreadState* __tstate = wxPyBeginAllowThreads();
44276 result = (PyObject *)wxMenu_GetMenuItems(arg1);
44277 wxPyEndAllowThreads(__tstate);
44278 if (PyErr_Occurred()) SWIG_fail;
44279 }
44280 resultobj = result;
44281 return resultobj;
44282 fail:
44283 return NULL;
44284 }
44285
44286
44287 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44288 PyObject *resultobj = 0;
44289 wxMenu *arg1 = (wxMenu *) 0 ;
44290 wxString *arg2 = 0 ;
44291 int result;
44292 void *argp1 = 0 ;
44293 int res1 = 0 ;
44294 bool temp2 = false ;
44295 PyObject * obj0 = 0 ;
44296 PyObject * obj1 = 0 ;
44297 char * kwnames[] = {
44298 (char *) "self",(char *) "item", NULL
44299 };
44300
44301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
44302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44303 if (!SWIG_IsOK(res1)) {
44304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
44305 }
44306 arg1 = reinterpret_cast< wxMenu * >(argp1);
44307 {
44308 arg2 = wxString_in_helper(obj1);
44309 if (arg2 == NULL) SWIG_fail;
44310 temp2 = true;
44311 }
44312 {
44313 PyThreadState* __tstate = wxPyBeginAllowThreads();
44314 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
44315 wxPyEndAllowThreads(__tstate);
44316 if (PyErr_Occurred()) SWIG_fail;
44317 }
44318 resultobj = SWIG_From_int(static_cast< int >(result));
44319 {
44320 if (temp2)
44321 delete arg2;
44322 }
44323 return resultobj;
44324 fail:
44325 {
44326 if (temp2)
44327 delete arg2;
44328 }
44329 return NULL;
44330 }
44331
44332
44333 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44334 PyObject *resultobj = 0;
44335 wxMenu *arg1 = (wxMenu *) 0 ;
44336 int arg2 ;
44337 wxMenuItem *result = 0 ;
44338 void *argp1 = 0 ;
44339 int res1 = 0 ;
44340 int val2 ;
44341 int ecode2 = 0 ;
44342 PyObject * obj0 = 0 ;
44343 PyObject * obj1 = 0 ;
44344 char * kwnames[] = {
44345 (char *) "self",(char *) "id", NULL
44346 };
44347
44348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
44349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44350 if (!SWIG_IsOK(res1)) {
44351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
44352 }
44353 arg1 = reinterpret_cast< wxMenu * >(argp1);
44354 ecode2 = SWIG_AsVal_int(obj1, &val2);
44355 if (!SWIG_IsOK(ecode2)) {
44356 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
44357 }
44358 arg2 = static_cast< int >(val2);
44359 {
44360 PyThreadState* __tstate = wxPyBeginAllowThreads();
44361 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
44362 wxPyEndAllowThreads(__tstate);
44363 if (PyErr_Occurred()) SWIG_fail;
44364 }
44365 {
44366 resultobj = wxPyMake_wxObject(result, (bool)0);
44367 }
44368 return resultobj;
44369 fail:
44370 return NULL;
44371 }
44372
44373
44374 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44375 PyObject *resultobj = 0;
44376 wxMenu *arg1 = (wxMenu *) 0 ;
44377 size_t arg2 ;
44378 wxMenuItem *result = 0 ;
44379 void *argp1 = 0 ;
44380 int res1 = 0 ;
44381 size_t val2 ;
44382 int ecode2 = 0 ;
44383 PyObject * obj0 = 0 ;
44384 PyObject * obj1 = 0 ;
44385 char * kwnames[] = {
44386 (char *) "self",(char *) "position", NULL
44387 };
44388
44389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
44390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44391 if (!SWIG_IsOK(res1)) {
44392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
44393 }
44394 arg1 = reinterpret_cast< wxMenu * >(argp1);
44395 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44396 if (!SWIG_IsOK(ecode2)) {
44397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
44398 }
44399 arg2 = static_cast< size_t >(val2);
44400 {
44401 PyThreadState* __tstate = wxPyBeginAllowThreads();
44402 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
44403 wxPyEndAllowThreads(__tstate);
44404 if (PyErr_Occurred()) SWIG_fail;
44405 }
44406 {
44407 resultobj = wxPyMake_wxObject(result, (bool)0);
44408 }
44409 return resultobj;
44410 fail:
44411 return NULL;
44412 }
44413
44414
44415 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44416 PyObject *resultobj = 0;
44417 wxMenu *arg1 = (wxMenu *) 0 ;
44418 int arg2 ;
44419 bool arg3 ;
44420 void *argp1 = 0 ;
44421 int res1 = 0 ;
44422 int val2 ;
44423 int ecode2 = 0 ;
44424 bool val3 ;
44425 int ecode3 = 0 ;
44426 PyObject * obj0 = 0 ;
44427 PyObject * obj1 = 0 ;
44428 PyObject * obj2 = 0 ;
44429 char * kwnames[] = {
44430 (char *) "self",(char *) "id",(char *) "enable", NULL
44431 };
44432
44433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44435 if (!SWIG_IsOK(res1)) {
44436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
44437 }
44438 arg1 = reinterpret_cast< wxMenu * >(argp1);
44439 ecode2 = SWIG_AsVal_int(obj1, &val2);
44440 if (!SWIG_IsOK(ecode2)) {
44441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
44442 }
44443 arg2 = static_cast< int >(val2);
44444 ecode3 = SWIG_AsVal_bool(obj2, &val3);
44445 if (!SWIG_IsOK(ecode3)) {
44446 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
44447 }
44448 arg3 = static_cast< bool >(val3);
44449 {
44450 PyThreadState* __tstate = wxPyBeginAllowThreads();
44451 (arg1)->Enable(arg2,arg3);
44452 wxPyEndAllowThreads(__tstate);
44453 if (PyErr_Occurred()) SWIG_fail;
44454 }
44455 resultobj = SWIG_Py_Void();
44456 return resultobj;
44457 fail:
44458 return NULL;
44459 }
44460
44461
44462 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44463 PyObject *resultobj = 0;
44464 wxMenu *arg1 = (wxMenu *) 0 ;
44465 int arg2 ;
44466 bool result;
44467 void *argp1 = 0 ;
44468 int res1 = 0 ;
44469 int val2 ;
44470 int ecode2 = 0 ;
44471 PyObject * obj0 = 0 ;
44472 PyObject * obj1 = 0 ;
44473 char * kwnames[] = {
44474 (char *) "self",(char *) "id", NULL
44475 };
44476
44477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
44478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44479 if (!SWIG_IsOK(res1)) {
44480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
44481 }
44482 arg1 = reinterpret_cast< wxMenu * >(argp1);
44483 ecode2 = SWIG_AsVal_int(obj1, &val2);
44484 if (!SWIG_IsOK(ecode2)) {
44485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
44486 }
44487 arg2 = static_cast< int >(val2);
44488 {
44489 PyThreadState* __tstate = wxPyBeginAllowThreads();
44490 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
44491 wxPyEndAllowThreads(__tstate);
44492 if (PyErr_Occurred()) SWIG_fail;
44493 }
44494 {
44495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44496 }
44497 return resultobj;
44498 fail:
44499 return NULL;
44500 }
44501
44502
44503 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44504 PyObject *resultobj = 0;
44505 wxMenu *arg1 = (wxMenu *) 0 ;
44506 int arg2 ;
44507 bool arg3 ;
44508 void *argp1 = 0 ;
44509 int res1 = 0 ;
44510 int val2 ;
44511 int ecode2 = 0 ;
44512 bool val3 ;
44513 int ecode3 = 0 ;
44514 PyObject * obj0 = 0 ;
44515 PyObject * obj1 = 0 ;
44516 PyObject * obj2 = 0 ;
44517 char * kwnames[] = {
44518 (char *) "self",(char *) "id",(char *) "check", NULL
44519 };
44520
44521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44523 if (!SWIG_IsOK(res1)) {
44524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
44525 }
44526 arg1 = reinterpret_cast< wxMenu * >(argp1);
44527 ecode2 = SWIG_AsVal_int(obj1, &val2);
44528 if (!SWIG_IsOK(ecode2)) {
44529 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
44530 }
44531 arg2 = static_cast< int >(val2);
44532 ecode3 = SWIG_AsVal_bool(obj2, &val3);
44533 if (!SWIG_IsOK(ecode3)) {
44534 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
44535 }
44536 arg3 = static_cast< bool >(val3);
44537 {
44538 PyThreadState* __tstate = wxPyBeginAllowThreads();
44539 (arg1)->Check(arg2,arg3);
44540 wxPyEndAllowThreads(__tstate);
44541 if (PyErr_Occurred()) SWIG_fail;
44542 }
44543 resultobj = SWIG_Py_Void();
44544 return resultobj;
44545 fail:
44546 return NULL;
44547 }
44548
44549
44550 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44551 PyObject *resultobj = 0;
44552 wxMenu *arg1 = (wxMenu *) 0 ;
44553 int arg2 ;
44554 bool result;
44555 void *argp1 = 0 ;
44556 int res1 = 0 ;
44557 int val2 ;
44558 int ecode2 = 0 ;
44559 PyObject * obj0 = 0 ;
44560 PyObject * obj1 = 0 ;
44561 char * kwnames[] = {
44562 (char *) "self",(char *) "id", NULL
44563 };
44564
44565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
44566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44567 if (!SWIG_IsOK(res1)) {
44568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
44569 }
44570 arg1 = reinterpret_cast< wxMenu * >(argp1);
44571 ecode2 = SWIG_AsVal_int(obj1, &val2);
44572 if (!SWIG_IsOK(ecode2)) {
44573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
44574 }
44575 arg2 = static_cast< int >(val2);
44576 {
44577 PyThreadState* __tstate = wxPyBeginAllowThreads();
44578 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
44579 wxPyEndAllowThreads(__tstate);
44580 if (PyErr_Occurred()) SWIG_fail;
44581 }
44582 {
44583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44584 }
44585 return resultobj;
44586 fail:
44587 return NULL;
44588 }
44589
44590
44591 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44592 PyObject *resultobj = 0;
44593 wxMenu *arg1 = (wxMenu *) 0 ;
44594 int arg2 ;
44595 wxString *arg3 = 0 ;
44596 void *argp1 = 0 ;
44597 int res1 = 0 ;
44598 int val2 ;
44599 int ecode2 = 0 ;
44600 bool temp3 = false ;
44601 PyObject * obj0 = 0 ;
44602 PyObject * obj1 = 0 ;
44603 PyObject * obj2 = 0 ;
44604 char * kwnames[] = {
44605 (char *) "self",(char *) "id",(char *) "label", NULL
44606 };
44607
44608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44610 if (!SWIG_IsOK(res1)) {
44611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
44612 }
44613 arg1 = reinterpret_cast< wxMenu * >(argp1);
44614 ecode2 = SWIG_AsVal_int(obj1, &val2);
44615 if (!SWIG_IsOK(ecode2)) {
44616 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
44617 }
44618 arg2 = static_cast< int >(val2);
44619 {
44620 arg3 = wxString_in_helper(obj2);
44621 if (arg3 == NULL) SWIG_fail;
44622 temp3 = true;
44623 }
44624 {
44625 PyThreadState* __tstate = wxPyBeginAllowThreads();
44626 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
44627 wxPyEndAllowThreads(__tstate);
44628 if (PyErr_Occurred()) SWIG_fail;
44629 }
44630 resultobj = SWIG_Py_Void();
44631 {
44632 if (temp3)
44633 delete arg3;
44634 }
44635 return resultobj;
44636 fail:
44637 {
44638 if (temp3)
44639 delete arg3;
44640 }
44641 return NULL;
44642 }
44643
44644
44645 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44646 PyObject *resultobj = 0;
44647 wxMenu *arg1 = (wxMenu *) 0 ;
44648 int arg2 ;
44649 wxString result;
44650 void *argp1 = 0 ;
44651 int res1 = 0 ;
44652 int val2 ;
44653 int ecode2 = 0 ;
44654 PyObject * obj0 = 0 ;
44655 PyObject * obj1 = 0 ;
44656 char * kwnames[] = {
44657 (char *) "self",(char *) "id", NULL
44658 };
44659
44660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
44661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44662 if (!SWIG_IsOK(res1)) {
44663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
44664 }
44665 arg1 = reinterpret_cast< wxMenu * >(argp1);
44666 ecode2 = SWIG_AsVal_int(obj1, &val2);
44667 if (!SWIG_IsOK(ecode2)) {
44668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
44669 }
44670 arg2 = static_cast< int >(val2);
44671 {
44672 PyThreadState* __tstate = wxPyBeginAllowThreads();
44673 result = ((wxMenu const *)arg1)->GetLabel(arg2);
44674 wxPyEndAllowThreads(__tstate);
44675 if (PyErr_Occurred()) SWIG_fail;
44676 }
44677 {
44678 #if wxUSE_UNICODE
44679 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44680 #else
44681 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44682 #endif
44683 }
44684 return resultobj;
44685 fail:
44686 return NULL;
44687 }
44688
44689
44690 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44691 PyObject *resultobj = 0;
44692 wxMenu *arg1 = (wxMenu *) 0 ;
44693 int arg2 ;
44694 wxString *arg3 = 0 ;
44695 void *argp1 = 0 ;
44696 int res1 = 0 ;
44697 int val2 ;
44698 int ecode2 = 0 ;
44699 bool temp3 = false ;
44700 PyObject * obj0 = 0 ;
44701 PyObject * obj1 = 0 ;
44702 PyObject * obj2 = 0 ;
44703 char * kwnames[] = {
44704 (char *) "self",(char *) "id",(char *) "helpString", NULL
44705 };
44706
44707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44709 if (!SWIG_IsOK(res1)) {
44710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
44711 }
44712 arg1 = reinterpret_cast< wxMenu * >(argp1);
44713 ecode2 = SWIG_AsVal_int(obj1, &val2);
44714 if (!SWIG_IsOK(ecode2)) {
44715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
44716 }
44717 arg2 = static_cast< int >(val2);
44718 {
44719 arg3 = wxString_in_helper(obj2);
44720 if (arg3 == NULL) SWIG_fail;
44721 temp3 = true;
44722 }
44723 {
44724 PyThreadState* __tstate = wxPyBeginAllowThreads();
44725 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
44726 wxPyEndAllowThreads(__tstate);
44727 if (PyErr_Occurred()) SWIG_fail;
44728 }
44729 resultobj = SWIG_Py_Void();
44730 {
44731 if (temp3)
44732 delete arg3;
44733 }
44734 return resultobj;
44735 fail:
44736 {
44737 if (temp3)
44738 delete arg3;
44739 }
44740 return NULL;
44741 }
44742
44743
44744 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44745 PyObject *resultobj = 0;
44746 wxMenu *arg1 = (wxMenu *) 0 ;
44747 int arg2 ;
44748 wxString result;
44749 void *argp1 = 0 ;
44750 int res1 = 0 ;
44751 int val2 ;
44752 int ecode2 = 0 ;
44753 PyObject * obj0 = 0 ;
44754 PyObject * obj1 = 0 ;
44755 char * kwnames[] = {
44756 (char *) "self",(char *) "id", NULL
44757 };
44758
44759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
44760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44761 if (!SWIG_IsOK(res1)) {
44762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
44763 }
44764 arg1 = reinterpret_cast< wxMenu * >(argp1);
44765 ecode2 = SWIG_AsVal_int(obj1, &val2);
44766 if (!SWIG_IsOK(ecode2)) {
44767 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
44768 }
44769 arg2 = static_cast< int >(val2);
44770 {
44771 PyThreadState* __tstate = wxPyBeginAllowThreads();
44772 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
44773 wxPyEndAllowThreads(__tstate);
44774 if (PyErr_Occurred()) SWIG_fail;
44775 }
44776 {
44777 #if wxUSE_UNICODE
44778 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44779 #else
44780 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44781 #endif
44782 }
44783 return resultobj;
44784 fail:
44785 return NULL;
44786 }
44787
44788
44789 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44790 PyObject *resultobj = 0;
44791 wxMenu *arg1 = (wxMenu *) 0 ;
44792 wxString *arg2 = 0 ;
44793 void *argp1 = 0 ;
44794 int res1 = 0 ;
44795 bool temp2 = false ;
44796 PyObject * obj0 = 0 ;
44797 PyObject * obj1 = 0 ;
44798 char * kwnames[] = {
44799 (char *) "self",(char *) "title", NULL
44800 };
44801
44802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
44803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44804 if (!SWIG_IsOK(res1)) {
44805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
44806 }
44807 arg1 = reinterpret_cast< wxMenu * >(argp1);
44808 {
44809 arg2 = wxString_in_helper(obj1);
44810 if (arg2 == NULL) SWIG_fail;
44811 temp2 = true;
44812 }
44813 {
44814 PyThreadState* __tstate = wxPyBeginAllowThreads();
44815 (arg1)->SetTitle((wxString const &)*arg2);
44816 wxPyEndAllowThreads(__tstate);
44817 if (PyErr_Occurred()) SWIG_fail;
44818 }
44819 resultobj = SWIG_Py_Void();
44820 {
44821 if (temp2)
44822 delete arg2;
44823 }
44824 return resultobj;
44825 fail:
44826 {
44827 if (temp2)
44828 delete arg2;
44829 }
44830 return NULL;
44831 }
44832
44833
44834 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44835 PyObject *resultobj = 0;
44836 wxMenu *arg1 = (wxMenu *) 0 ;
44837 wxString result;
44838 void *argp1 = 0 ;
44839 int res1 = 0 ;
44840 PyObject *swig_obj[1] ;
44841
44842 if (!args) SWIG_fail;
44843 swig_obj[0] = args;
44844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44845 if (!SWIG_IsOK(res1)) {
44846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44847 }
44848 arg1 = reinterpret_cast< wxMenu * >(argp1);
44849 {
44850 PyThreadState* __tstate = wxPyBeginAllowThreads();
44851 result = ((wxMenu const *)arg1)->GetTitle();
44852 wxPyEndAllowThreads(__tstate);
44853 if (PyErr_Occurred()) SWIG_fail;
44854 }
44855 {
44856 #if wxUSE_UNICODE
44857 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44858 #else
44859 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44860 #endif
44861 }
44862 return resultobj;
44863 fail:
44864 return NULL;
44865 }
44866
44867
44868 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44869 PyObject *resultobj = 0;
44870 wxMenu *arg1 = (wxMenu *) 0 ;
44871 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
44872 void *argp1 = 0 ;
44873 int res1 = 0 ;
44874 void *argp2 = 0 ;
44875 int res2 = 0 ;
44876 PyObject * obj0 = 0 ;
44877 PyObject * obj1 = 0 ;
44878 char * kwnames[] = {
44879 (char *) "self",(char *) "handler", NULL
44880 };
44881
44882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
44883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44884 if (!SWIG_IsOK(res1)) {
44885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
44886 }
44887 arg1 = reinterpret_cast< wxMenu * >(argp1);
44888 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44889 if (!SWIG_IsOK(res2)) {
44890 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44891 }
44892 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44893 {
44894 PyThreadState* __tstate = wxPyBeginAllowThreads();
44895 (arg1)->SetEventHandler(arg2);
44896 wxPyEndAllowThreads(__tstate);
44897 if (PyErr_Occurred()) SWIG_fail;
44898 }
44899 resultobj = SWIG_Py_Void();
44900 return resultobj;
44901 fail:
44902 return NULL;
44903 }
44904
44905
44906 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44907 PyObject *resultobj = 0;
44908 wxMenu *arg1 = (wxMenu *) 0 ;
44909 wxEvtHandler *result = 0 ;
44910 void *argp1 = 0 ;
44911 int res1 = 0 ;
44912 PyObject *swig_obj[1] ;
44913
44914 if (!args) SWIG_fail;
44915 swig_obj[0] = args;
44916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44917 if (!SWIG_IsOK(res1)) {
44918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
44919 }
44920 arg1 = reinterpret_cast< wxMenu * >(argp1);
44921 {
44922 PyThreadState* __tstate = wxPyBeginAllowThreads();
44923 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
44924 wxPyEndAllowThreads(__tstate);
44925 if (PyErr_Occurred()) SWIG_fail;
44926 }
44927 {
44928 resultobj = wxPyMake_wxObject(result, 0);
44929 }
44930 return resultobj;
44931 fail:
44932 return NULL;
44933 }
44934
44935
44936 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44937 PyObject *resultobj = 0;
44938 wxMenu *arg1 = (wxMenu *) 0 ;
44939 wxWindow *arg2 = (wxWindow *) 0 ;
44940 void *argp1 = 0 ;
44941 int res1 = 0 ;
44942 void *argp2 = 0 ;
44943 int res2 = 0 ;
44944 PyObject * obj0 = 0 ;
44945 PyObject * obj1 = 0 ;
44946 char * kwnames[] = {
44947 (char *) "self",(char *) "win", NULL
44948 };
44949
44950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
44951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44952 if (!SWIG_IsOK(res1)) {
44953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
44954 }
44955 arg1 = reinterpret_cast< wxMenu * >(argp1);
44956 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44957 if (!SWIG_IsOK(res2)) {
44958 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
44959 }
44960 arg2 = reinterpret_cast< wxWindow * >(argp2);
44961 {
44962 PyThreadState* __tstate = wxPyBeginAllowThreads();
44963 (arg1)->SetInvokingWindow(arg2);
44964 wxPyEndAllowThreads(__tstate);
44965 if (PyErr_Occurred()) SWIG_fail;
44966 }
44967 resultobj = SWIG_Py_Void();
44968 return resultobj;
44969 fail:
44970 return NULL;
44971 }
44972
44973
44974 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44975 PyObject *resultobj = 0;
44976 wxMenu *arg1 = (wxMenu *) 0 ;
44977 wxWindow *result = 0 ;
44978 void *argp1 = 0 ;
44979 int res1 = 0 ;
44980 PyObject *swig_obj[1] ;
44981
44982 if (!args) SWIG_fail;
44983 swig_obj[0] = args;
44984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44985 if (!SWIG_IsOK(res1)) {
44986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
44987 }
44988 arg1 = reinterpret_cast< wxMenu * >(argp1);
44989 {
44990 PyThreadState* __tstate = wxPyBeginAllowThreads();
44991 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
44992 wxPyEndAllowThreads(__tstate);
44993 if (PyErr_Occurred()) SWIG_fail;
44994 }
44995 {
44996 resultobj = wxPyMake_wxObject(result, 0);
44997 }
44998 return resultobj;
44999 fail:
45000 return NULL;
45001 }
45002
45003
45004 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45005 PyObject *resultobj = 0;
45006 wxMenu *arg1 = (wxMenu *) 0 ;
45007 long result;
45008 void *argp1 = 0 ;
45009 int res1 = 0 ;
45010 PyObject *swig_obj[1] ;
45011
45012 if (!args) SWIG_fail;
45013 swig_obj[0] = args;
45014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45015 if (!SWIG_IsOK(res1)) {
45016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
45017 }
45018 arg1 = reinterpret_cast< wxMenu * >(argp1);
45019 {
45020 PyThreadState* __tstate = wxPyBeginAllowThreads();
45021 result = (long)((wxMenu const *)arg1)->GetStyle();
45022 wxPyEndAllowThreads(__tstate);
45023 if (PyErr_Occurred()) SWIG_fail;
45024 }
45025 resultobj = SWIG_From_long(static_cast< long >(result));
45026 return resultobj;
45027 fail:
45028 return NULL;
45029 }
45030
45031
45032 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45033 PyObject *resultobj = 0;
45034 wxMenu *arg1 = (wxMenu *) 0 ;
45035 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
45036 void *argp1 = 0 ;
45037 int res1 = 0 ;
45038 void *argp2 = 0 ;
45039 int res2 = 0 ;
45040 PyObject * obj0 = 0 ;
45041 PyObject * obj1 = 0 ;
45042 char * kwnames[] = {
45043 (char *) "self",(char *) "source", NULL
45044 };
45045
45046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
45047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45048 if (!SWIG_IsOK(res1)) {
45049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
45050 }
45051 arg1 = reinterpret_cast< wxMenu * >(argp1);
45052 if (obj1) {
45053 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
45054 if (!SWIG_IsOK(res2)) {
45055 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
45056 }
45057 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
45058 }
45059 {
45060 PyThreadState* __tstate = wxPyBeginAllowThreads();
45061 (arg1)->UpdateUI(arg2);
45062 wxPyEndAllowThreads(__tstate);
45063 if (PyErr_Occurred()) SWIG_fail;
45064 }
45065 resultobj = SWIG_Py_Void();
45066 return resultobj;
45067 fail:
45068 return NULL;
45069 }
45070
45071
45072 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45073 PyObject *resultobj = 0;
45074 wxMenu *arg1 = (wxMenu *) 0 ;
45075 wxMenuBar *result = 0 ;
45076 void *argp1 = 0 ;
45077 int res1 = 0 ;
45078 PyObject *swig_obj[1] ;
45079
45080 if (!args) SWIG_fail;
45081 swig_obj[0] = args;
45082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45083 if (!SWIG_IsOK(res1)) {
45084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
45085 }
45086 arg1 = reinterpret_cast< wxMenu * >(argp1);
45087 {
45088 PyThreadState* __tstate = wxPyBeginAllowThreads();
45089 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
45090 wxPyEndAllowThreads(__tstate);
45091 if (PyErr_Occurred()) SWIG_fail;
45092 }
45093 {
45094 resultobj = wxPyMake_wxObject(result, (bool)0);
45095 }
45096 return resultobj;
45097 fail:
45098 return NULL;
45099 }
45100
45101
45102 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45103 PyObject *resultobj = 0;
45104 wxMenu *arg1 = (wxMenu *) 0 ;
45105 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
45106 void *argp1 = 0 ;
45107 int res1 = 0 ;
45108 void *argp2 = 0 ;
45109 int res2 = 0 ;
45110 PyObject * obj0 = 0 ;
45111 PyObject * obj1 = 0 ;
45112 char * kwnames[] = {
45113 (char *) "self",(char *) "menubar", NULL
45114 };
45115
45116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
45117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45118 if (!SWIG_IsOK(res1)) {
45119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
45120 }
45121 arg1 = reinterpret_cast< wxMenu * >(argp1);
45122 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
45123 if (!SWIG_IsOK(res2)) {
45124 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
45125 }
45126 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
45127 {
45128 PyThreadState* __tstate = wxPyBeginAllowThreads();
45129 (arg1)->Attach(arg2);
45130 wxPyEndAllowThreads(__tstate);
45131 if (PyErr_Occurred()) SWIG_fail;
45132 }
45133 resultobj = SWIG_Py_Void();
45134 return resultobj;
45135 fail:
45136 return NULL;
45137 }
45138
45139
45140 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45141 PyObject *resultobj = 0;
45142 wxMenu *arg1 = (wxMenu *) 0 ;
45143 void *argp1 = 0 ;
45144 int res1 = 0 ;
45145 PyObject *swig_obj[1] ;
45146
45147 if (!args) SWIG_fail;
45148 swig_obj[0] = args;
45149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45150 if (!SWIG_IsOK(res1)) {
45151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
45152 }
45153 arg1 = reinterpret_cast< wxMenu * >(argp1);
45154 {
45155 PyThreadState* __tstate = wxPyBeginAllowThreads();
45156 (arg1)->Detach();
45157 wxPyEndAllowThreads(__tstate);
45158 if (PyErr_Occurred()) SWIG_fail;
45159 }
45160 resultobj = SWIG_Py_Void();
45161 return resultobj;
45162 fail:
45163 return NULL;
45164 }
45165
45166
45167 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45168 PyObject *resultobj = 0;
45169 wxMenu *arg1 = (wxMenu *) 0 ;
45170 bool result;
45171 void *argp1 = 0 ;
45172 int res1 = 0 ;
45173 PyObject *swig_obj[1] ;
45174
45175 if (!args) SWIG_fail;
45176 swig_obj[0] = args;
45177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45178 if (!SWIG_IsOK(res1)) {
45179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
45180 }
45181 arg1 = reinterpret_cast< wxMenu * >(argp1);
45182 {
45183 PyThreadState* __tstate = wxPyBeginAllowThreads();
45184 result = (bool)((wxMenu const *)arg1)->IsAttached();
45185 wxPyEndAllowThreads(__tstate);
45186 if (PyErr_Occurred()) SWIG_fail;
45187 }
45188 {
45189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45190 }
45191 return resultobj;
45192 fail:
45193 return NULL;
45194 }
45195
45196
45197 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45198 PyObject *resultobj = 0;
45199 wxMenu *arg1 = (wxMenu *) 0 ;
45200 wxMenu *arg2 = (wxMenu *) 0 ;
45201 void *argp1 = 0 ;
45202 int res1 = 0 ;
45203 void *argp2 = 0 ;
45204 int res2 = 0 ;
45205 PyObject * obj0 = 0 ;
45206 PyObject * obj1 = 0 ;
45207 char * kwnames[] = {
45208 (char *) "self",(char *) "parent", NULL
45209 };
45210
45211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
45212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45213 if (!SWIG_IsOK(res1)) {
45214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
45215 }
45216 arg1 = reinterpret_cast< wxMenu * >(argp1);
45217 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
45218 if (!SWIG_IsOK(res2)) {
45219 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
45220 }
45221 arg2 = reinterpret_cast< wxMenu * >(argp2);
45222 {
45223 PyThreadState* __tstate = wxPyBeginAllowThreads();
45224 (arg1)->SetParent(arg2);
45225 wxPyEndAllowThreads(__tstate);
45226 if (PyErr_Occurred()) SWIG_fail;
45227 }
45228 resultobj = SWIG_Py_Void();
45229 return resultobj;
45230 fail:
45231 return NULL;
45232 }
45233
45234
45235 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45236 PyObject *resultobj = 0;
45237 wxMenu *arg1 = (wxMenu *) 0 ;
45238 wxMenu *result = 0 ;
45239 void *argp1 = 0 ;
45240 int res1 = 0 ;
45241 PyObject *swig_obj[1] ;
45242
45243 if (!args) SWIG_fail;
45244 swig_obj[0] = args;
45245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45246 if (!SWIG_IsOK(res1)) {
45247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
45248 }
45249 arg1 = reinterpret_cast< wxMenu * >(argp1);
45250 {
45251 PyThreadState* __tstate = wxPyBeginAllowThreads();
45252 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
45253 wxPyEndAllowThreads(__tstate);
45254 if (PyErr_Occurred()) SWIG_fail;
45255 }
45256 {
45257 resultobj = wxPyMake_wxObject(result, 0);
45258 }
45259 return resultobj;
45260 fail:
45261 return NULL;
45262 }
45263
45264
45265 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45266 PyObject *obj;
45267 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45268 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
45269 return SWIG_Py_Void();
45270 }
45271
45272 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45273 return SWIG_Python_InitShadowInstance(args);
45274 }
45275
45276 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45277 PyObject *resultobj = 0;
45278 long arg1 = (long) 0 ;
45279 wxMenuBar *result = 0 ;
45280 long val1 ;
45281 int ecode1 = 0 ;
45282 PyObject * obj0 = 0 ;
45283 char * kwnames[] = {
45284 (char *) "style", NULL
45285 };
45286
45287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
45288 if (obj0) {
45289 ecode1 = SWIG_AsVal_long(obj0, &val1);
45290 if (!SWIG_IsOK(ecode1)) {
45291 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
45292 }
45293 arg1 = static_cast< long >(val1);
45294 }
45295 {
45296 if (!wxPyCheckForApp()) SWIG_fail;
45297 PyThreadState* __tstate = wxPyBeginAllowThreads();
45298 result = (wxMenuBar *)new wxMenuBar(arg1);
45299 wxPyEndAllowThreads(__tstate);
45300 if (PyErr_Occurred()) SWIG_fail;
45301 }
45302 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
45303 return resultobj;
45304 fail:
45305 return NULL;
45306 }
45307
45308
45309 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45310 PyObject *resultobj = 0;
45311 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45312 wxMenu *arg2 = (wxMenu *) 0 ;
45313 wxString *arg3 = 0 ;
45314 bool result;
45315 void *argp1 = 0 ;
45316 int res1 = 0 ;
45317 void *argp2 = 0 ;
45318 int res2 = 0 ;
45319 bool temp3 = false ;
45320 PyObject * obj0 = 0 ;
45321 PyObject * obj1 = 0 ;
45322 PyObject * obj2 = 0 ;
45323 char * kwnames[] = {
45324 (char *) "self",(char *) "menu",(char *) "title", NULL
45325 };
45326
45327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45329 if (!SWIG_IsOK(res1)) {
45330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45331 }
45332 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45333 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
45334 if (!SWIG_IsOK(res2)) {
45335 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
45336 }
45337 arg2 = reinterpret_cast< wxMenu * >(argp2);
45338 {
45339 arg3 = wxString_in_helper(obj2);
45340 if (arg3 == NULL) SWIG_fail;
45341 temp3 = true;
45342 }
45343 {
45344 PyThreadState* __tstate = wxPyBeginAllowThreads();
45345 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
45346 wxPyEndAllowThreads(__tstate);
45347 if (PyErr_Occurred()) SWIG_fail;
45348 }
45349 {
45350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45351 }
45352 {
45353 if (temp3)
45354 delete arg3;
45355 }
45356 return resultobj;
45357 fail:
45358 {
45359 if (temp3)
45360 delete arg3;
45361 }
45362 return NULL;
45363 }
45364
45365
45366 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45367 PyObject *resultobj = 0;
45368 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45369 size_t arg2 ;
45370 wxMenu *arg3 = (wxMenu *) 0 ;
45371 wxString *arg4 = 0 ;
45372 bool result;
45373 void *argp1 = 0 ;
45374 int res1 = 0 ;
45375 size_t val2 ;
45376 int ecode2 = 0 ;
45377 void *argp3 = 0 ;
45378 int res3 = 0 ;
45379 bool temp4 = false ;
45380 PyObject * obj0 = 0 ;
45381 PyObject * obj1 = 0 ;
45382 PyObject * obj2 = 0 ;
45383 PyObject * obj3 = 0 ;
45384 char * kwnames[] = {
45385 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
45386 };
45387
45388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
45389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45390 if (!SWIG_IsOK(res1)) {
45391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45392 }
45393 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45394 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45395 if (!SWIG_IsOK(ecode2)) {
45396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
45397 }
45398 arg2 = static_cast< size_t >(val2);
45399 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
45400 if (!SWIG_IsOK(res3)) {
45401 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
45402 }
45403 arg3 = reinterpret_cast< wxMenu * >(argp3);
45404 {
45405 arg4 = wxString_in_helper(obj3);
45406 if (arg4 == NULL) SWIG_fail;
45407 temp4 = true;
45408 }
45409 {
45410 PyThreadState* __tstate = wxPyBeginAllowThreads();
45411 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
45412 wxPyEndAllowThreads(__tstate);
45413 if (PyErr_Occurred()) SWIG_fail;
45414 }
45415 {
45416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45417 }
45418 {
45419 if (temp4)
45420 delete arg4;
45421 }
45422 return resultobj;
45423 fail:
45424 {
45425 if (temp4)
45426 delete arg4;
45427 }
45428 return NULL;
45429 }
45430
45431
45432 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45433 PyObject *resultobj = 0;
45434 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45435 size_t result;
45436 void *argp1 = 0 ;
45437 int res1 = 0 ;
45438 PyObject *swig_obj[1] ;
45439
45440 if (!args) SWIG_fail;
45441 swig_obj[0] = args;
45442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45443 if (!SWIG_IsOK(res1)) {
45444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45445 }
45446 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45447 {
45448 PyThreadState* __tstate = wxPyBeginAllowThreads();
45449 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
45450 wxPyEndAllowThreads(__tstate);
45451 if (PyErr_Occurred()) SWIG_fail;
45452 }
45453 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
45454 return resultobj;
45455 fail:
45456 return NULL;
45457 }
45458
45459
45460 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45461 PyObject *resultobj = 0;
45462 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45463 size_t arg2 ;
45464 wxMenu *result = 0 ;
45465 void *argp1 = 0 ;
45466 int res1 = 0 ;
45467 size_t val2 ;
45468 int ecode2 = 0 ;
45469 PyObject * obj0 = 0 ;
45470 PyObject * obj1 = 0 ;
45471 char * kwnames[] = {
45472 (char *) "self",(char *) "pos", NULL
45473 };
45474
45475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45477 if (!SWIG_IsOK(res1)) {
45478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45479 }
45480 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45481 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45482 if (!SWIG_IsOK(ecode2)) {
45483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
45484 }
45485 arg2 = static_cast< size_t >(val2);
45486 {
45487 PyThreadState* __tstate = wxPyBeginAllowThreads();
45488 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
45489 wxPyEndAllowThreads(__tstate);
45490 if (PyErr_Occurred()) SWIG_fail;
45491 }
45492 {
45493 resultobj = wxPyMake_wxObject(result, 0);
45494 }
45495 return resultobj;
45496 fail:
45497 return NULL;
45498 }
45499
45500
45501 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45502 PyObject *resultobj = 0;
45503 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45504 size_t arg2 ;
45505 wxMenu *arg3 = (wxMenu *) 0 ;
45506 wxString *arg4 = 0 ;
45507 wxMenu *result = 0 ;
45508 void *argp1 = 0 ;
45509 int res1 = 0 ;
45510 size_t val2 ;
45511 int ecode2 = 0 ;
45512 void *argp3 = 0 ;
45513 int res3 = 0 ;
45514 bool temp4 = false ;
45515 PyObject * obj0 = 0 ;
45516 PyObject * obj1 = 0 ;
45517 PyObject * obj2 = 0 ;
45518 PyObject * obj3 = 0 ;
45519 char * kwnames[] = {
45520 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
45521 };
45522
45523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
45524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45525 if (!SWIG_IsOK(res1)) {
45526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45527 }
45528 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45529 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45530 if (!SWIG_IsOK(ecode2)) {
45531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
45532 }
45533 arg2 = static_cast< size_t >(val2);
45534 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
45535 if (!SWIG_IsOK(res3)) {
45536 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
45537 }
45538 arg3 = reinterpret_cast< wxMenu * >(argp3);
45539 {
45540 arg4 = wxString_in_helper(obj3);
45541 if (arg4 == NULL) SWIG_fail;
45542 temp4 = true;
45543 }
45544 {
45545 PyThreadState* __tstate = wxPyBeginAllowThreads();
45546 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
45547 wxPyEndAllowThreads(__tstate);
45548 if (PyErr_Occurred()) SWIG_fail;
45549 }
45550 {
45551 resultobj = wxPyMake_wxObject(result, 0);
45552 }
45553 {
45554 if (temp4)
45555 delete arg4;
45556 }
45557 return resultobj;
45558 fail:
45559 {
45560 if (temp4)
45561 delete arg4;
45562 }
45563 return NULL;
45564 }
45565
45566
45567 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45568 PyObject *resultobj = 0;
45569 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45570 size_t arg2 ;
45571 wxMenu *result = 0 ;
45572 void *argp1 = 0 ;
45573 int res1 = 0 ;
45574 size_t val2 ;
45575 int ecode2 = 0 ;
45576 PyObject * obj0 = 0 ;
45577 PyObject * obj1 = 0 ;
45578 char * kwnames[] = {
45579 (char *) "self",(char *) "pos", NULL
45580 };
45581
45582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
45583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45584 if (!SWIG_IsOK(res1)) {
45585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45586 }
45587 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45588 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45589 if (!SWIG_IsOK(ecode2)) {
45590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
45591 }
45592 arg2 = static_cast< size_t >(val2);
45593 {
45594 PyThreadState* __tstate = wxPyBeginAllowThreads();
45595 result = (wxMenu *)(arg1)->Remove(arg2);
45596 wxPyEndAllowThreads(__tstate);
45597 if (PyErr_Occurred()) SWIG_fail;
45598 }
45599 {
45600 resultobj = wxPyMake_wxObject(result, 0);
45601 }
45602 return resultobj;
45603 fail:
45604 return NULL;
45605 }
45606
45607
45608 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45609 PyObject *resultobj = 0;
45610 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45611 size_t arg2 ;
45612 bool arg3 ;
45613 void *argp1 = 0 ;
45614 int res1 = 0 ;
45615 size_t val2 ;
45616 int ecode2 = 0 ;
45617 bool val3 ;
45618 int ecode3 = 0 ;
45619 PyObject * obj0 = 0 ;
45620 PyObject * obj1 = 0 ;
45621 PyObject * obj2 = 0 ;
45622 char * kwnames[] = {
45623 (char *) "self",(char *) "pos",(char *) "enable", NULL
45624 };
45625
45626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45628 if (!SWIG_IsOK(res1)) {
45629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45630 }
45631 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45632 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45633 if (!SWIG_IsOK(ecode2)) {
45634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
45635 }
45636 arg2 = static_cast< size_t >(val2);
45637 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45638 if (!SWIG_IsOK(ecode3)) {
45639 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
45640 }
45641 arg3 = static_cast< bool >(val3);
45642 {
45643 PyThreadState* __tstate = wxPyBeginAllowThreads();
45644 (arg1)->EnableTop(arg2,arg3);
45645 wxPyEndAllowThreads(__tstate);
45646 if (PyErr_Occurred()) SWIG_fail;
45647 }
45648 resultobj = SWIG_Py_Void();
45649 return resultobj;
45650 fail:
45651 return NULL;
45652 }
45653
45654
45655 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45656 PyObject *resultobj = 0;
45657 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45658 size_t arg2 ;
45659 bool result;
45660 void *argp1 = 0 ;
45661 int res1 = 0 ;
45662 size_t val2 ;
45663 int ecode2 = 0 ;
45664 PyObject * obj0 = 0 ;
45665 PyObject * obj1 = 0 ;
45666 char * kwnames[] = {
45667 (char *) "self",(char *) "pos", NULL
45668 };
45669
45670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
45671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45672 if (!SWIG_IsOK(res1)) {
45673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45674 }
45675 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45676 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45677 if (!SWIG_IsOK(ecode2)) {
45678 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
45679 }
45680 arg2 = static_cast< size_t >(val2);
45681 {
45682 PyThreadState* __tstate = wxPyBeginAllowThreads();
45683 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
45684 wxPyEndAllowThreads(__tstate);
45685 if (PyErr_Occurred()) SWIG_fail;
45686 }
45687 {
45688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45689 }
45690 return resultobj;
45691 fail:
45692 return NULL;
45693 }
45694
45695
45696 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45697 PyObject *resultobj = 0;
45698 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45699 size_t arg2 ;
45700 wxString *arg3 = 0 ;
45701 void *argp1 = 0 ;
45702 int res1 = 0 ;
45703 size_t val2 ;
45704 int ecode2 = 0 ;
45705 bool temp3 = false ;
45706 PyObject * obj0 = 0 ;
45707 PyObject * obj1 = 0 ;
45708 PyObject * obj2 = 0 ;
45709 char * kwnames[] = {
45710 (char *) "self",(char *) "pos",(char *) "label", NULL
45711 };
45712
45713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45715 if (!SWIG_IsOK(res1)) {
45716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45717 }
45718 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45719 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45720 if (!SWIG_IsOK(ecode2)) {
45721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
45722 }
45723 arg2 = static_cast< size_t >(val2);
45724 {
45725 arg3 = wxString_in_helper(obj2);
45726 if (arg3 == NULL) SWIG_fail;
45727 temp3 = true;
45728 }
45729 {
45730 PyThreadState* __tstate = wxPyBeginAllowThreads();
45731 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
45732 wxPyEndAllowThreads(__tstate);
45733 if (PyErr_Occurred()) SWIG_fail;
45734 }
45735 resultobj = SWIG_Py_Void();
45736 {
45737 if (temp3)
45738 delete arg3;
45739 }
45740 return resultobj;
45741 fail:
45742 {
45743 if (temp3)
45744 delete arg3;
45745 }
45746 return NULL;
45747 }
45748
45749
45750 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45751 PyObject *resultobj = 0;
45752 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45753 size_t arg2 ;
45754 wxString result;
45755 void *argp1 = 0 ;
45756 int res1 = 0 ;
45757 size_t val2 ;
45758 int ecode2 = 0 ;
45759 PyObject * obj0 = 0 ;
45760 PyObject * obj1 = 0 ;
45761 char * kwnames[] = {
45762 (char *) "self",(char *) "pos", NULL
45763 };
45764
45765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
45766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45767 if (!SWIG_IsOK(res1)) {
45768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45769 }
45770 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45771 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45772 if (!SWIG_IsOK(ecode2)) {
45773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
45774 }
45775 arg2 = static_cast< size_t >(val2);
45776 {
45777 PyThreadState* __tstate = wxPyBeginAllowThreads();
45778 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
45779 wxPyEndAllowThreads(__tstate);
45780 if (PyErr_Occurred()) SWIG_fail;
45781 }
45782 {
45783 #if wxUSE_UNICODE
45784 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45785 #else
45786 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45787 #endif
45788 }
45789 return resultobj;
45790 fail:
45791 return NULL;
45792 }
45793
45794
45795 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45796 PyObject *resultobj = 0;
45797 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45798 wxString *arg2 = 0 ;
45799 wxString *arg3 = 0 ;
45800 int result;
45801 void *argp1 = 0 ;
45802 int res1 = 0 ;
45803 bool temp2 = false ;
45804 bool temp3 = false ;
45805 PyObject * obj0 = 0 ;
45806 PyObject * obj1 = 0 ;
45807 PyObject * obj2 = 0 ;
45808 char * kwnames[] = {
45809 (char *) "self",(char *) "menu",(char *) "item", NULL
45810 };
45811
45812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45814 if (!SWIG_IsOK(res1)) {
45815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45816 }
45817 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45818 {
45819 arg2 = wxString_in_helper(obj1);
45820 if (arg2 == NULL) SWIG_fail;
45821 temp2 = true;
45822 }
45823 {
45824 arg3 = wxString_in_helper(obj2);
45825 if (arg3 == NULL) SWIG_fail;
45826 temp3 = true;
45827 }
45828 {
45829 PyThreadState* __tstate = wxPyBeginAllowThreads();
45830 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
45831 wxPyEndAllowThreads(__tstate);
45832 if (PyErr_Occurred()) SWIG_fail;
45833 }
45834 resultobj = SWIG_From_int(static_cast< int >(result));
45835 {
45836 if (temp2)
45837 delete arg2;
45838 }
45839 {
45840 if (temp3)
45841 delete arg3;
45842 }
45843 return resultobj;
45844 fail:
45845 {
45846 if (temp2)
45847 delete arg2;
45848 }
45849 {
45850 if (temp3)
45851 delete arg3;
45852 }
45853 return NULL;
45854 }
45855
45856
45857 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45858 PyObject *resultobj = 0;
45859 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45860 int arg2 ;
45861 wxMenuItem *result = 0 ;
45862 void *argp1 = 0 ;
45863 int res1 = 0 ;
45864 int val2 ;
45865 int ecode2 = 0 ;
45866 PyObject * obj0 = 0 ;
45867 PyObject * obj1 = 0 ;
45868 char * kwnames[] = {
45869 (char *) "self",(char *) "id", NULL
45870 };
45871
45872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
45873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45874 if (!SWIG_IsOK(res1)) {
45875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45876 }
45877 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45878 ecode2 = SWIG_AsVal_int(obj1, &val2);
45879 if (!SWIG_IsOK(ecode2)) {
45880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
45881 }
45882 arg2 = static_cast< int >(val2);
45883 {
45884 PyThreadState* __tstate = wxPyBeginAllowThreads();
45885 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
45886 wxPyEndAllowThreads(__tstate);
45887 if (PyErr_Occurred()) SWIG_fail;
45888 }
45889 {
45890 resultobj = wxPyMake_wxObject(result, (bool)0);
45891 }
45892 return resultobj;
45893 fail:
45894 return NULL;
45895 }
45896
45897
45898 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45899 PyObject *resultobj = 0;
45900 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45901 wxString *arg2 = 0 ;
45902 int result;
45903 void *argp1 = 0 ;
45904 int res1 = 0 ;
45905 bool temp2 = false ;
45906 PyObject * obj0 = 0 ;
45907 PyObject * obj1 = 0 ;
45908 char * kwnames[] = {
45909 (char *) "self",(char *) "title", NULL
45910 };
45911
45912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45914 if (!SWIG_IsOK(res1)) {
45915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45916 }
45917 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45918 {
45919 arg2 = wxString_in_helper(obj1);
45920 if (arg2 == NULL) SWIG_fail;
45921 temp2 = true;
45922 }
45923 {
45924 PyThreadState* __tstate = wxPyBeginAllowThreads();
45925 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
45926 wxPyEndAllowThreads(__tstate);
45927 if (PyErr_Occurred()) SWIG_fail;
45928 }
45929 resultobj = SWIG_From_int(static_cast< int >(result));
45930 {
45931 if (temp2)
45932 delete arg2;
45933 }
45934 return resultobj;
45935 fail:
45936 {
45937 if (temp2)
45938 delete arg2;
45939 }
45940 return NULL;
45941 }
45942
45943
45944 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45945 PyObject *resultobj = 0;
45946 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45947 int arg2 ;
45948 bool arg3 ;
45949 void *argp1 = 0 ;
45950 int res1 = 0 ;
45951 int val2 ;
45952 int ecode2 = 0 ;
45953 bool val3 ;
45954 int ecode3 = 0 ;
45955 PyObject * obj0 = 0 ;
45956 PyObject * obj1 = 0 ;
45957 PyObject * obj2 = 0 ;
45958 char * kwnames[] = {
45959 (char *) "self",(char *) "id",(char *) "enable", NULL
45960 };
45961
45962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45964 if (!SWIG_IsOK(res1)) {
45965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45966 }
45967 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45968 ecode2 = SWIG_AsVal_int(obj1, &val2);
45969 if (!SWIG_IsOK(ecode2)) {
45970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
45971 }
45972 arg2 = static_cast< int >(val2);
45973 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45974 if (!SWIG_IsOK(ecode3)) {
45975 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
45976 }
45977 arg3 = static_cast< bool >(val3);
45978 {
45979 PyThreadState* __tstate = wxPyBeginAllowThreads();
45980 (arg1)->Enable(arg2,arg3);
45981 wxPyEndAllowThreads(__tstate);
45982 if (PyErr_Occurred()) SWIG_fail;
45983 }
45984 resultobj = SWIG_Py_Void();
45985 return resultobj;
45986 fail:
45987 return NULL;
45988 }
45989
45990
45991 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45992 PyObject *resultobj = 0;
45993 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45994 int arg2 ;
45995 bool arg3 ;
45996 void *argp1 = 0 ;
45997 int res1 = 0 ;
45998 int val2 ;
45999 int ecode2 = 0 ;
46000 bool val3 ;
46001 int ecode3 = 0 ;
46002 PyObject * obj0 = 0 ;
46003 PyObject * obj1 = 0 ;
46004 PyObject * obj2 = 0 ;
46005 char * kwnames[] = {
46006 (char *) "self",(char *) "id",(char *) "check", NULL
46007 };
46008
46009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46011 if (!SWIG_IsOK(res1)) {
46012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
46013 }
46014 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46015 ecode2 = SWIG_AsVal_int(obj1, &val2);
46016 if (!SWIG_IsOK(ecode2)) {
46017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
46018 }
46019 arg2 = static_cast< int >(val2);
46020 ecode3 = SWIG_AsVal_bool(obj2, &val3);
46021 if (!SWIG_IsOK(ecode3)) {
46022 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
46023 }
46024 arg3 = static_cast< bool >(val3);
46025 {
46026 PyThreadState* __tstate = wxPyBeginAllowThreads();
46027 (arg1)->Check(arg2,arg3);
46028 wxPyEndAllowThreads(__tstate);
46029 if (PyErr_Occurred()) SWIG_fail;
46030 }
46031 resultobj = SWIG_Py_Void();
46032 return resultobj;
46033 fail:
46034 return NULL;
46035 }
46036
46037
46038 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46039 PyObject *resultobj = 0;
46040 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46041 int arg2 ;
46042 bool result;
46043 void *argp1 = 0 ;
46044 int res1 = 0 ;
46045 int val2 ;
46046 int ecode2 = 0 ;
46047 PyObject * obj0 = 0 ;
46048 PyObject * obj1 = 0 ;
46049 char * kwnames[] = {
46050 (char *) "self",(char *) "id", NULL
46051 };
46052
46053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
46054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46055 if (!SWIG_IsOK(res1)) {
46056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
46057 }
46058 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46059 ecode2 = SWIG_AsVal_int(obj1, &val2);
46060 if (!SWIG_IsOK(ecode2)) {
46061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
46062 }
46063 arg2 = static_cast< int >(val2);
46064 {
46065 PyThreadState* __tstate = wxPyBeginAllowThreads();
46066 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
46067 wxPyEndAllowThreads(__tstate);
46068 if (PyErr_Occurred()) SWIG_fail;
46069 }
46070 {
46071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46072 }
46073 return resultobj;
46074 fail:
46075 return NULL;
46076 }
46077
46078
46079 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46080 PyObject *resultobj = 0;
46081 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46082 int arg2 ;
46083 bool result;
46084 void *argp1 = 0 ;
46085 int res1 = 0 ;
46086 int val2 ;
46087 int ecode2 = 0 ;
46088 PyObject * obj0 = 0 ;
46089 PyObject * obj1 = 0 ;
46090 char * kwnames[] = {
46091 (char *) "self",(char *) "id", NULL
46092 };
46093
46094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
46095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46096 if (!SWIG_IsOK(res1)) {
46097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
46098 }
46099 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46100 ecode2 = SWIG_AsVal_int(obj1, &val2);
46101 if (!SWIG_IsOK(ecode2)) {
46102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
46103 }
46104 arg2 = static_cast< int >(val2);
46105 {
46106 PyThreadState* __tstate = wxPyBeginAllowThreads();
46107 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
46108 wxPyEndAllowThreads(__tstate);
46109 if (PyErr_Occurred()) SWIG_fail;
46110 }
46111 {
46112 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46113 }
46114 return resultobj;
46115 fail:
46116 return NULL;
46117 }
46118
46119
46120 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46121 PyObject *resultobj = 0;
46122 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46123 int arg2 ;
46124 wxString *arg3 = 0 ;
46125 void *argp1 = 0 ;
46126 int res1 = 0 ;
46127 int val2 ;
46128 int ecode2 = 0 ;
46129 bool temp3 = false ;
46130 PyObject * obj0 = 0 ;
46131 PyObject * obj1 = 0 ;
46132 PyObject * obj2 = 0 ;
46133 char * kwnames[] = {
46134 (char *) "self",(char *) "id",(char *) "label", NULL
46135 };
46136
46137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46139 if (!SWIG_IsOK(res1)) {
46140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
46141 }
46142 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46143 ecode2 = SWIG_AsVal_int(obj1, &val2);
46144 if (!SWIG_IsOK(ecode2)) {
46145 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
46146 }
46147 arg2 = static_cast< int >(val2);
46148 {
46149 arg3 = wxString_in_helper(obj2);
46150 if (arg3 == NULL) SWIG_fail;
46151 temp3 = true;
46152 }
46153 {
46154 PyThreadState* __tstate = wxPyBeginAllowThreads();
46155 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
46156 wxPyEndAllowThreads(__tstate);
46157 if (PyErr_Occurred()) SWIG_fail;
46158 }
46159 resultobj = SWIG_Py_Void();
46160 {
46161 if (temp3)
46162 delete arg3;
46163 }
46164 return resultobj;
46165 fail:
46166 {
46167 if (temp3)
46168 delete arg3;
46169 }
46170 return NULL;
46171 }
46172
46173
46174 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46175 PyObject *resultobj = 0;
46176 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46177 int arg2 ;
46178 wxString result;
46179 void *argp1 = 0 ;
46180 int res1 = 0 ;
46181 int val2 ;
46182 int ecode2 = 0 ;
46183 PyObject * obj0 = 0 ;
46184 PyObject * obj1 = 0 ;
46185 char * kwnames[] = {
46186 (char *) "self",(char *) "id", NULL
46187 };
46188
46189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
46190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46191 if (!SWIG_IsOK(res1)) {
46192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
46193 }
46194 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46195 ecode2 = SWIG_AsVal_int(obj1, &val2);
46196 if (!SWIG_IsOK(ecode2)) {
46197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
46198 }
46199 arg2 = static_cast< int >(val2);
46200 {
46201 PyThreadState* __tstate = wxPyBeginAllowThreads();
46202 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
46203 wxPyEndAllowThreads(__tstate);
46204 if (PyErr_Occurred()) SWIG_fail;
46205 }
46206 {
46207 #if wxUSE_UNICODE
46208 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46209 #else
46210 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46211 #endif
46212 }
46213 return resultobj;
46214 fail:
46215 return NULL;
46216 }
46217
46218
46219 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46220 PyObject *resultobj = 0;
46221 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46222 int arg2 ;
46223 wxString *arg3 = 0 ;
46224 void *argp1 = 0 ;
46225 int res1 = 0 ;
46226 int val2 ;
46227 int ecode2 = 0 ;
46228 bool temp3 = false ;
46229 PyObject * obj0 = 0 ;
46230 PyObject * obj1 = 0 ;
46231 PyObject * obj2 = 0 ;
46232 char * kwnames[] = {
46233 (char *) "self",(char *) "id",(char *) "helpString", NULL
46234 };
46235
46236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46238 if (!SWIG_IsOK(res1)) {
46239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
46240 }
46241 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46242 ecode2 = SWIG_AsVal_int(obj1, &val2);
46243 if (!SWIG_IsOK(ecode2)) {
46244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
46245 }
46246 arg2 = static_cast< int >(val2);
46247 {
46248 arg3 = wxString_in_helper(obj2);
46249 if (arg3 == NULL) SWIG_fail;
46250 temp3 = true;
46251 }
46252 {
46253 PyThreadState* __tstate = wxPyBeginAllowThreads();
46254 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
46255 wxPyEndAllowThreads(__tstate);
46256 if (PyErr_Occurred()) SWIG_fail;
46257 }
46258 resultobj = SWIG_Py_Void();
46259 {
46260 if (temp3)
46261 delete arg3;
46262 }
46263 return resultobj;
46264 fail:
46265 {
46266 if (temp3)
46267 delete arg3;
46268 }
46269 return NULL;
46270 }
46271
46272
46273 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46274 PyObject *resultobj = 0;
46275 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46276 int arg2 ;
46277 wxString result;
46278 void *argp1 = 0 ;
46279 int res1 = 0 ;
46280 int val2 ;
46281 int ecode2 = 0 ;
46282 PyObject * obj0 = 0 ;
46283 PyObject * obj1 = 0 ;
46284 char * kwnames[] = {
46285 (char *) "self",(char *) "id", NULL
46286 };
46287
46288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
46289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46290 if (!SWIG_IsOK(res1)) {
46291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
46292 }
46293 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46294 ecode2 = SWIG_AsVal_int(obj1, &val2);
46295 if (!SWIG_IsOK(ecode2)) {
46296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
46297 }
46298 arg2 = static_cast< int >(val2);
46299 {
46300 PyThreadState* __tstate = wxPyBeginAllowThreads();
46301 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
46302 wxPyEndAllowThreads(__tstate);
46303 if (PyErr_Occurred()) SWIG_fail;
46304 }
46305 {
46306 #if wxUSE_UNICODE
46307 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46308 #else
46309 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46310 #endif
46311 }
46312 return resultobj;
46313 fail:
46314 return NULL;
46315 }
46316
46317
46318 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46319 PyObject *resultobj = 0;
46320 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46321 wxFrame *result = 0 ;
46322 void *argp1 = 0 ;
46323 int res1 = 0 ;
46324 PyObject *swig_obj[1] ;
46325
46326 if (!args) SWIG_fail;
46327 swig_obj[0] = args;
46328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46329 if (!SWIG_IsOK(res1)) {
46330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
46331 }
46332 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46333 {
46334 PyThreadState* __tstate = wxPyBeginAllowThreads();
46335 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
46336 wxPyEndAllowThreads(__tstate);
46337 if (PyErr_Occurred()) SWIG_fail;
46338 }
46339 {
46340 resultobj = wxPyMake_wxObject(result, (bool)0);
46341 }
46342 return resultobj;
46343 fail:
46344 return NULL;
46345 }
46346
46347
46348 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46349 PyObject *resultobj = 0;
46350 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46351 bool result;
46352 void *argp1 = 0 ;
46353 int res1 = 0 ;
46354 PyObject *swig_obj[1] ;
46355
46356 if (!args) SWIG_fail;
46357 swig_obj[0] = args;
46358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46359 if (!SWIG_IsOK(res1)) {
46360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
46361 }
46362 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46363 {
46364 PyThreadState* __tstate = wxPyBeginAllowThreads();
46365 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
46366 wxPyEndAllowThreads(__tstate);
46367 if (PyErr_Occurred()) SWIG_fail;
46368 }
46369 {
46370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46371 }
46372 return resultobj;
46373 fail:
46374 return NULL;
46375 }
46376
46377
46378 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46379 PyObject *resultobj = 0;
46380 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46381 wxFrame *arg2 = (wxFrame *) 0 ;
46382 void *argp1 = 0 ;
46383 int res1 = 0 ;
46384 void *argp2 = 0 ;
46385 int res2 = 0 ;
46386 PyObject * obj0 = 0 ;
46387 PyObject * obj1 = 0 ;
46388 char * kwnames[] = {
46389 (char *) "self",(char *) "frame", NULL
46390 };
46391
46392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
46393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46394 if (!SWIG_IsOK(res1)) {
46395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
46396 }
46397 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46398 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
46399 if (!SWIG_IsOK(res2)) {
46400 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
46401 }
46402 arg2 = reinterpret_cast< wxFrame * >(argp2);
46403 {
46404 PyThreadState* __tstate = wxPyBeginAllowThreads();
46405 (arg1)->Attach(arg2);
46406 wxPyEndAllowThreads(__tstate);
46407 if (PyErr_Occurred()) SWIG_fail;
46408 }
46409 resultobj = SWIG_Py_Void();
46410 return resultobj;
46411 fail:
46412 return NULL;
46413 }
46414
46415
46416 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46417 PyObject *resultobj = 0;
46418 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46419 void *argp1 = 0 ;
46420 int res1 = 0 ;
46421 PyObject *swig_obj[1] ;
46422
46423 if (!args) SWIG_fail;
46424 swig_obj[0] = args;
46425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46426 if (!SWIG_IsOK(res1)) {
46427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
46428 }
46429 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46430 {
46431 PyThreadState* __tstate = wxPyBeginAllowThreads();
46432 (arg1)->Detach();
46433 wxPyEndAllowThreads(__tstate);
46434 if (PyErr_Occurred()) SWIG_fail;
46435 }
46436 resultobj = SWIG_Py_Void();
46437 return resultobj;
46438 fail:
46439 return NULL;
46440 }
46441
46442
46443 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46444 PyObject *resultobj = 0;
46445 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46446 void *argp1 = 0 ;
46447 int res1 = 0 ;
46448 PyObject *swig_obj[1] ;
46449
46450 if (!args) SWIG_fail;
46451 swig_obj[0] = args;
46452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46453 if (!SWIG_IsOK(res1)) {
46454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
46455 }
46456 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46457 {
46458 PyThreadState* __tstate = wxPyBeginAllowThreads();
46459 (arg1)->UpdateMenus();
46460 wxPyEndAllowThreads(__tstate);
46461 if (PyErr_Occurred()) SWIG_fail;
46462 }
46463 resultobj = SWIG_Py_Void();
46464 return resultobj;
46465 fail:
46466 return NULL;
46467 }
46468
46469
46470 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46471 PyObject *resultobj = 0;
46472 bool arg1 ;
46473 bool val1 ;
46474 int ecode1 = 0 ;
46475 PyObject * obj0 = 0 ;
46476 char * kwnames[] = {
46477 (char *) "enable", NULL
46478 };
46479
46480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
46481 ecode1 = SWIG_AsVal_bool(obj0, &val1);
46482 if (!SWIG_IsOK(ecode1)) {
46483 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
46484 }
46485 arg1 = static_cast< bool >(val1);
46486 {
46487 PyThreadState* __tstate = wxPyBeginAllowThreads();
46488 wxMenuBar::SetAutoWindowMenu(arg1);
46489 wxPyEndAllowThreads(__tstate);
46490 if (PyErr_Occurred()) SWIG_fail;
46491 }
46492 resultobj = SWIG_Py_Void();
46493 return resultobj;
46494 fail:
46495 return NULL;
46496 }
46497
46498
46499 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46500 PyObject *resultobj = 0;
46501 bool result;
46502
46503 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
46504 {
46505 PyThreadState* __tstate = wxPyBeginAllowThreads();
46506 result = (bool)wxMenuBar::GetAutoWindowMenu();
46507 wxPyEndAllowThreads(__tstate);
46508 if (PyErr_Occurred()) SWIG_fail;
46509 }
46510 {
46511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46512 }
46513 return resultobj;
46514 fail:
46515 return NULL;
46516 }
46517
46518
46519 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46520 PyObject *obj;
46521 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46522 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
46523 return SWIG_Py_Void();
46524 }
46525
46526 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46527 return SWIG_Python_InitShadowInstance(args);
46528 }
46529
46530 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46531 PyObject *resultobj = 0;
46532 wxMenu *arg1 = (wxMenu *) NULL ;
46533 int arg2 = (int) wxID_SEPARATOR ;
46534 wxString const &arg3_defvalue = wxPyEmptyString ;
46535 wxString *arg3 = (wxString *) &arg3_defvalue ;
46536 wxString const &arg4_defvalue = wxPyEmptyString ;
46537 wxString *arg4 = (wxString *) &arg4_defvalue ;
46538 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
46539 wxMenu *arg6 = (wxMenu *) NULL ;
46540 wxMenuItem *result = 0 ;
46541 void *argp1 = 0 ;
46542 int res1 = 0 ;
46543 int val2 ;
46544 int ecode2 = 0 ;
46545 bool temp3 = false ;
46546 bool temp4 = false ;
46547 int val5 ;
46548 int ecode5 = 0 ;
46549 void *argp6 = 0 ;
46550 int res6 = 0 ;
46551 PyObject * obj0 = 0 ;
46552 PyObject * obj1 = 0 ;
46553 PyObject * obj2 = 0 ;
46554 PyObject * obj3 = 0 ;
46555 PyObject * obj4 = 0 ;
46556 PyObject * obj5 = 0 ;
46557 char * kwnames[] = {
46558 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
46559 };
46560
46561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46562 if (obj0) {
46563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
46564 if (!SWIG_IsOK(res1)) {
46565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
46566 }
46567 arg1 = reinterpret_cast< wxMenu * >(argp1);
46568 }
46569 if (obj1) {
46570 ecode2 = SWIG_AsVal_int(obj1, &val2);
46571 if (!SWIG_IsOK(ecode2)) {
46572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
46573 }
46574 arg2 = static_cast< int >(val2);
46575 }
46576 if (obj2) {
46577 {
46578 arg3 = wxString_in_helper(obj2);
46579 if (arg3 == NULL) SWIG_fail;
46580 temp3 = true;
46581 }
46582 }
46583 if (obj3) {
46584 {
46585 arg4 = wxString_in_helper(obj3);
46586 if (arg4 == NULL) SWIG_fail;
46587 temp4 = true;
46588 }
46589 }
46590 if (obj4) {
46591 ecode5 = SWIG_AsVal_int(obj4, &val5);
46592 if (!SWIG_IsOK(ecode5)) {
46593 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
46594 }
46595 arg5 = static_cast< wxItemKind >(val5);
46596 }
46597 if (obj5) {
46598 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
46599 if (!SWIG_IsOK(res6)) {
46600 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
46601 }
46602 arg6 = reinterpret_cast< wxMenu * >(argp6);
46603 }
46604 {
46605 PyThreadState* __tstate = wxPyBeginAllowThreads();
46606 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
46607 wxPyEndAllowThreads(__tstate);
46608 if (PyErr_Occurred()) SWIG_fail;
46609 }
46610 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_NEW | 0 );
46611 {
46612 if (temp3)
46613 delete arg3;
46614 }
46615 {
46616 if (temp4)
46617 delete arg4;
46618 }
46619 return resultobj;
46620 fail:
46621 {
46622 if (temp3)
46623 delete arg3;
46624 }
46625 {
46626 if (temp4)
46627 delete arg4;
46628 }
46629 return NULL;
46630 }
46631
46632
46633 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46634 PyObject *resultobj = 0;
46635 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46636 void *argp1 = 0 ;
46637 int res1 = 0 ;
46638 PyObject *swig_obj[1] ;
46639
46640 if (!args) SWIG_fail;
46641 swig_obj[0] = args;
46642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
46643 if (!SWIG_IsOK(res1)) {
46644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46645 }
46646 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46647 {
46648 PyThreadState* __tstate = wxPyBeginAllowThreads();
46649 delete arg1;
46650
46651 wxPyEndAllowThreads(__tstate);
46652 if (PyErr_Occurred()) SWIG_fail;
46653 }
46654 resultobj = SWIG_Py_Void();
46655 return resultobj;
46656 fail:
46657 return NULL;
46658 }
46659
46660
46661 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46662 PyObject *resultobj = 0;
46663 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46664 wxMenu *result = 0 ;
46665 void *argp1 = 0 ;
46666 int res1 = 0 ;
46667 PyObject *swig_obj[1] ;
46668
46669 if (!args) SWIG_fail;
46670 swig_obj[0] = args;
46671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46672 if (!SWIG_IsOK(res1)) {
46673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46674 }
46675 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46676 {
46677 PyThreadState* __tstate = wxPyBeginAllowThreads();
46678 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
46679 wxPyEndAllowThreads(__tstate);
46680 if (PyErr_Occurred()) SWIG_fail;
46681 }
46682 {
46683 resultobj = wxPyMake_wxObject(result, 0);
46684 }
46685 return resultobj;
46686 fail:
46687 return NULL;
46688 }
46689
46690
46691 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46692 PyObject *resultobj = 0;
46693 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46694 wxMenu *arg2 = (wxMenu *) 0 ;
46695 void *argp1 = 0 ;
46696 int res1 = 0 ;
46697 void *argp2 = 0 ;
46698 int res2 = 0 ;
46699 PyObject * obj0 = 0 ;
46700 PyObject * obj1 = 0 ;
46701 char * kwnames[] = {
46702 (char *) "self",(char *) "menu", NULL
46703 };
46704
46705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
46706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46707 if (!SWIG_IsOK(res1)) {
46708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46709 }
46710 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46711 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
46712 if (!SWIG_IsOK(res2)) {
46713 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
46714 }
46715 arg2 = reinterpret_cast< wxMenu * >(argp2);
46716 {
46717 PyThreadState* __tstate = wxPyBeginAllowThreads();
46718 (arg1)->SetMenu(arg2);
46719 wxPyEndAllowThreads(__tstate);
46720 if (PyErr_Occurred()) SWIG_fail;
46721 }
46722 resultobj = SWIG_Py_Void();
46723 return resultobj;
46724 fail:
46725 return NULL;
46726 }
46727
46728
46729 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46730 PyObject *resultobj = 0;
46731 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46732 int arg2 ;
46733 void *argp1 = 0 ;
46734 int res1 = 0 ;
46735 int val2 ;
46736 int ecode2 = 0 ;
46737 PyObject * obj0 = 0 ;
46738 PyObject * obj1 = 0 ;
46739 char * kwnames[] = {
46740 (char *) "self",(char *) "id", NULL
46741 };
46742
46743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
46744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46745 if (!SWIG_IsOK(res1)) {
46746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46747 }
46748 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46749 ecode2 = SWIG_AsVal_int(obj1, &val2);
46750 if (!SWIG_IsOK(ecode2)) {
46751 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
46752 }
46753 arg2 = static_cast< int >(val2);
46754 {
46755 PyThreadState* __tstate = wxPyBeginAllowThreads();
46756 (arg1)->SetId(arg2);
46757 wxPyEndAllowThreads(__tstate);
46758 if (PyErr_Occurred()) SWIG_fail;
46759 }
46760 resultobj = SWIG_Py_Void();
46761 return resultobj;
46762 fail:
46763 return NULL;
46764 }
46765
46766
46767 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46768 PyObject *resultobj = 0;
46769 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46770 int result;
46771 void *argp1 = 0 ;
46772 int res1 = 0 ;
46773 PyObject *swig_obj[1] ;
46774
46775 if (!args) SWIG_fail;
46776 swig_obj[0] = args;
46777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46778 if (!SWIG_IsOK(res1)) {
46779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46780 }
46781 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46782 {
46783 PyThreadState* __tstate = wxPyBeginAllowThreads();
46784 result = (int)((wxMenuItem const *)arg1)->GetId();
46785 wxPyEndAllowThreads(__tstate);
46786 if (PyErr_Occurred()) SWIG_fail;
46787 }
46788 resultobj = SWIG_From_int(static_cast< int >(result));
46789 return resultobj;
46790 fail:
46791 return NULL;
46792 }
46793
46794
46795 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46796 PyObject *resultobj = 0;
46797 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46798 bool result;
46799 void *argp1 = 0 ;
46800 int res1 = 0 ;
46801 PyObject *swig_obj[1] ;
46802
46803 if (!args) SWIG_fail;
46804 swig_obj[0] = args;
46805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46806 if (!SWIG_IsOK(res1)) {
46807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46808 }
46809 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46810 {
46811 PyThreadState* __tstate = wxPyBeginAllowThreads();
46812 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
46813 wxPyEndAllowThreads(__tstate);
46814 if (PyErr_Occurred()) SWIG_fail;
46815 }
46816 {
46817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46818 }
46819 return resultobj;
46820 fail:
46821 return NULL;
46822 }
46823
46824
46825 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46826 PyObject *resultobj = 0;
46827 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46828 wxString *arg2 = 0 ;
46829 void *argp1 = 0 ;
46830 int res1 = 0 ;
46831 bool temp2 = false ;
46832 PyObject * obj0 = 0 ;
46833 PyObject * obj1 = 0 ;
46834 char * kwnames[] = {
46835 (char *) "self",(char *) "str", NULL
46836 };
46837
46838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
46839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46840 if (!SWIG_IsOK(res1)) {
46841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46842 }
46843 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46844 {
46845 arg2 = wxString_in_helper(obj1);
46846 if (arg2 == NULL) SWIG_fail;
46847 temp2 = true;
46848 }
46849 {
46850 PyThreadState* __tstate = wxPyBeginAllowThreads();
46851 (arg1)->SetText((wxString const &)*arg2);
46852 wxPyEndAllowThreads(__tstate);
46853 if (PyErr_Occurred()) SWIG_fail;
46854 }
46855 resultobj = SWIG_Py_Void();
46856 {
46857 if (temp2)
46858 delete arg2;
46859 }
46860 return resultobj;
46861 fail:
46862 {
46863 if (temp2)
46864 delete arg2;
46865 }
46866 return NULL;
46867 }
46868
46869
46870 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46871 PyObject *resultobj = 0;
46872 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46873 wxString result;
46874 void *argp1 = 0 ;
46875 int res1 = 0 ;
46876 PyObject *swig_obj[1] ;
46877
46878 if (!args) SWIG_fail;
46879 swig_obj[0] = args;
46880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46881 if (!SWIG_IsOK(res1)) {
46882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46883 }
46884 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46885 {
46886 PyThreadState* __tstate = wxPyBeginAllowThreads();
46887 result = ((wxMenuItem const *)arg1)->GetLabel();
46888 wxPyEndAllowThreads(__tstate);
46889 if (PyErr_Occurred()) SWIG_fail;
46890 }
46891 {
46892 #if wxUSE_UNICODE
46893 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46894 #else
46895 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46896 #endif
46897 }
46898 return resultobj;
46899 fail:
46900 return NULL;
46901 }
46902
46903
46904 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46905 PyObject *resultobj = 0;
46906 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46907 wxString *result = 0 ;
46908 void *argp1 = 0 ;
46909 int res1 = 0 ;
46910 PyObject *swig_obj[1] ;
46911
46912 if (!args) SWIG_fail;
46913 swig_obj[0] = args;
46914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46915 if (!SWIG_IsOK(res1)) {
46916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46917 }
46918 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46919 {
46920 PyThreadState* __tstate = wxPyBeginAllowThreads();
46921 {
46922 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
46923 result = (wxString *) &_result_ref;
46924 }
46925 wxPyEndAllowThreads(__tstate);
46926 if (PyErr_Occurred()) SWIG_fail;
46927 }
46928 {
46929 #if wxUSE_UNICODE
46930 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46931 #else
46932 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46933 #endif
46934 }
46935 return resultobj;
46936 fail:
46937 return NULL;
46938 }
46939
46940
46941 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46942 PyObject *resultobj = 0;
46943 wxString *arg1 = 0 ;
46944 wxString result;
46945 bool temp1 = false ;
46946 PyObject * obj0 = 0 ;
46947 char * kwnames[] = {
46948 (char *) "text", NULL
46949 };
46950
46951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
46952 {
46953 arg1 = wxString_in_helper(obj0);
46954 if (arg1 == NULL) SWIG_fail;
46955 temp1 = true;
46956 }
46957 {
46958 PyThreadState* __tstate = wxPyBeginAllowThreads();
46959 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
46960 wxPyEndAllowThreads(__tstate);
46961 if (PyErr_Occurred()) SWIG_fail;
46962 }
46963 {
46964 #if wxUSE_UNICODE
46965 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46966 #else
46967 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46968 #endif
46969 }
46970 {
46971 if (temp1)
46972 delete arg1;
46973 }
46974 return resultobj;
46975 fail:
46976 {
46977 if (temp1)
46978 delete arg1;
46979 }
46980 return NULL;
46981 }
46982
46983
46984 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46985 PyObject *resultobj = 0;
46986 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46987 wxItemKind result;
46988 void *argp1 = 0 ;
46989 int res1 = 0 ;
46990 PyObject *swig_obj[1] ;
46991
46992 if (!args) SWIG_fail;
46993 swig_obj[0] = args;
46994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46995 if (!SWIG_IsOK(res1)) {
46996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46997 }
46998 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46999 {
47000 PyThreadState* __tstate = wxPyBeginAllowThreads();
47001 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
47002 wxPyEndAllowThreads(__tstate);
47003 if (PyErr_Occurred()) SWIG_fail;
47004 }
47005 resultobj = SWIG_From_int(static_cast< int >(result));
47006 return resultobj;
47007 fail:
47008 return NULL;
47009 }
47010
47011
47012 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47013 PyObject *resultobj = 0;
47014 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47015 wxItemKind arg2 ;
47016 void *argp1 = 0 ;
47017 int res1 = 0 ;
47018 int val2 ;
47019 int ecode2 = 0 ;
47020 PyObject * obj0 = 0 ;
47021 PyObject * obj1 = 0 ;
47022 char * kwnames[] = {
47023 (char *) "self",(char *) "kind", NULL
47024 };
47025
47026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
47027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47028 if (!SWIG_IsOK(res1)) {
47029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47030 }
47031 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47032 ecode2 = SWIG_AsVal_int(obj1, &val2);
47033 if (!SWIG_IsOK(ecode2)) {
47034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
47035 }
47036 arg2 = static_cast< wxItemKind >(val2);
47037 {
47038 PyThreadState* __tstate = wxPyBeginAllowThreads();
47039 (arg1)->SetKind(arg2);
47040 wxPyEndAllowThreads(__tstate);
47041 if (PyErr_Occurred()) SWIG_fail;
47042 }
47043 resultobj = SWIG_Py_Void();
47044 return resultobj;
47045 fail:
47046 return NULL;
47047 }
47048
47049
47050 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47051 PyObject *resultobj = 0;
47052 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47053 bool arg2 ;
47054 void *argp1 = 0 ;
47055 int res1 = 0 ;
47056 bool val2 ;
47057 int ecode2 = 0 ;
47058 PyObject * obj0 = 0 ;
47059 PyObject * obj1 = 0 ;
47060 char * kwnames[] = {
47061 (char *) "self",(char *) "checkable", NULL
47062 };
47063
47064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
47065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47066 if (!SWIG_IsOK(res1)) {
47067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47068 }
47069 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47070 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47071 if (!SWIG_IsOK(ecode2)) {
47072 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
47073 }
47074 arg2 = static_cast< bool >(val2);
47075 {
47076 PyThreadState* __tstate = wxPyBeginAllowThreads();
47077 (arg1)->SetCheckable(arg2);
47078 wxPyEndAllowThreads(__tstate);
47079 if (PyErr_Occurred()) SWIG_fail;
47080 }
47081 resultobj = SWIG_Py_Void();
47082 return resultobj;
47083 fail:
47084 return NULL;
47085 }
47086
47087
47088 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47089 PyObject *resultobj = 0;
47090 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47091 bool result;
47092 void *argp1 = 0 ;
47093 int res1 = 0 ;
47094 PyObject *swig_obj[1] ;
47095
47096 if (!args) SWIG_fail;
47097 swig_obj[0] = args;
47098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47099 if (!SWIG_IsOK(res1)) {
47100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47101 }
47102 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47103 {
47104 PyThreadState* __tstate = wxPyBeginAllowThreads();
47105 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
47106 wxPyEndAllowThreads(__tstate);
47107 if (PyErr_Occurred()) SWIG_fail;
47108 }
47109 {
47110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47111 }
47112 return resultobj;
47113 fail:
47114 return NULL;
47115 }
47116
47117
47118 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47119 PyObject *resultobj = 0;
47120 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47121 bool result;
47122 void *argp1 = 0 ;
47123 int res1 = 0 ;
47124 PyObject *swig_obj[1] ;
47125
47126 if (!args) SWIG_fail;
47127 swig_obj[0] = args;
47128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47129 if (!SWIG_IsOK(res1)) {
47130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47131 }
47132 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47133 {
47134 PyThreadState* __tstate = wxPyBeginAllowThreads();
47135 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
47136 wxPyEndAllowThreads(__tstate);
47137 if (PyErr_Occurred()) SWIG_fail;
47138 }
47139 {
47140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47141 }
47142 return resultobj;
47143 fail:
47144 return NULL;
47145 }
47146
47147
47148 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47149 PyObject *resultobj = 0;
47150 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47151 wxMenu *arg2 = (wxMenu *) 0 ;
47152 void *argp1 = 0 ;
47153 int res1 = 0 ;
47154 void *argp2 = 0 ;
47155 int res2 = 0 ;
47156 PyObject * obj0 = 0 ;
47157 PyObject * obj1 = 0 ;
47158 char * kwnames[] = {
47159 (char *) "self",(char *) "menu", NULL
47160 };
47161
47162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
47163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47164 if (!SWIG_IsOK(res1)) {
47165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47166 }
47167 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47168 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
47169 if (!SWIG_IsOK(res2)) {
47170 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
47171 }
47172 arg2 = reinterpret_cast< wxMenu * >(argp2);
47173 {
47174 PyThreadState* __tstate = wxPyBeginAllowThreads();
47175 (arg1)->SetSubMenu(arg2);
47176 wxPyEndAllowThreads(__tstate);
47177 if (PyErr_Occurred()) SWIG_fail;
47178 }
47179 resultobj = SWIG_Py_Void();
47180 return resultobj;
47181 fail:
47182 return NULL;
47183 }
47184
47185
47186 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47187 PyObject *resultobj = 0;
47188 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47189 wxMenu *result = 0 ;
47190 void *argp1 = 0 ;
47191 int res1 = 0 ;
47192 PyObject *swig_obj[1] ;
47193
47194 if (!args) SWIG_fail;
47195 swig_obj[0] = args;
47196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47197 if (!SWIG_IsOK(res1)) {
47198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47199 }
47200 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47201 {
47202 PyThreadState* __tstate = wxPyBeginAllowThreads();
47203 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
47204 wxPyEndAllowThreads(__tstate);
47205 if (PyErr_Occurred()) SWIG_fail;
47206 }
47207 {
47208 resultobj = wxPyMake_wxObject(result, 0);
47209 }
47210 return resultobj;
47211 fail:
47212 return NULL;
47213 }
47214
47215
47216 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47217 PyObject *resultobj = 0;
47218 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47219 bool arg2 = (bool) true ;
47220 void *argp1 = 0 ;
47221 int res1 = 0 ;
47222 bool val2 ;
47223 int ecode2 = 0 ;
47224 PyObject * obj0 = 0 ;
47225 PyObject * obj1 = 0 ;
47226 char * kwnames[] = {
47227 (char *) "self",(char *) "enable", NULL
47228 };
47229
47230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
47231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47232 if (!SWIG_IsOK(res1)) {
47233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47234 }
47235 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47236 if (obj1) {
47237 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47238 if (!SWIG_IsOK(ecode2)) {
47239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
47240 }
47241 arg2 = static_cast< bool >(val2);
47242 }
47243 {
47244 PyThreadState* __tstate = wxPyBeginAllowThreads();
47245 (arg1)->Enable(arg2);
47246 wxPyEndAllowThreads(__tstate);
47247 if (PyErr_Occurred()) SWIG_fail;
47248 }
47249 resultobj = SWIG_Py_Void();
47250 return resultobj;
47251 fail:
47252 return NULL;
47253 }
47254
47255
47256 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47257 PyObject *resultobj = 0;
47258 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47259 bool result;
47260 void *argp1 = 0 ;
47261 int res1 = 0 ;
47262 PyObject *swig_obj[1] ;
47263
47264 if (!args) SWIG_fail;
47265 swig_obj[0] = args;
47266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47267 if (!SWIG_IsOK(res1)) {
47268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47269 }
47270 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47271 {
47272 PyThreadState* __tstate = wxPyBeginAllowThreads();
47273 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
47274 wxPyEndAllowThreads(__tstate);
47275 if (PyErr_Occurred()) SWIG_fail;
47276 }
47277 {
47278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47279 }
47280 return resultobj;
47281 fail:
47282 return NULL;
47283 }
47284
47285
47286 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47287 PyObject *resultobj = 0;
47288 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47289 bool arg2 = (bool) true ;
47290 void *argp1 = 0 ;
47291 int res1 = 0 ;
47292 bool val2 ;
47293 int ecode2 = 0 ;
47294 PyObject * obj0 = 0 ;
47295 PyObject * obj1 = 0 ;
47296 char * kwnames[] = {
47297 (char *) "self",(char *) "check", NULL
47298 };
47299
47300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
47301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47302 if (!SWIG_IsOK(res1)) {
47303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47304 }
47305 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47306 if (obj1) {
47307 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47308 if (!SWIG_IsOK(ecode2)) {
47309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
47310 }
47311 arg2 = static_cast< bool >(val2);
47312 }
47313 {
47314 PyThreadState* __tstate = wxPyBeginAllowThreads();
47315 (arg1)->Check(arg2);
47316 wxPyEndAllowThreads(__tstate);
47317 if (PyErr_Occurred()) SWIG_fail;
47318 }
47319 resultobj = SWIG_Py_Void();
47320 return resultobj;
47321 fail:
47322 return NULL;
47323 }
47324
47325
47326 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47327 PyObject *resultobj = 0;
47328 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47329 bool result;
47330 void *argp1 = 0 ;
47331 int res1 = 0 ;
47332 PyObject *swig_obj[1] ;
47333
47334 if (!args) SWIG_fail;
47335 swig_obj[0] = args;
47336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47337 if (!SWIG_IsOK(res1)) {
47338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47339 }
47340 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47341 {
47342 PyThreadState* __tstate = wxPyBeginAllowThreads();
47343 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
47344 wxPyEndAllowThreads(__tstate);
47345 if (PyErr_Occurred()) SWIG_fail;
47346 }
47347 {
47348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47349 }
47350 return resultobj;
47351 fail:
47352 return NULL;
47353 }
47354
47355
47356 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47357 PyObject *resultobj = 0;
47358 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47359 void *argp1 = 0 ;
47360 int res1 = 0 ;
47361 PyObject *swig_obj[1] ;
47362
47363 if (!args) SWIG_fail;
47364 swig_obj[0] = args;
47365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47366 if (!SWIG_IsOK(res1)) {
47367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47368 }
47369 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47370 {
47371 PyThreadState* __tstate = wxPyBeginAllowThreads();
47372 (arg1)->Toggle();
47373 wxPyEndAllowThreads(__tstate);
47374 if (PyErr_Occurred()) SWIG_fail;
47375 }
47376 resultobj = SWIG_Py_Void();
47377 return resultobj;
47378 fail:
47379 return NULL;
47380 }
47381
47382
47383 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47384 PyObject *resultobj = 0;
47385 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47386 wxString *arg2 = 0 ;
47387 void *argp1 = 0 ;
47388 int res1 = 0 ;
47389 bool temp2 = false ;
47390 PyObject * obj0 = 0 ;
47391 PyObject * obj1 = 0 ;
47392 char * kwnames[] = {
47393 (char *) "self",(char *) "str", NULL
47394 };
47395
47396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
47397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47398 if (!SWIG_IsOK(res1)) {
47399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47400 }
47401 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47402 {
47403 arg2 = wxString_in_helper(obj1);
47404 if (arg2 == NULL) SWIG_fail;
47405 temp2 = true;
47406 }
47407 {
47408 PyThreadState* __tstate = wxPyBeginAllowThreads();
47409 (arg1)->SetHelp((wxString const &)*arg2);
47410 wxPyEndAllowThreads(__tstate);
47411 if (PyErr_Occurred()) SWIG_fail;
47412 }
47413 resultobj = SWIG_Py_Void();
47414 {
47415 if (temp2)
47416 delete arg2;
47417 }
47418 return resultobj;
47419 fail:
47420 {
47421 if (temp2)
47422 delete arg2;
47423 }
47424 return NULL;
47425 }
47426
47427
47428 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47429 PyObject *resultobj = 0;
47430 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47431 wxString *result = 0 ;
47432 void *argp1 = 0 ;
47433 int res1 = 0 ;
47434 PyObject *swig_obj[1] ;
47435
47436 if (!args) SWIG_fail;
47437 swig_obj[0] = args;
47438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47439 if (!SWIG_IsOK(res1)) {
47440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47441 }
47442 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47443 {
47444 PyThreadState* __tstate = wxPyBeginAllowThreads();
47445 {
47446 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
47447 result = (wxString *) &_result_ref;
47448 }
47449 wxPyEndAllowThreads(__tstate);
47450 if (PyErr_Occurred()) SWIG_fail;
47451 }
47452 {
47453 #if wxUSE_UNICODE
47454 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
47455 #else
47456 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
47457 #endif
47458 }
47459 return resultobj;
47460 fail:
47461 return NULL;
47462 }
47463
47464
47465 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47466 PyObject *resultobj = 0;
47467 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47468 wxAcceleratorEntry *result = 0 ;
47469 void *argp1 = 0 ;
47470 int res1 = 0 ;
47471 PyObject *swig_obj[1] ;
47472
47473 if (!args) SWIG_fail;
47474 swig_obj[0] = args;
47475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47476 if (!SWIG_IsOK(res1)) {
47477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47478 }
47479 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47480 {
47481 PyThreadState* __tstate = wxPyBeginAllowThreads();
47482 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
47483 wxPyEndAllowThreads(__tstate);
47484 if (PyErr_Occurred()) SWIG_fail;
47485 }
47486 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
47487 return resultobj;
47488 fail:
47489 return NULL;
47490 }
47491
47492
47493 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47494 PyObject *resultobj = 0;
47495 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47496 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
47497 void *argp1 = 0 ;
47498 int res1 = 0 ;
47499 void *argp2 = 0 ;
47500 int res2 = 0 ;
47501 PyObject * obj0 = 0 ;
47502 PyObject * obj1 = 0 ;
47503 char * kwnames[] = {
47504 (char *) "self",(char *) "accel", NULL
47505 };
47506
47507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
47508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47509 if (!SWIG_IsOK(res1)) {
47510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47511 }
47512 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47513 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
47514 if (!SWIG_IsOK(res2)) {
47515 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
47516 }
47517 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
47518 {
47519 PyThreadState* __tstate = wxPyBeginAllowThreads();
47520 (arg1)->SetAccel(arg2);
47521 wxPyEndAllowThreads(__tstate);
47522 if (PyErr_Occurred()) SWIG_fail;
47523 }
47524 resultobj = SWIG_Py_Void();
47525 return resultobj;
47526 fail:
47527 return NULL;
47528 }
47529
47530
47531 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47532 PyObject *resultobj = 0;
47533 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47534 wxBitmap *arg2 = 0 ;
47535 void *argp1 = 0 ;
47536 int res1 = 0 ;
47537 void *argp2 = 0 ;
47538 int res2 = 0 ;
47539 PyObject * obj0 = 0 ;
47540 PyObject * obj1 = 0 ;
47541 char * kwnames[] = {
47542 (char *) "self",(char *) "bitmap", NULL
47543 };
47544
47545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
47546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47547 if (!SWIG_IsOK(res1)) {
47548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47549 }
47550 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47551 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47552 if (!SWIG_IsOK(res2)) {
47553 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47554 }
47555 if (!argp2) {
47556 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47557 }
47558 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47559 {
47560 PyThreadState* __tstate = wxPyBeginAllowThreads();
47561 (arg1)->SetBitmap((wxBitmap const &)*arg2);
47562 wxPyEndAllowThreads(__tstate);
47563 if (PyErr_Occurred()) SWIG_fail;
47564 }
47565 resultobj = SWIG_Py_Void();
47566 return resultobj;
47567 fail:
47568 return NULL;
47569 }
47570
47571
47572 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47573 PyObject *resultobj = 0;
47574 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47575 wxBitmap *result = 0 ;
47576 void *argp1 = 0 ;
47577 int res1 = 0 ;
47578 PyObject *swig_obj[1] ;
47579
47580 if (!args) SWIG_fail;
47581 swig_obj[0] = args;
47582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47583 if (!SWIG_IsOK(res1)) {
47584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47585 }
47586 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47587 {
47588 PyThreadState* __tstate = wxPyBeginAllowThreads();
47589 {
47590 wxBitmap const &_result_ref = (arg1)->GetBitmap();
47591 result = (wxBitmap *) &_result_ref;
47592 }
47593 wxPyEndAllowThreads(__tstate);
47594 if (PyErr_Occurred()) SWIG_fail;
47595 }
47596 {
47597 wxBitmap* resultptr = new wxBitmap(*result);
47598 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
47599 }
47600 return resultobj;
47601 fail:
47602 return NULL;
47603 }
47604
47605
47606 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47607 PyObject *resultobj = 0;
47608 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47609 wxFont *arg2 = 0 ;
47610 void *argp1 = 0 ;
47611 int res1 = 0 ;
47612 void *argp2 = 0 ;
47613 int res2 = 0 ;
47614 PyObject * obj0 = 0 ;
47615 PyObject * obj1 = 0 ;
47616 char * kwnames[] = {
47617 (char *) "self",(char *) "font", NULL
47618 };
47619
47620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
47621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47622 if (!SWIG_IsOK(res1)) {
47623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47624 }
47625 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47626 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
47627 if (!SWIG_IsOK(res2)) {
47628 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
47629 }
47630 if (!argp2) {
47631 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
47632 }
47633 arg2 = reinterpret_cast< wxFont * >(argp2);
47634 {
47635 PyThreadState* __tstate = wxPyBeginAllowThreads();
47636 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
47637 wxPyEndAllowThreads(__tstate);
47638 if (PyErr_Occurred()) SWIG_fail;
47639 }
47640 resultobj = SWIG_Py_Void();
47641 return resultobj;
47642 fail:
47643 return NULL;
47644 }
47645
47646
47647 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47648 PyObject *resultobj = 0;
47649 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47650 wxFont result;
47651 void *argp1 = 0 ;
47652 int res1 = 0 ;
47653 PyObject *swig_obj[1] ;
47654
47655 if (!args) SWIG_fail;
47656 swig_obj[0] = args;
47657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47658 if (!SWIG_IsOK(res1)) {
47659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47660 }
47661 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47662 {
47663 PyThreadState* __tstate = wxPyBeginAllowThreads();
47664 result = wxMenuItem_GetFont(arg1);
47665 wxPyEndAllowThreads(__tstate);
47666 if (PyErr_Occurred()) SWIG_fail;
47667 }
47668 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
47669 return resultobj;
47670 fail:
47671 return NULL;
47672 }
47673
47674
47675 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47676 PyObject *resultobj = 0;
47677 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47678 wxColour *arg2 = 0 ;
47679 void *argp1 = 0 ;
47680 int res1 = 0 ;
47681 wxColour temp2 ;
47682 PyObject * obj0 = 0 ;
47683 PyObject * obj1 = 0 ;
47684 char * kwnames[] = {
47685 (char *) "self",(char *) "colText", NULL
47686 };
47687
47688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
47689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47690 if (!SWIG_IsOK(res1)) {
47691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47692 }
47693 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47694 {
47695 arg2 = &temp2;
47696 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
47697 }
47698 {
47699 PyThreadState* __tstate = wxPyBeginAllowThreads();
47700 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
47701 wxPyEndAllowThreads(__tstate);
47702 if (PyErr_Occurred()) SWIG_fail;
47703 }
47704 resultobj = SWIG_Py_Void();
47705 return resultobj;
47706 fail:
47707 return NULL;
47708 }
47709
47710
47711 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47712 PyObject *resultobj = 0;
47713 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47714 wxColour result;
47715 void *argp1 = 0 ;
47716 int res1 = 0 ;
47717 PyObject *swig_obj[1] ;
47718
47719 if (!args) SWIG_fail;
47720 swig_obj[0] = args;
47721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47722 if (!SWIG_IsOK(res1)) {
47723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47724 }
47725 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47726 {
47727 PyThreadState* __tstate = wxPyBeginAllowThreads();
47728 result = wxMenuItem_GetTextColour(arg1);
47729 wxPyEndAllowThreads(__tstate);
47730 if (PyErr_Occurred()) SWIG_fail;
47731 }
47732 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
47733 return resultobj;
47734 fail:
47735 return NULL;
47736 }
47737
47738
47739 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47740 PyObject *resultobj = 0;
47741 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47742 wxColour *arg2 = 0 ;
47743 void *argp1 = 0 ;
47744 int res1 = 0 ;
47745 wxColour temp2 ;
47746 PyObject * obj0 = 0 ;
47747 PyObject * obj1 = 0 ;
47748 char * kwnames[] = {
47749 (char *) "self",(char *) "colBack", NULL
47750 };
47751
47752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
47753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47754 if (!SWIG_IsOK(res1)) {
47755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47756 }
47757 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47758 {
47759 arg2 = &temp2;
47760 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
47761 }
47762 {
47763 PyThreadState* __tstate = wxPyBeginAllowThreads();
47764 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
47765 wxPyEndAllowThreads(__tstate);
47766 if (PyErr_Occurred()) SWIG_fail;
47767 }
47768 resultobj = SWIG_Py_Void();
47769 return resultobj;
47770 fail:
47771 return NULL;
47772 }
47773
47774
47775 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47776 PyObject *resultobj = 0;
47777 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47778 wxColour result;
47779 void *argp1 = 0 ;
47780 int res1 = 0 ;
47781 PyObject *swig_obj[1] ;
47782
47783 if (!args) SWIG_fail;
47784 swig_obj[0] = args;
47785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47786 if (!SWIG_IsOK(res1)) {
47787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47788 }
47789 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47790 {
47791 PyThreadState* __tstate = wxPyBeginAllowThreads();
47792 result = wxMenuItem_GetBackgroundColour(arg1);
47793 wxPyEndAllowThreads(__tstate);
47794 if (PyErr_Occurred()) SWIG_fail;
47795 }
47796 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
47797 return resultobj;
47798 fail:
47799 return NULL;
47800 }
47801
47802
47803 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47804 PyObject *resultobj = 0;
47805 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47806 wxBitmap *arg2 = 0 ;
47807 wxBitmap const &arg3_defvalue = wxNullBitmap ;
47808 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
47809 void *argp1 = 0 ;
47810 int res1 = 0 ;
47811 void *argp2 = 0 ;
47812 int res2 = 0 ;
47813 void *argp3 = 0 ;
47814 int res3 = 0 ;
47815 PyObject * obj0 = 0 ;
47816 PyObject * obj1 = 0 ;
47817 PyObject * obj2 = 0 ;
47818 char * kwnames[] = {
47819 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
47820 };
47821
47822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47824 if (!SWIG_IsOK(res1)) {
47825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47826 }
47827 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47828 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47829 if (!SWIG_IsOK(res2)) {
47830 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47831 }
47832 if (!argp2) {
47833 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47834 }
47835 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47836 if (obj2) {
47837 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
47838 if (!SWIG_IsOK(res3)) {
47839 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
47840 }
47841 if (!argp3) {
47842 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
47843 }
47844 arg3 = reinterpret_cast< wxBitmap * >(argp3);
47845 }
47846 {
47847 PyThreadState* __tstate = wxPyBeginAllowThreads();
47848 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
47849 wxPyEndAllowThreads(__tstate);
47850 if (PyErr_Occurred()) SWIG_fail;
47851 }
47852 resultobj = SWIG_Py_Void();
47853 return resultobj;
47854 fail:
47855 return NULL;
47856 }
47857
47858
47859 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47860 PyObject *resultobj = 0;
47861 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47862 wxBitmap *arg2 = 0 ;
47863 void *argp1 = 0 ;
47864 int res1 = 0 ;
47865 void *argp2 = 0 ;
47866 int res2 = 0 ;
47867 PyObject * obj0 = 0 ;
47868 PyObject * obj1 = 0 ;
47869 char * kwnames[] = {
47870 (char *) "self",(char *) "bmpDisabled", NULL
47871 };
47872
47873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
47874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47875 if (!SWIG_IsOK(res1)) {
47876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47877 }
47878 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47879 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47880 if (!SWIG_IsOK(res2)) {
47881 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47882 }
47883 if (!argp2) {
47884 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47885 }
47886 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47887 {
47888 PyThreadState* __tstate = wxPyBeginAllowThreads();
47889 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
47890 wxPyEndAllowThreads(__tstate);
47891 if (PyErr_Occurred()) SWIG_fail;
47892 }
47893 resultobj = SWIG_Py_Void();
47894 return resultobj;
47895 fail:
47896 return NULL;
47897 }
47898
47899
47900 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47901 PyObject *resultobj = 0;
47902 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47903 wxBitmap *result = 0 ;
47904 void *argp1 = 0 ;
47905 int res1 = 0 ;
47906 PyObject *swig_obj[1] ;
47907
47908 if (!args) SWIG_fail;
47909 swig_obj[0] = args;
47910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47911 if (!SWIG_IsOK(res1)) {
47912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47913 }
47914 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47915 {
47916 PyThreadState* __tstate = wxPyBeginAllowThreads();
47917 {
47918 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
47919 result = (wxBitmap *) &_result_ref;
47920 }
47921 wxPyEndAllowThreads(__tstate);
47922 if (PyErr_Occurred()) SWIG_fail;
47923 }
47924 {
47925 wxBitmap* resultptr = new wxBitmap(*result);
47926 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
47927 }
47928 return resultobj;
47929 fail:
47930 return NULL;
47931 }
47932
47933
47934 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47935 PyObject *resultobj = 0;
47936 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47937 int arg2 ;
47938 void *argp1 = 0 ;
47939 int res1 = 0 ;
47940 int val2 ;
47941 int ecode2 = 0 ;
47942 PyObject * obj0 = 0 ;
47943 PyObject * obj1 = 0 ;
47944 char * kwnames[] = {
47945 (char *) "self",(char *) "nWidth", NULL
47946 };
47947
47948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
47949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47950 if (!SWIG_IsOK(res1)) {
47951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47952 }
47953 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47954 ecode2 = SWIG_AsVal_int(obj1, &val2);
47955 if (!SWIG_IsOK(ecode2)) {
47956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
47957 }
47958 arg2 = static_cast< int >(val2);
47959 {
47960 PyThreadState* __tstate = wxPyBeginAllowThreads();
47961 wxMenuItem_SetMarginWidth(arg1,arg2);
47962 wxPyEndAllowThreads(__tstate);
47963 if (PyErr_Occurred()) SWIG_fail;
47964 }
47965 resultobj = SWIG_Py_Void();
47966 return resultobj;
47967 fail:
47968 return NULL;
47969 }
47970
47971
47972 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47973 PyObject *resultobj = 0;
47974 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47975 int result;
47976 void *argp1 = 0 ;
47977 int res1 = 0 ;
47978 PyObject *swig_obj[1] ;
47979
47980 if (!args) SWIG_fail;
47981 swig_obj[0] = args;
47982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47983 if (!SWIG_IsOK(res1)) {
47984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47985 }
47986 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47987 {
47988 PyThreadState* __tstate = wxPyBeginAllowThreads();
47989 result = (int)wxMenuItem_GetMarginWidth(arg1);
47990 wxPyEndAllowThreads(__tstate);
47991 if (PyErr_Occurred()) SWIG_fail;
47992 }
47993 resultobj = SWIG_From_int(static_cast< int >(result));
47994 return resultobj;
47995 fail:
47996 return NULL;
47997 }
47998
47999
48000 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48001 PyObject *resultobj = 0;
48002 int result;
48003
48004 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
48005 {
48006 PyThreadState* __tstate = wxPyBeginAllowThreads();
48007 result = (int)wxMenuItem_GetDefaultMarginWidth();
48008 wxPyEndAllowThreads(__tstate);
48009 if (PyErr_Occurred()) SWIG_fail;
48010 }
48011 resultobj = SWIG_From_int(static_cast< int >(result));
48012 return resultobj;
48013 fail:
48014 return NULL;
48015 }
48016
48017
48018 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48019 PyObject *resultobj = 0;
48020 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
48021 bool result;
48022 void *argp1 = 0 ;
48023 int res1 = 0 ;
48024 PyObject *swig_obj[1] ;
48025
48026 if (!args) SWIG_fail;
48027 swig_obj[0] = args;
48028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
48029 if (!SWIG_IsOK(res1)) {
48030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
48031 }
48032 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
48033 {
48034 PyThreadState* __tstate = wxPyBeginAllowThreads();
48035 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
48036 wxPyEndAllowThreads(__tstate);
48037 if (PyErr_Occurred()) SWIG_fail;
48038 }
48039 {
48040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48041 }
48042 return resultobj;
48043 fail:
48044 return NULL;
48045 }
48046
48047
48048 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48049 PyObject *resultobj = 0;
48050 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
48051 bool arg2 = (bool) true ;
48052 void *argp1 = 0 ;
48053 int res1 = 0 ;
48054 bool val2 ;
48055 int ecode2 = 0 ;
48056 PyObject * obj0 = 0 ;
48057 PyObject * obj1 = 0 ;
48058 char * kwnames[] = {
48059 (char *) "self",(char *) "ownerDrawn", NULL
48060 };
48061
48062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
48063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
48064 if (!SWIG_IsOK(res1)) {
48065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
48066 }
48067 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
48068 if (obj1) {
48069 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48070 if (!SWIG_IsOK(ecode2)) {
48071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
48072 }
48073 arg2 = static_cast< bool >(val2);
48074 }
48075 {
48076 PyThreadState* __tstate = wxPyBeginAllowThreads();
48077 wxMenuItem_SetOwnerDrawn(arg1,arg2);
48078 wxPyEndAllowThreads(__tstate);
48079 if (PyErr_Occurred()) SWIG_fail;
48080 }
48081 resultobj = SWIG_Py_Void();
48082 return resultobj;
48083 fail:
48084 return NULL;
48085 }
48086
48087
48088 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48089 PyObject *resultobj = 0;
48090 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
48091 void *argp1 = 0 ;
48092 int res1 = 0 ;
48093 PyObject *swig_obj[1] ;
48094
48095 if (!args) SWIG_fail;
48096 swig_obj[0] = args;
48097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
48098 if (!SWIG_IsOK(res1)) {
48099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
48100 }
48101 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
48102 {
48103 PyThreadState* __tstate = wxPyBeginAllowThreads();
48104 wxMenuItem_ResetOwnerDrawn(arg1);
48105 wxPyEndAllowThreads(__tstate);
48106 if (PyErr_Occurred()) SWIG_fail;
48107 }
48108 resultobj = SWIG_Py_Void();
48109 return resultobj;
48110 fail:
48111 return NULL;
48112 }
48113
48114
48115 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48116 PyObject *obj;
48117 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48118 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
48119 return SWIG_Py_Void();
48120 }
48121
48122 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48123 return SWIG_Python_InitShadowInstance(args);
48124 }
48125
48126 SWIGINTERN int ControlNameStr_set(PyObject *) {
48127 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
48128 return 1;
48129 }
48130
48131
48132 SWIGINTERN PyObject *ControlNameStr_get(void) {
48133 PyObject *pyobj = 0;
48134
48135 {
48136 #if wxUSE_UNICODE
48137 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
48138 #else
48139 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
48140 #endif
48141 }
48142 return pyobj;
48143 }
48144
48145
48146 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48147 PyObject *resultobj = 0;
48148 wxWindow *arg1 = (wxWindow *) 0 ;
48149 int arg2 = (int) -1 ;
48150 wxPoint const &arg3_defvalue = wxDefaultPosition ;
48151 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
48152 wxSize const &arg4_defvalue = wxDefaultSize ;
48153 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
48154 long arg5 = (long) 0 ;
48155 wxValidator const &arg6_defvalue = wxDefaultValidator ;
48156 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
48157 wxString const &arg7_defvalue = wxPyControlNameStr ;
48158 wxString *arg7 = (wxString *) &arg7_defvalue ;
48159 wxControl *result = 0 ;
48160 void *argp1 = 0 ;
48161 int res1 = 0 ;
48162 int val2 ;
48163 int ecode2 = 0 ;
48164 wxPoint temp3 ;
48165 wxSize temp4 ;
48166 long val5 ;
48167 int ecode5 = 0 ;
48168 void *argp6 = 0 ;
48169 int res6 = 0 ;
48170 bool temp7 = false ;
48171 PyObject * obj0 = 0 ;
48172 PyObject * obj1 = 0 ;
48173 PyObject * obj2 = 0 ;
48174 PyObject * obj3 = 0 ;
48175 PyObject * obj4 = 0 ;
48176 PyObject * obj5 = 0 ;
48177 PyObject * obj6 = 0 ;
48178 char * kwnames[] = {
48179 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
48180 };
48181
48182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
48183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
48184 if (!SWIG_IsOK(res1)) {
48185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
48186 }
48187 arg1 = reinterpret_cast< wxWindow * >(argp1);
48188 if (obj1) {
48189 ecode2 = SWIG_AsVal_int(obj1, &val2);
48190 if (!SWIG_IsOK(ecode2)) {
48191 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
48192 }
48193 arg2 = static_cast< int >(val2);
48194 }
48195 if (obj2) {
48196 {
48197 arg3 = &temp3;
48198 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
48199 }
48200 }
48201 if (obj3) {
48202 {
48203 arg4 = &temp4;
48204 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
48205 }
48206 }
48207 if (obj4) {
48208 ecode5 = SWIG_AsVal_long(obj4, &val5);
48209 if (!SWIG_IsOK(ecode5)) {
48210 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
48211 }
48212 arg5 = static_cast< long >(val5);
48213 }
48214 if (obj5) {
48215 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
48216 if (!SWIG_IsOK(res6)) {
48217 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
48218 }
48219 if (!argp6) {
48220 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
48221 }
48222 arg6 = reinterpret_cast< wxValidator * >(argp6);
48223 }
48224 if (obj6) {
48225 {
48226 arg7 = wxString_in_helper(obj6);
48227 if (arg7 == NULL) SWIG_fail;
48228 temp7 = true;
48229 }
48230 }
48231 {
48232 if (!wxPyCheckForApp()) SWIG_fail;
48233 PyThreadState* __tstate = wxPyBeginAllowThreads();
48234 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
48235 wxPyEndAllowThreads(__tstate);
48236 if (PyErr_Occurred()) SWIG_fail;
48237 }
48238 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
48239 {
48240 if (temp7)
48241 delete arg7;
48242 }
48243 return resultobj;
48244 fail:
48245 {
48246 if (temp7)
48247 delete arg7;
48248 }
48249 return NULL;
48250 }
48251
48252
48253 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48254 PyObject *resultobj = 0;
48255 wxControl *result = 0 ;
48256
48257 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
48258 {
48259 if (!wxPyCheckForApp()) SWIG_fail;
48260 PyThreadState* __tstate = wxPyBeginAllowThreads();
48261 result = (wxControl *)new wxControl();
48262 wxPyEndAllowThreads(__tstate);
48263 if (PyErr_Occurred()) SWIG_fail;
48264 }
48265 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
48266 return resultobj;
48267 fail:
48268 return NULL;
48269 }
48270
48271
48272 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48273 PyObject *resultobj = 0;
48274 wxControl *arg1 = (wxControl *) 0 ;
48275 wxWindow *arg2 = (wxWindow *) 0 ;
48276 int arg3 = (int) -1 ;
48277 wxPoint const &arg4_defvalue = wxDefaultPosition ;
48278 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
48279 wxSize const &arg5_defvalue = wxDefaultSize ;
48280 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
48281 long arg6 = (long) 0 ;
48282 wxValidator const &arg7_defvalue = wxDefaultValidator ;
48283 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
48284 wxString const &arg8_defvalue = wxPyControlNameStr ;
48285 wxString *arg8 = (wxString *) &arg8_defvalue ;
48286 bool result;
48287 void *argp1 = 0 ;
48288 int res1 = 0 ;
48289 void *argp2 = 0 ;
48290 int res2 = 0 ;
48291 int val3 ;
48292 int ecode3 = 0 ;
48293 wxPoint temp4 ;
48294 wxSize temp5 ;
48295 long val6 ;
48296 int ecode6 = 0 ;
48297 void *argp7 = 0 ;
48298 int res7 = 0 ;
48299 bool temp8 = false ;
48300 PyObject * obj0 = 0 ;
48301 PyObject * obj1 = 0 ;
48302 PyObject * obj2 = 0 ;
48303 PyObject * obj3 = 0 ;
48304 PyObject * obj4 = 0 ;
48305 PyObject * obj5 = 0 ;
48306 PyObject * obj6 = 0 ;
48307 PyObject * obj7 = 0 ;
48308 char * kwnames[] = {
48309 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
48310 };
48311
48312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
48313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
48314 if (!SWIG_IsOK(res1)) {
48315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
48316 }
48317 arg1 = reinterpret_cast< wxControl * >(argp1);
48318 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48319 if (!SWIG_IsOK(res2)) {
48320 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
48321 }
48322 arg2 = reinterpret_cast< wxWindow * >(argp2);
48323 if (obj2) {
48324 ecode3 = SWIG_AsVal_int(obj2, &val3);
48325 if (!SWIG_IsOK(ecode3)) {
48326 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
48327 }
48328 arg3 = static_cast< int >(val3);
48329 }
48330 if (obj3) {
48331 {
48332 arg4 = &temp4;
48333 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
48334 }
48335 }
48336 if (obj4) {
48337 {
48338 arg5 = &temp5;
48339 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
48340 }
48341 }
48342 if (obj5) {
48343 ecode6 = SWIG_AsVal_long(obj5, &val6);
48344 if (!SWIG_IsOK(ecode6)) {
48345 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
48346 }
48347 arg6 = static_cast< long >(val6);
48348 }
48349 if (obj6) {
48350 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
48351 if (!SWIG_IsOK(res7)) {
48352 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
48353 }
48354 if (!argp7) {
48355 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
48356 }
48357 arg7 = reinterpret_cast< wxValidator * >(argp7);
48358 }
48359 if (obj7) {
48360 {
48361 arg8 = wxString_in_helper(obj7);
48362 if (arg8 == NULL) SWIG_fail;
48363 temp8 = true;
48364 }
48365 }
48366 {
48367 PyThreadState* __tstate = wxPyBeginAllowThreads();
48368 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
48369 wxPyEndAllowThreads(__tstate);
48370 if (PyErr_Occurred()) SWIG_fail;
48371 }
48372 {
48373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48374 }
48375 {
48376 if (temp8)
48377 delete arg8;
48378 }
48379 return resultobj;
48380 fail:
48381 {
48382 if (temp8)
48383 delete arg8;
48384 }
48385 return NULL;
48386 }
48387
48388
48389 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48390 PyObject *resultobj = 0;
48391 wxControl *arg1 = (wxControl *) 0 ;
48392 int result;
48393 void *argp1 = 0 ;
48394 int res1 = 0 ;
48395 PyObject *swig_obj[1] ;
48396
48397 if (!args) SWIG_fail;
48398 swig_obj[0] = args;
48399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
48400 if (!SWIG_IsOK(res1)) {
48401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
48402 }
48403 arg1 = reinterpret_cast< wxControl * >(argp1);
48404 {
48405 PyThreadState* __tstate = wxPyBeginAllowThreads();
48406 result = (int)((wxControl const *)arg1)->GetAlignment();
48407 wxPyEndAllowThreads(__tstate);
48408 if (PyErr_Occurred()) SWIG_fail;
48409 }
48410 resultobj = SWIG_From_int(static_cast< int >(result));
48411 return resultobj;
48412 fail:
48413 return NULL;
48414 }
48415
48416
48417 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48418 PyObject *resultobj = 0;
48419 wxControl *arg1 = (wxControl *) 0 ;
48420 wxString result;
48421 void *argp1 = 0 ;
48422 int res1 = 0 ;
48423 PyObject *swig_obj[1] ;
48424
48425 if (!args) SWIG_fail;
48426 swig_obj[0] = args;
48427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
48428 if (!SWIG_IsOK(res1)) {
48429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
48430 }
48431 arg1 = reinterpret_cast< wxControl * >(argp1);
48432 {
48433 PyThreadState* __tstate = wxPyBeginAllowThreads();
48434 result = ((wxControl const *)arg1)->GetLabelText();
48435 wxPyEndAllowThreads(__tstate);
48436 if (PyErr_Occurred()) SWIG_fail;
48437 }
48438 {
48439 #if wxUSE_UNICODE
48440 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48441 #else
48442 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48443 #endif
48444 }
48445 return resultobj;
48446 fail:
48447 return NULL;
48448 }
48449
48450
48451 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48452 PyObject *resultobj = 0;
48453 wxControl *arg1 = (wxControl *) 0 ;
48454 wxCommandEvent *arg2 = 0 ;
48455 void *argp1 = 0 ;
48456 int res1 = 0 ;
48457 void *argp2 = 0 ;
48458 int res2 = 0 ;
48459 PyObject * obj0 = 0 ;
48460 PyObject * obj1 = 0 ;
48461 char * kwnames[] = {
48462 (char *) "self",(char *) "event", NULL
48463 };
48464
48465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
48466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
48467 if (!SWIG_IsOK(res1)) {
48468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
48469 }
48470 arg1 = reinterpret_cast< wxControl * >(argp1);
48471 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
48472 if (!SWIG_IsOK(res2)) {
48473 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
48474 }
48475 if (!argp2) {
48476 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
48477 }
48478 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
48479 {
48480 PyThreadState* __tstate = wxPyBeginAllowThreads();
48481 (arg1)->Command(*arg2);
48482 wxPyEndAllowThreads(__tstate);
48483 if (PyErr_Occurred()) SWIG_fail;
48484 }
48485 resultobj = SWIG_Py_Void();
48486 return resultobj;
48487 fail:
48488 return NULL;
48489 }
48490
48491
48492 SWIGINTERN PyObject *_wrap_Control_RemoveMnemonics(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48493 PyObject *resultobj = 0;
48494 wxString *arg1 = 0 ;
48495 wxString result;
48496 bool temp1 = false ;
48497 PyObject * obj0 = 0 ;
48498 char * kwnames[] = {
48499 (char *) "str", NULL
48500 };
48501
48502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_RemoveMnemonics",kwnames,&obj0)) SWIG_fail;
48503 {
48504 arg1 = wxString_in_helper(obj0);
48505 if (arg1 == NULL) SWIG_fail;
48506 temp1 = true;
48507 }
48508 {
48509 PyThreadState* __tstate = wxPyBeginAllowThreads();
48510 result = wxControl::RemoveMnemonics((wxString const &)*arg1);
48511 wxPyEndAllowThreads(__tstate);
48512 if (PyErr_Occurred()) SWIG_fail;
48513 }
48514 {
48515 #if wxUSE_UNICODE
48516 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48517 #else
48518 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48519 #endif
48520 }
48521 {
48522 if (temp1)
48523 delete arg1;
48524 }
48525 return resultobj;
48526 fail:
48527 {
48528 if (temp1)
48529 delete arg1;
48530 }
48531 return NULL;
48532 }
48533
48534
48535 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48536 PyObject *resultobj = 0;
48537 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
48538 SwigValueWrapper<wxVisualAttributes > result;
48539 int val1 ;
48540 int ecode1 = 0 ;
48541 PyObject * obj0 = 0 ;
48542 char * kwnames[] = {
48543 (char *) "variant", NULL
48544 };
48545
48546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
48547 if (obj0) {
48548 ecode1 = SWIG_AsVal_int(obj0, &val1);
48549 if (!SWIG_IsOK(ecode1)) {
48550 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
48551 }
48552 arg1 = static_cast< wxWindowVariant >(val1);
48553 }
48554 {
48555 if (!wxPyCheckForApp()) SWIG_fail;
48556 PyThreadState* __tstate = wxPyBeginAllowThreads();
48557 result = wxControl::GetClassDefaultAttributes(arg1);
48558 wxPyEndAllowThreads(__tstate);
48559 if (PyErr_Occurred()) SWIG_fail;
48560 }
48561 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
48562 return resultobj;
48563 fail:
48564 return NULL;
48565 }
48566
48567
48568 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48569 PyObject *obj;
48570 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48571 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
48572 return SWIG_Py_Void();
48573 }
48574
48575 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48576 return SWIG_Python_InitShadowInstance(args);
48577 }
48578
48579 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48580 PyObject *resultobj = 0;
48581 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48582 wxString *arg2 = 0 ;
48583 PyObject *arg3 = (PyObject *) NULL ;
48584 int result;
48585 void *argp1 = 0 ;
48586 int res1 = 0 ;
48587 bool temp2 = false ;
48588 PyObject * obj0 = 0 ;
48589 PyObject * obj1 = 0 ;
48590 PyObject * obj2 = 0 ;
48591 char * kwnames[] = {
48592 (char *) "self",(char *) "item",(char *) "clientData", NULL
48593 };
48594
48595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48597 if (!SWIG_IsOK(res1)) {
48598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48599 }
48600 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48601 {
48602 arg2 = wxString_in_helper(obj1);
48603 if (arg2 == NULL) SWIG_fail;
48604 temp2 = true;
48605 }
48606 if (obj2) {
48607 arg3 = obj2;
48608 }
48609 {
48610 PyThreadState* __tstate = wxPyBeginAllowThreads();
48611 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
48612 wxPyEndAllowThreads(__tstate);
48613 if (PyErr_Occurred()) SWIG_fail;
48614 }
48615 resultobj = SWIG_From_int(static_cast< int >(result));
48616 {
48617 if (temp2)
48618 delete arg2;
48619 }
48620 return resultobj;
48621 fail:
48622 {
48623 if (temp2)
48624 delete arg2;
48625 }
48626 return NULL;
48627 }
48628
48629
48630 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48631 PyObject *resultobj = 0;
48632 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48633 wxArrayString *arg2 = 0 ;
48634 void *argp1 = 0 ;
48635 int res1 = 0 ;
48636 bool temp2 = false ;
48637 PyObject * obj0 = 0 ;
48638 PyObject * obj1 = 0 ;
48639 char * kwnames[] = {
48640 (char *) "self",(char *) "strings", NULL
48641 };
48642
48643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
48644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48645 if (!SWIG_IsOK(res1)) {
48646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48647 }
48648 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48649 {
48650 if (! PySequence_Check(obj1)) {
48651 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
48652 SWIG_fail;
48653 }
48654 arg2 = new wxArrayString;
48655 temp2 = true;
48656 int i, len=PySequence_Length(obj1);
48657 for (i=0; i<len; i++) {
48658 PyObject* item = PySequence_GetItem(obj1, i);
48659 wxString* s = wxString_in_helper(item);
48660 if (PyErr_Occurred()) SWIG_fail;
48661 arg2->Add(*s);
48662 delete s;
48663 Py_DECREF(item);
48664 }
48665 }
48666 {
48667 PyThreadState* __tstate = wxPyBeginAllowThreads();
48668 (arg1)->Append((wxArrayString const &)*arg2);
48669 wxPyEndAllowThreads(__tstate);
48670 if (PyErr_Occurred()) SWIG_fail;
48671 }
48672 resultobj = SWIG_Py_Void();
48673 {
48674 if (temp2) delete arg2;
48675 }
48676 return resultobj;
48677 fail:
48678 {
48679 if (temp2) delete arg2;
48680 }
48681 return NULL;
48682 }
48683
48684
48685 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48686 PyObject *resultobj = 0;
48687 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48688 wxString *arg2 = 0 ;
48689 int arg3 ;
48690 PyObject *arg4 = (PyObject *) NULL ;
48691 int result;
48692 void *argp1 = 0 ;
48693 int res1 = 0 ;
48694 bool temp2 = false ;
48695 int val3 ;
48696 int ecode3 = 0 ;
48697 PyObject * obj0 = 0 ;
48698 PyObject * obj1 = 0 ;
48699 PyObject * obj2 = 0 ;
48700 PyObject * obj3 = 0 ;
48701 char * kwnames[] = {
48702 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
48703 };
48704
48705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48707 if (!SWIG_IsOK(res1)) {
48708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48709 }
48710 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48711 {
48712 arg2 = wxString_in_helper(obj1);
48713 if (arg2 == NULL) SWIG_fail;
48714 temp2 = true;
48715 }
48716 ecode3 = SWIG_AsVal_int(obj2, &val3);
48717 if (!SWIG_IsOK(ecode3)) {
48718 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "int""'");
48719 }
48720 arg3 = static_cast< int >(val3);
48721 if (obj3) {
48722 arg4 = obj3;
48723 }
48724 {
48725 PyThreadState* __tstate = wxPyBeginAllowThreads();
48726 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
48727 wxPyEndAllowThreads(__tstate);
48728 if (PyErr_Occurred()) SWIG_fail;
48729 }
48730 resultobj = SWIG_From_int(static_cast< int >(result));
48731 {
48732 if (temp2)
48733 delete arg2;
48734 }
48735 return resultobj;
48736 fail:
48737 {
48738 if (temp2)
48739 delete arg2;
48740 }
48741 return NULL;
48742 }
48743
48744
48745 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48746 PyObject *resultobj = 0;
48747 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48748 void *argp1 = 0 ;
48749 int res1 = 0 ;
48750 PyObject *swig_obj[1] ;
48751
48752 if (!args) SWIG_fail;
48753 swig_obj[0] = args;
48754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48755 if (!SWIG_IsOK(res1)) {
48756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48757 }
48758 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48759 {
48760 PyThreadState* __tstate = wxPyBeginAllowThreads();
48761 (arg1)->Clear();
48762 wxPyEndAllowThreads(__tstate);
48763 if (PyErr_Occurred()) SWIG_fail;
48764 }
48765 resultobj = SWIG_Py_Void();
48766 return resultobj;
48767 fail:
48768 return NULL;
48769 }
48770
48771
48772 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48773 PyObject *resultobj = 0;
48774 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48775 int arg2 ;
48776 void *argp1 = 0 ;
48777 int res1 = 0 ;
48778 int val2 ;
48779 int ecode2 = 0 ;
48780 PyObject * obj0 = 0 ;
48781 PyObject * obj1 = 0 ;
48782 char * kwnames[] = {
48783 (char *) "self",(char *) "n", NULL
48784 };
48785
48786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
48787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48788 if (!SWIG_IsOK(res1)) {
48789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48790 }
48791 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48792 ecode2 = SWIG_AsVal_int(obj1, &val2);
48793 if (!SWIG_IsOK(ecode2)) {
48794 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "int""'");
48795 }
48796 arg2 = static_cast< int >(val2);
48797 {
48798 PyThreadState* __tstate = wxPyBeginAllowThreads();
48799 (arg1)->Delete(arg2);
48800 wxPyEndAllowThreads(__tstate);
48801 if (PyErr_Occurred()) SWIG_fail;
48802 }
48803 resultobj = SWIG_Py_Void();
48804 return resultobj;
48805 fail:
48806 return NULL;
48807 }
48808
48809
48810 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48811 PyObject *resultobj = 0;
48812 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48813 int arg2 ;
48814 PyObject *result = 0 ;
48815 void *argp1 = 0 ;
48816 int res1 = 0 ;
48817 int val2 ;
48818 int ecode2 = 0 ;
48819 PyObject * obj0 = 0 ;
48820 PyObject * obj1 = 0 ;
48821 char * kwnames[] = {
48822 (char *) "self",(char *) "n", NULL
48823 };
48824
48825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
48826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48827 if (!SWIG_IsOK(res1)) {
48828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48829 }
48830 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48831 ecode2 = SWIG_AsVal_int(obj1, &val2);
48832 if (!SWIG_IsOK(ecode2)) {
48833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "int""'");
48834 }
48835 arg2 = static_cast< int >(val2);
48836 {
48837 PyThreadState* __tstate = wxPyBeginAllowThreads();
48838 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
48839 wxPyEndAllowThreads(__tstate);
48840 if (PyErr_Occurred()) SWIG_fail;
48841 }
48842 resultobj = result;
48843 return resultobj;
48844 fail:
48845 return NULL;
48846 }
48847
48848
48849 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48850 PyObject *resultobj = 0;
48851 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48852 int arg2 ;
48853 PyObject *arg3 = (PyObject *) 0 ;
48854 void *argp1 = 0 ;
48855 int res1 = 0 ;
48856 int val2 ;
48857 int ecode2 = 0 ;
48858 PyObject * obj0 = 0 ;
48859 PyObject * obj1 = 0 ;
48860 PyObject * obj2 = 0 ;
48861 char * kwnames[] = {
48862 (char *) "self",(char *) "n",(char *) "clientData", NULL
48863 };
48864
48865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48867 if (!SWIG_IsOK(res1)) {
48868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48869 }
48870 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48871 ecode2 = SWIG_AsVal_int(obj1, &val2);
48872 if (!SWIG_IsOK(ecode2)) {
48873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "int""'");
48874 }
48875 arg2 = static_cast< int >(val2);
48876 arg3 = obj2;
48877 {
48878 PyThreadState* __tstate = wxPyBeginAllowThreads();
48879 wxItemContainer_SetClientData(arg1,arg2,arg3);
48880 wxPyEndAllowThreads(__tstate);
48881 if (PyErr_Occurred()) SWIG_fail;
48882 }
48883 resultobj = SWIG_Py_Void();
48884 return resultobj;
48885 fail:
48886 return NULL;
48887 }
48888
48889
48890 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48891 PyObject *resultobj = 0;
48892 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48893 int result;
48894 void *argp1 = 0 ;
48895 int res1 = 0 ;
48896 PyObject *swig_obj[1] ;
48897
48898 if (!args) SWIG_fail;
48899 swig_obj[0] = args;
48900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48901 if (!SWIG_IsOK(res1)) {
48902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48903 }
48904 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48905 {
48906 PyThreadState* __tstate = wxPyBeginAllowThreads();
48907 result = (int)((wxItemContainer const *)arg1)->GetCount();
48908 wxPyEndAllowThreads(__tstate);
48909 if (PyErr_Occurred()) SWIG_fail;
48910 }
48911 resultobj = SWIG_From_int(static_cast< int >(result));
48912 return resultobj;
48913 fail:
48914 return NULL;
48915 }
48916
48917
48918 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48919 PyObject *resultobj = 0;
48920 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48921 bool result;
48922 void *argp1 = 0 ;
48923 int res1 = 0 ;
48924 PyObject *swig_obj[1] ;
48925
48926 if (!args) SWIG_fail;
48927 swig_obj[0] = args;
48928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48929 if (!SWIG_IsOK(res1)) {
48930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48931 }
48932 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48933 {
48934 PyThreadState* __tstate = wxPyBeginAllowThreads();
48935 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
48936 wxPyEndAllowThreads(__tstate);
48937 if (PyErr_Occurred()) SWIG_fail;
48938 }
48939 {
48940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48941 }
48942 return resultobj;
48943 fail:
48944 return NULL;
48945 }
48946
48947
48948 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48949 PyObject *resultobj = 0;
48950 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48951 int arg2 ;
48952 wxString result;
48953 void *argp1 = 0 ;
48954 int res1 = 0 ;
48955 int val2 ;
48956 int ecode2 = 0 ;
48957 PyObject * obj0 = 0 ;
48958 PyObject * obj1 = 0 ;
48959 char * kwnames[] = {
48960 (char *) "self",(char *) "n", NULL
48961 };
48962
48963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
48964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48965 if (!SWIG_IsOK(res1)) {
48966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48967 }
48968 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48969 ecode2 = SWIG_AsVal_int(obj1, &val2);
48970 if (!SWIG_IsOK(ecode2)) {
48971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "int""'");
48972 }
48973 arg2 = static_cast< int >(val2);
48974 {
48975 PyThreadState* __tstate = wxPyBeginAllowThreads();
48976 result = ((wxItemContainer const *)arg1)->GetString(arg2);
48977 wxPyEndAllowThreads(__tstate);
48978 if (PyErr_Occurred()) SWIG_fail;
48979 }
48980 {
48981 #if wxUSE_UNICODE
48982 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48983 #else
48984 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48985 #endif
48986 }
48987 return resultobj;
48988 fail:
48989 return NULL;
48990 }
48991
48992
48993 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48994 PyObject *resultobj = 0;
48995 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48996 wxArrayString result;
48997 void *argp1 = 0 ;
48998 int res1 = 0 ;
48999 PyObject *swig_obj[1] ;
49000
49001 if (!args) SWIG_fail;
49002 swig_obj[0] = args;
49003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49004 if (!SWIG_IsOK(res1)) {
49005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
49006 }
49007 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49008 {
49009 PyThreadState* __tstate = wxPyBeginAllowThreads();
49010 result = ((wxItemContainer const *)arg1)->GetStrings();
49011 wxPyEndAllowThreads(__tstate);
49012 if (PyErr_Occurred()) SWIG_fail;
49013 }
49014 {
49015 resultobj = wxArrayString2PyList_helper(result);
49016 }
49017 return resultobj;
49018 fail:
49019 return NULL;
49020 }
49021
49022
49023 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49024 PyObject *resultobj = 0;
49025 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
49026 int arg2 ;
49027 wxString *arg3 = 0 ;
49028 void *argp1 = 0 ;
49029 int res1 = 0 ;
49030 int val2 ;
49031 int ecode2 = 0 ;
49032 bool temp3 = false ;
49033 PyObject * obj0 = 0 ;
49034 PyObject * obj1 = 0 ;
49035 PyObject * obj2 = 0 ;
49036 char * kwnames[] = {
49037 (char *) "self",(char *) "n",(char *) "s", NULL
49038 };
49039
49040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49042 if (!SWIG_IsOK(res1)) {
49043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
49044 }
49045 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49046 ecode2 = SWIG_AsVal_int(obj1, &val2);
49047 if (!SWIG_IsOK(ecode2)) {
49048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "int""'");
49049 }
49050 arg2 = static_cast< int >(val2);
49051 {
49052 arg3 = wxString_in_helper(obj2);
49053 if (arg3 == NULL) SWIG_fail;
49054 temp3 = true;
49055 }
49056 {
49057 PyThreadState* __tstate = wxPyBeginAllowThreads();
49058 (arg1)->SetString(arg2,(wxString const &)*arg3);
49059 wxPyEndAllowThreads(__tstate);
49060 if (PyErr_Occurred()) SWIG_fail;
49061 }
49062 resultobj = SWIG_Py_Void();
49063 {
49064 if (temp3)
49065 delete arg3;
49066 }
49067 return resultobj;
49068 fail:
49069 {
49070 if (temp3)
49071 delete arg3;
49072 }
49073 return NULL;
49074 }
49075
49076
49077 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49078 PyObject *resultobj = 0;
49079 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
49080 wxString *arg2 = 0 ;
49081 int result;
49082 void *argp1 = 0 ;
49083 int res1 = 0 ;
49084 bool temp2 = false ;
49085 PyObject * obj0 = 0 ;
49086 PyObject * obj1 = 0 ;
49087 char * kwnames[] = {
49088 (char *) "self",(char *) "s", NULL
49089 };
49090
49091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
49092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49093 if (!SWIG_IsOK(res1)) {
49094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
49095 }
49096 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49097 {
49098 arg2 = wxString_in_helper(obj1);
49099 if (arg2 == NULL) SWIG_fail;
49100 temp2 = true;
49101 }
49102 {
49103 PyThreadState* __tstate = wxPyBeginAllowThreads();
49104 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
49105 wxPyEndAllowThreads(__tstate);
49106 if (PyErr_Occurred()) SWIG_fail;
49107 }
49108 resultobj = SWIG_From_int(static_cast< int >(result));
49109 {
49110 if (temp2)
49111 delete arg2;
49112 }
49113 return resultobj;
49114 fail:
49115 {
49116 if (temp2)
49117 delete arg2;
49118 }
49119 return NULL;
49120 }
49121
49122
49123 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49124 PyObject *resultobj = 0;
49125 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
49126 int arg2 ;
49127 void *argp1 = 0 ;
49128 int res1 = 0 ;
49129 int val2 ;
49130 int ecode2 = 0 ;
49131 PyObject * obj0 = 0 ;
49132 PyObject * obj1 = 0 ;
49133 char * kwnames[] = {
49134 (char *) "self",(char *) "n", NULL
49135 };
49136
49137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
49138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49139 if (!SWIG_IsOK(res1)) {
49140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
49141 }
49142 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49143 ecode2 = SWIG_AsVal_int(obj1, &val2);
49144 if (!SWIG_IsOK(ecode2)) {
49145 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
49146 }
49147 arg2 = static_cast< int >(val2);
49148 {
49149 PyThreadState* __tstate = wxPyBeginAllowThreads();
49150 (arg1)->SetSelection(arg2);
49151 wxPyEndAllowThreads(__tstate);
49152 if (PyErr_Occurred()) SWIG_fail;
49153 }
49154 resultobj = SWIG_Py_Void();
49155 return resultobj;
49156 fail:
49157 return NULL;
49158 }
49159
49160
49161 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49162 PyObject *resultobj = 0;
49163 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
49164 int result;
49165 void *argp1 = 0 ;
49166 int res1 = 0 ;
49167 PyObject *swig_obj[1] ;
49168
49169 if (!args) SWIG_fail;
49170 swig_obj[0] = args;
49171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49172 if (!SWIG_IsOK(res1)) {
49173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
49174 }
49175 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49176 {
49177 PyThreadState* __tstate = wxPyBeginAllowThreads();
49178 result = (int)((wxItemContainer const *)arg1)->GetSelection();
49179 wxPyEndAllowThreads(__tstate);
49180 if (PyErr_Occurred()) SWIG_fail;
49181 }
49182 resultobj = SWIG_From_int(static_cast< int >(result));
49183 return resultobj;
49184 fail:
49185 return NULL;
49186 }
49187
49188
49189 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49190 PyObject *resultobj = 0;
49191 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
49192 wxString *arg2 = 0 ;
49193 bool result;
49194 void *argp1 = 0 ;
49195 int res1 = 0 ;
49196 bool temp2 = false ;
49197 PyObject * obj0 = 0 ;
49198 PyObject * obj1 = 0 ;
49199 char * kwnames[] = {
49200 (char *) "self",(char *) "s", NULL
49201 };
49202
49203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
49204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49205 if (!SWIG_IsOK(res1)) {
49206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
49207 }
49208 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49209 {
49210 arg2 = wxString_in_helper(obj1);
49211 if (arg2 == NULL) SWIG_fail;
49212 temp2 = true;
49213 }
49214 {
49215 PyThreadState* __tstate = wxPyBeginAllowThreads();
49216 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
49217 wxPyEndAllowThreads(__tstate);
49218 if (PyErr_Occurred()) SWIG_fail;
49219 }
49220 {
49221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49222 }
49223 {
49224 if (temp2)
49225 delete arg2;
49226 }
49227 return resultobj;
49228 fail:
49229 {
49230 if (temp2)
49231 delete arg2;
49232 }
49233 return NULL;
49234 }
49235
49236
49237 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49238 PyObject *resultobj = 0;
49239 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
49240 wxString result;
49241 void *argp1 = 0 ;
49242 int res1 = 0 ;
49243 PyObject *swig_obj[1] ;
49244
49245 if (!args) SWIG_fail;
49246 swig_obj[0] = args;
49247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49248 if (!SWIG_IsOK(res1)) {
49249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
49250 }
49251 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49252 {
49253 PyThreadState* __tstate = wxPyBeginAllowThreads();
49254 result = ((wxItemContainer const *)arg1)->GetStringSelection();
49255 wxPyEndAllowThreads(__tstate);
49256 if (PyErr_Occurred()) SWIG_fail;
49257 }
49258 {
49259 #if wxUSE_UNICODE
49260 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
49261 #else
49262 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
49263 #endif
49264 }
49265 return resultobj;
49266 fail:
49267 return NULL;
49268 }
49269
49270
49271 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49272 PyObject *resultobj = 0;
49273 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
49274 int arg2 ;
49275 void *argp1 = 0 ;
49276 int res1 = 0 ;
49277 int val2 ;
49278 int ecode2 = 0 ;
49279 PyObject * obj0 = 0 ;
49280 PyObject * obj1 = 0 ;
49281 char * kwnames[] = {
49282 (char *) "self",(char *) "n", NULL
49283 };
49284
49285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
49286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49287 if (!SWIG_IsOK(res1)) {
49288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
49289 }
49290 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49291 ecode2 = SWIG_AsVal_int(obj1, &val2);
49292 if (!SWIG_IsOK(ecode2)) {
49293 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
49294 }
49295 arg2 = static_cast< int >(val2);
49296 {
49297 PyThreadState* __tstate = wxPyBeginAllowThreads();
49298 (arg1)->Select(arg2);
49299 wxPyEndAllowThreads(__tstate);
49300 if (PyErr_Occurred()) SWIG_fail;
49301 }
49302 resultobj = SWIG_Py_Void();
49303 return resultobj;
49304 fail:
49305 return NULL;
49306 }
49307
49308
49309 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49310 PyObject *obj;
49311 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49312 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
49313 return SWIG_Py_Void();
49314 }
49315
49316 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49317 PyObject *obj;
49318 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49319 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
49320 return SWIG_Py_Void();
49321 }
49322
49323 SWIGINTERN PyObject *_wrap_new_SizerFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49324 PyObject *resultobj = 0;
49325 int arg1 = (int) 0 ;
49326 wxSizerFlags *result = 0 ;
49327 int val1 ;
49328 int ecode1 = 0 ;
49329 PyObject * obj0 = 0 ;
49330 char * kwnames[] = {
49331 (char *) "proportion", NULL
49332 };
49333
49334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_SizerFlags",kwnames,&obj0)) SWIG_fail;
49335 if (obj0) {
49336 ecode1 = SWIG_AsVal_int(obj0, &val1);
49337 if (!SWIG_IsOK(ecode1)) {
49338 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerFlags" "', expected argument " "1"" of type '" "int""'");
49339 }
49340 arg1 = static_cast< int >(val1);
49341 }
49342 {
49343 PyThreadState* __tstate = wxPyBeginAllowThreads();
49344 result = (wxSizerFlags *)new wxSizerFlags(arg1);
49345 wxPyEndAllowThreads(__tstate);
49346 if (PyErr_Occurred()) SWIG_fail;
49347 }
49348 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerFlags, SWIG_POINTER_NEW | 0 );
49349 return resultobj;
49350 fail:
49351 return NULL;
49352 }
49353
49354
49355 SWIGINTERN PyObject *_wrap_delete_SizerFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49356 PyObject *resultobj = 0;
49357 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49358 void *argp1 = 0 ;
49359 int res1 = 0 ;
49360 PyObject *swig_obj[1] ;
49361
49362 if (!args) SWIG_fail;
49363 swig_obj[0] = args;
49364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, SWIG_POINTER_DISOWN | 0 );
49365 if (!SWIG_IsOK(res1)) {
49366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerFlags" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49367 }
49368 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49369 {
49370 PyThreadState* __tstate = wxPyBeginAllowThreads();
49371 delete arg1;
49372
49373 wxPyEndAllowThreads(__tstate);
49374 if (PyErr_Occurred()) SWIG_fail;
49375 }
49376 resultobj = SWIG_Py_Void();
49377 return resultobj;
49378 fail:
49379 return NULL;
49380 }
49381
49382
49383 SWIGINTERN PyObject *_wrap_SizerFlags_Proportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49384 PyObject *resultobj = 0;
49385 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49386 int arg2 ;
49387 wxSizerFlags *result = 0 ;
49388 void *argp1 = 0 ;
49389 int res1 = 0 ;
49390 int val2 ;
49391 int ecode2 = 0 ;
49392 PyObject * obj0 = 0 ;
49393 PyObject * obj1 = 0 ;
49394 char * kwnames[] = {
49395 (char *) "self",(char *) "proportion", NULL
49396 };
49397
49398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerFlags_Proportion",kwnames,&obj0,&obj1)) SWIG_fail;
49399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49400 if (!SWIG_IsOK(res1)) {
49401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Proportion" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49402 }
49403 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49404 ecode2 = SWIG_AsVal_int(obj1, &val2);
49405 if (!SWIG_IsOK(ecode2)) {
49406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_Proportion" "', expected argument " "2"" of type '" "int""'");
49407 }
49408 arg2 = static_cast< int >(val2);
49409 {
49410 PyThreadState* __tstate = wxPyBeginAllowThreads();
49411 {
49412 wxSizerFlags &_result_ref = (arg1)->Proportion(arg2);
49413 result = (wxSizerFlags *) &_result_ref;
49414 }
49415 wxPyEndAllowThreads(__tstate);
49416 if (PyErr_Occurred()) SWIG_fail;
49417 }
49418 {
49419 resultobj = obj0; Py_INCREF(resultobj);
49420 }
49421 return resultobj;
49422 fail:
49423 return NULL;
49424 }
49425
49426
49427 SWIGINTERN PyObject *_wrap_SizerFlags_Align(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49428 PyObject *resultobj = 0;
49429 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49430 int arg2 ;
49431 wxSizerFlags *result = 0 ;
49432 void *argp1 = 0 ;
49433 int res1 = 0 ;
49434 int val2 ;
49435 int ecode2 = 0 ;
49436 PyObject * obj0 = 0 ;
49437 PyObject * obj1 = 0 ;
49438 char * kwnames[] = {
49439 (char *) "self",(char *) "alignment", NULL
49440 };
49441
49442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerFlags_Align",kwnames,&obj0,&obj1)) SWIG_fail;
49443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49444 if (!SWIG_IsOK(res1)) {
49445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Align" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49446 }
49447 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49448 ecode2 = SWIG_AsVal_int(obj1, &val2);
49449 if (!SWIG_IsOK(ecode2)) {
49450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_Align" "', expected argument " "2"" of type '" "int""'");
49451 }
49452 arg2 = static_cast< int >(val2);
49453 {
49454 PyThreadState* __tstate = wxPyBeginAllowThreads();
49455 {
49456 wxSizerFlags &_result_ref = (arg1)->Align(arg2);
49457 result = (wxSizerFlags *) &_result_ref;
49458 }
49459 wxPyEndAllowThreads(__tstate);
49460 if (PyErr_Occurred()) SWIG_fail;
49461 }
49462 {
49463 resultobj = obj0; Py_INCREF(resultobj);
49464 }
49465 return resultobj;
49466 fail:
49467 return NULL;
49468 }
49469
49470
49471 SWIGINTERN PyObject *_wrap_SizerFlags_Expand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49472 PyObject *resultobj = 0;
49473 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49474 wxSizerFlags *result = 0 ;
49475 void *argp1 = 0 ;
49476 int res1 = 0 ;
49477 PyObject *swig_obj[1] ;
49478
49479 if (!args) SWIG_fail;
49480 swig_obj[0] = args;
49481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49482 if (!SWIG_IsOK(res1)) {
49483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Expand" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49484 }
49485 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49486 {
49487 PyThreadState* __tstate = wxPyBeginAllowThreads();
49488 {
49489 wxSizerFlags &_result_ref = (arg1)->Expand();
49490 result = (wxSizerFlags *) &_result_ref;
49491 }
49492 wxPyEndAllowThreads(__tstate);
49493 if (PyErr_Occurred()) SWIG_fail;
49494 }
49495 {
49496 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49497 }
49498 return resultobj;
49499 fail:
49500 return NULL;
49501 }
49502
49503
49504 SWIGINTERN PyObject *_wrap_SizerFlags_Centre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49505 PyObject *resultobj = 0;
49506 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49507 wxSizerFlags *result = 0 ;
49508 void *argp1 = 0 ;
49509 int res1 = 0 ;
49510 PyObject *swig_obj[1] ;
49511
49512 if (!args) SWIG_fail;
49513 swig_obj[0] = args;
49514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49515 if (!SWIG_IsOK(res1)) {
49516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Centre" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49517 }
49518 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49519 {
49520 PyThreadState* __tstate = wxPyBeginAllowThreads();
49521 {
49522 wxSizerFlags &_result_ref = (arg1)->Centre();
49523 result = (wxSizerFlags *) &_result_ref;
49524 }
49525 wxPyEndAllowThreads(__tstate);
49526 if (PyErr_Occurred()) SWIG_fail;
49527 }
49528 {
49529 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49530 }
49531 return resultobj;
49532 fail:
49533 return NULL;
49534 }
49535
49536
49537 SWIGINTERN PyObject *_wrap_SizerFlags_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49538 PyObject *resultobj = 0;
49539 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49540 wxSizerFlags *result = 0 ;
49541 void *argp1 = 0 ;
49542 int res1 = 0 ;
49543 PyObject *swig_obj[1] ;
49544
49545 if (!args) SWIG_fail;
49546 swig_obj[0] = args;
49547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49548 if (!SWIG_IsOK(res1)) {
49549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Center" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49550 }
49551 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49552 {
49553 PyThreadState* __tstate = wxPyBeginAllowThreads();
49554 {
49555 wxSizerFlags &_result_ref = (arg1)->Center();
49556 result = (wxSizerFlags *) &_result_ref;
49557 }
49558 wxPyEndAllowThreads(__tstate);
49559 if (PyErr_Occurred()) SWIG_fail;
49560 }
49561 {
49562 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49563 }
49564 return resultobj;
49565 fail:
49566 return NULL;
49567 }
49568
49569
49570 SWIGINTERN PyObject *_wrap_SizerFlags_Left(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49571 PyObject *resultobj = 0;
49572 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49573 wxSizerFlags *result = 0 ;
49574 void *argp1 = 0 ;
49575 int res1 = 0 ;
49576 PyObject *swig_obj[1] ;
49577
49578 if (!args) SWIG_fail;
49579 swig_obj[0] = args;
49580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49581 if (!SWIG_IsOK(res1)) {
49582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Left" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49583 }
49584 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49585 {
49586 PyThreadState* __tstate = wxPyBeginAllowThreads();
49587 {
49588 wxSizerFlags &_result_ref = (arg1)->Left();
49589 result = (wxSizerFlags *) &_result_ref;
49590 }
49591 wxPyEndAllowThreads(__tstate);
49592 if (PyErr_Occurred()) SWIG_fail;
49593 }
49594 {
49595 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49596 }
49597 return resultobj;
49598 fail:
49599 return NULL;
49600 }
49601
49602
49603 SWIGINTERN PyObject *_wrap_SizerFlags_Right(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49604 PyObject *resultobj = 0;
49605 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49606 wxSizerFlags *result = 0 ;
49607 void *argp1 = 0 ;
49608 int res1 = 0 ;
49609 PyObject *swig_obj[1] ;
49610
49611 if (!args) SWIG_fail;
49612 swig_obj[0] = args;
49613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49614 if (!SWIG_IsOK(res1)) {
49615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Right" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49616 }
49617 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49618 {
49619 PyThreadState* __tstate = wxPyBeginAllowThreads();
49620 {
49621 wxSizerFlags &_result_ref = (arg1)->Right();
49622 result = (wxSizerFlags *) &_result_ref;
49623 }
49624 wxPyEndAllowThreads(__tstate);
49625 if (PyErr_Occurred()) SWIG_fail;
49626 }
49627 {
49628 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49629 }
49630 return resultobj;
49631 fail:
49632 return NULL;
49633 }
49634
49635
49636 SWIGINTERN PyObject *_wrap_SizerFlags_Top(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49637 PyObject *resultobj = 0;
49638 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49639 wxSizerFlags *result = 0 ;
49640 void *argp1 = 0 ;
49641 int res1 = 0 ;
49642 PyObject *swig_obj[1] ;
49643
49644 if (!args) SWIG_fail;
49645 swig_obj[0] = args;
49646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49647 if (!SWIG_IsOK(res1)) {
49648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Top" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49649 }
49650 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49651 {
49652 PyThreadState* __tstate = wxPyBeginAllowThreads();
49653 {
49654 wxSizerFlags &_result_ref = (arg1)->Top();
49655 result = (wxSizerFlags *) &_result_ref;
49656 }
49657 wxPyEndAllowThreads(__tstate);
49658 if (PyErr_Occurred()) SWIG_fail;
49659 }
49660 {
49661 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49662 }
49663 return resultobj;
49664 fail:
49665 return NULL;
49666 }
49667
49668
49669 SWIGINTERN PyObject *_wrap_SizerFlags_Bottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49670 PyObject *resultobj = 0;
49671 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49672 wxSizerFlags *result = 0 ;
49673 void *argp1 = 0 ;
49674 int res1 = 0 ;
49675 PyObject *swig_obj[1] ;
49676
49677 if (!args) SWIG_fail;
49678 swig_obj[0] = args;
49679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49680 if (!SWIG_IsOK(res1)) {
49681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Bottom" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49682 }
49683 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49684 {
49685 PyThreadState* __tstate = wxPyBeginAllowThreads();
49686 {
49687 wxSizerFlags &_result_ref = (arg1)->Bottom();
49688 result = (wxSizerFlags *) &_result_ref;
49689 }
49690 wxPyEndAllowThreads(__tstate);
49691 if (PyErr_Occurred()) SWIG_fail;
49692 }
49693 {
49694 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49695 }
49696 return resultobj;
49697 fail:
49698 return NULL;
49699 }
49700
49701
49702 SWIGINTERN PyObject *_wrap_SizerFlags_Shaped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49703 PyObject *resultobj = 0;
49704 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49705 wxSizerFlags *result = 0 ;
49706 void *argp1 = 0 ;
49707 int res1 = 0 ;
49708 PyObject *swig_obj[1] ;
49709
49710 if (!args) SWIG_fail;
49711 swig_obj[0] = args;
49712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49713 if (!SWIG_IsOK(res1)) {
49714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Shaped" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49715 }
49716 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49717 {
49718 PyThreadState* __tstate = wxPyBeginAllowThreads();
49719 {
49720 wxSizerFlags &_result_ref = (arg1)->Shaped();
49721 result = (wxSizerFlags *) &_result_ref;
49722 }
49723 wxPyEndAllowThreads(__tstate);
49724 if (PyErr_Occurred()) SWIG_fail;
49725 }
49726 {
49727 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49728 }
49729 return resultobj;
49730 fail:
49731 return NULL;
49732 }
49733
49734
49735 SWIGINTERN PyObject *_wrap_SizerFlags_FixedMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49736 PyObject *resultobj = 0;
49737 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49738 wxSizerFlags *result = 0 ;
49739 void *argp1 = 0 ;
49740 int res1 = 0 ;
49741 PyObject *swig_obj[1] ;
49742
49743 if (!args) SWIG_fail;
49744 swig_obj[0] = args;
49745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49746 if (!SWIG_IsOK(res1)) {
49747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_FixedMinSize" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49748 }
49749 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49750 {
49751 PyThreadState* __tstate = wxPyBeginAllowThreads();
49752 {
49753 wxSizerFlags &_result_ref = (arg1)->FixedMinSize();
49754 result = (wxSizerFlags *) &_result_ref;
49755 }
49756 wxPyEndAllowThreads(__tstate);
49757 if (PyErr_Occurred()) SWIG_fail;
49758 }
49759 {
49760 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49761 }
49762 return resultobj;
49763 fail:
49764 return NULL;
49765 }
49766
49767
49768 SWIGINTERN PyObject *_wrap_SizerFlags_Border(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49769 PyObject *resultobj = 0;
49770 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49771 int arg2 = (int) wxALL ;
49772 int arg3 = (int) -1 ;
49773 wxSizerFlags *result = 0 ;
49774 void *argp1 = 0 ;
49775 int res1 = 0 ;
49776 int val2 ;
49777 int ecode2 = 0 ;
49778 int val3 ;
49779 int ecode3 = 0 ;
49780 PyObject * obj0 = 0 ;
49781 PyObject * obj1 = 0 ;
49782 PyObject * obj2 = 0 ;
49783 char * kwnames[] = {
49784 (char *) "self",(char *) "direction",(char *) "borderInPixels", NULL
49785 };
49786
49787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:SizerFlags_Border",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49789 if (!SWIG_IsOK(res1)) {
49790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Border" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49791 }
49792 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49793 if (obj1) {
49794 ecode2 = SWIG_AsVal_int(obj1, &val2);
49795 if (!SWIG_IsOK(ecode2)) {
49796 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_Border" "', expected argument " "2"" of type '" "int""'");
49797 }
49798 arg2 = static_cast< int >(val2);
49799 }
49800 if (obj2) {
49801 ecode3 = SWIG_AsVal_int(obj2, &val3);
49802 if (!SWIG_IsOK(ecode3)) {
49803 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerFlags_Border" "', expected argument " "3"" of type '" "int""'");
49804 }
49805 arg3 = static_cast< int >(val3);
49806 }
49807 {
49808 PyThreadState* __tstate = wxPyBeginAllowThreads();
49809 {
49810 wxSizerFlags &_result_ref = wxSizerFlags_Border(arg1,arg2,arg3);
49811 result = (wxSizerFlags *) &_result_ref;
49812 }
49813 wxPyEndAllowThreads(__tstate);
49814 if (PyErr_Occurred()) SWIG_fail;
49815 }
49816 {
49817 resultobj = obj0; Py_INCREF(resultobj);
49818 }
49819 return resultobj;
49820 fail:
49821 return NULL;
49822 }
49823
49824
49825 SWIGINTERN PyObject *_wrap_SizerFlags_DoubleBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49826 PyObject *resultobj = 0;
49827 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49828 int arg2 = (int) wxALL ;
49829 wxSizerFlags *result = 0 ;
49830 void *argp1 = 0 ;
49831 int res1 = 0 ;
49832 int val2 ;
49833 int ecode2 = 0 ;
49834 PyObject * obj0 = 0 ;
49835 PyObject * obj1 = 0 ;
49836 char * kwnames[] = {
49837 (char *) "self",(char *) "direction", NULL
49838 };
49839
49840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SizerFlags_DoubleBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49842 if (!SWIG_IsOK(res1)) {
49843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_DoubleBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49844 }
49845 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49846 if (obj1) {
49847 ecode2 = SWIG_AsVal_int(obj1, &val2);
49848 if (!SWIG_IsOK(ecode2)) {
49849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_DoubleBorder" "', expected argument " "2"" of type '" "int""'");
49850 }
49851 arg2 = static_cast< int >(val2);
49852 }
49853 {
49854 PyThreadState* __tstate = wxPyBeginAllowThreads();
49855 {
49856 wxSizerFlags &_result_ref = (arg1)->DoubleBorder(arg2);
49857 result = (wxSizerFlags *) &_result_ref;
49858 }
49859 wxPyEndAllowThreads(__tstate);
49860 if (PyErr_Occurred()) SWIG_fail;
49861 }
49862 {
49863 resultobj = obj0; Py_INCREF(resultobj);
49864 }
49865 return resultobj;
49866 fail:
49867 return NULL;
49868 }
49869
49870
49871 SWIGINTERN PyObject *_wrap_SizerFlags_TripleBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49872 PyObject *resultobj = 0;
49873 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49874 int arg2 = (int) wxALL ;
49875 wxSizerFlags *result = 0 ;
49876 void *argp1 = 0 ;
49877 int res1 = 0 ;
49878 int val2 ;
49879 int ecode2 = 0 ;
49880 PyObject * obj0 = 0 ;
49881 PyObject * obj1 = 0 ;
49882 char * kwnames[] = {
49883 (char *) "self",(char *) "direction", NULL
49884 };
49885
49886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SizerFlags_TripleBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49888 if (!SWIG_IsOK(res1)) {
49889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_TripleBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49890 }
49891 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49892 if (obj1) {
49893 ecode2 = SWIG_AsVal_int(obj1, &val2);
49894 if (!SWIG_IsOK(ecode2)) {
49895 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_TripleBorder" "', expected argument " "2"" of type '" "int""'");
49896 }
49897 arg2 = static_cast< int >(val2);
49898 }
49899 {
49900 PyThreadState* __tstate = wxPyBeginAllowThreads();
49901 {
49902 wxSizerFlags &_result_ref = (arg1)->TripleBorder(arg2);
49903 result = (wxSizerFlags *) &_result_ref;
49904 }
49905 wxPyEndAllowThreads(__tstate);
49906 if (PyErr_Occurred()) SWIG_fail;
49907 }
49908 {
49909 resultobj = obj0; Py_INCREF(resultobj);
49910 }
49911 return resultobj;
49912 fail:
49913 return NULL;
49914 }
49915
49916
49917 SWIGINTERN PyObject *_wrap_SizerFlags_HorzBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49918 PyObject *resultobj = 0;
49919 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49920 wxSizerFlags *result = 0 ;
49921 void *argp1 = 0 ;
49922 int res1 = 0 ;
49923 PyObject *swig_obj[1] ;
49924
49925 if (!args) SWIG_fail;
49926 swig_obj[0] = args;
49927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49928 if (!SWIG_IsOK(res1)) {
49929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_HorzBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49930 }
49931 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49932 {
49933 PyThreadState* __tstate = wxPyBeginAllowThreads();
49934 {
49935 wxSizerFlags &_result_ref = (arg1)->HorzBorder();
49936 result = (wxSizerFlags *) &_result_ref;
49937 }
49938 wxPyEndAllowThreads(__tstate);
49939 if (PyErr_Occurred()) SWIG_fail;
49940 }
49941 {
49942 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49943 }
49944 return resultobj;
49945 fail:
49946 return NULL;
49947 }
49948
49949
49950 SWIGINTERN PyObject *_wrap_SizerFlags_DoubleHorzBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49951 PyObject *resultobj = 0;
49952 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49953 wxSizerFlags *result = 0 ;
49954 void *argp1 = 0 ;
49955 int res1 = 0 ;
49956 PyObject *swig_obj[1] ;
49957
49958 if (!args) SWIG_fail;
49959 swig_obj[0] = args;
49960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49961 if (!SWIG_IsOK(res1)) {
49962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_DoubleHorzBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49963 }
49964 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49965 {
49966 PyThreadState* __tstate = wxPyBeginAllowThreads();
49967 {
49968 wxSizerFlags &_result_ref = (arg1)->DoubleHorzBorder();
49969 result = (wxSizerFlags *) &_result_ref;
49970 }
49971 wxPyEndAllowThreads(__tstate);
49972 if (PyErr_Occurred()) SWIG_fail;
49973 }
49974 {
49975 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49976 }
49977 return resultobj;
49978 fail:
49979 return NULL;
49980 }
49981
49982
49983 SWIGINTERN PyObject *_wrap_SizerFlags_GetDefaultBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49984 PyObject *resultobj = 0;
49985 int result;
49986
49987 if (!SWIG_Python_UnpackTuple(args,"SizerFlags_GetDefaultBorder",0,0,0)) SWIG_fail;
49988 {
49989 PyThreadState* __tstate = wxPyBeginAllowThreads();
49990 result = (int)wxSizerFlags::GetDefaultBorder();
49991 wxPyEndAllowThreads(__tstate);
49992 if (PyErr_Occurred()) SWIG_fail;
49993 }
49994 resultobj = SWIG_From_int(static_cast< int >(result));
49995 return resultobj;
49996 fail:
49997 return NULL;
49998 }
49999
50000
50001 SWIGINTERN PyObject *_wrap_SizerFlags_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50002 PyObject *resultobj = 0;
50003 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
50004 int result;
50005 void *argp1 = 0 ;
50006 int res1 = 0 ;
50007 PyObject *swig_obj[1] ;
50008
50009 if (!args) SWIG_fail;
50010 swig_obj[0] = args;
50011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
50012 if (!SWIG_IsOK(res1)) {
50013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_GetProportion" "', expected argument " "1"" of type '" "wxSizerFlags const *""'");
50014 }
50015 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
50016 {
50017 PyThreadState* __tstate = wxPyBeginAllowThreads();
50018 result = (int)((wxSizerFlags const *)arg1)->GetProportion();
50019 wxPyEndAllowThreads(__tstate);
50020 if (PyErr_Occurred()) SWIG_fail;
50021 }
50022 resultobj = SWIG_From_int(static_cast< int >(result));
50023 return resultobj;
50024 fail:
50025 return NULL;
50026 }
50027
50028
50029 SWIGINTERN PyObject *_wrap_SizerFlags_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50030 PyObject *resultobj = 0;
50031 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
50032 int result;
50033 void *argp1 = 0 ;
50034 int res1 = 0 ;
50035 PyObject *swig_obj[1] ;
50036
50037 if (!args) SWIG_fail;
50038 swig_obj[0] = args;
50039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
50040 if (!SWIG_IsOK(res1)) {
50041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_GetFlags" "', expected argument " "1"" of type '" "wxSizerFlags const *""'");
50042 }
50043 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
50044 {
50045 PyThreadState* __tstate = wxPyBeginAllowThreads();
50046 result = (int)((wxSizerFlags const *)arg1)->GetFlags();
50047 wxPyEndAllowThreads(__tstate);
50048 if (PyErr_Occurred()) SWIG_fail;
50049 }
50050 resultobj = SWIG_From_int(static_cast< int >(result));
50051 return resultobj;
50052 fail:
50053 return NULL;
50054 }
50055
50056
50057 SWIGINTERN PyObject *_wrap_SizerFlags_GetBorderInPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50058 PyObject *resultobj = 0;
50059 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
50060 int result;
50061 void *argp1 = 0 ;
50062 int res1 = 0 ;
50063 PyObject *swig_obj[1] ;
50064
50065 if (!args) SWIG_fail;
50066 swig_obj[0] = args;
50067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
50068 if (!SWIG_IsOK(res1)) {
50069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_GetBorderInPixels" "', expected argument " "1"" of type '" "wxSizerFlags const *""'");
50070 }
50071 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
50072 {
50073 PyThreadState* __tstate = wxPyBeginAllowThreads();
50074 result = (int)((wxSizerFlags const *)arg1)->GetBorderInPixels();
50075 wxPyEndAllowThreads(__tstate);
50076 if (PyErr_Occurred()) SWIG_fail;
50077 }
50078 resultobj = SWIG_From_int(static_cast< int >(result));
50079 return resultobj;
50080 fail:
50081 return NULL;
50082 }
50083
50084
50085 SWIGINTERN PyObject *SizerFlags_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50086 PyObject *obj;
50087 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50088 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerFlags, SWIG_NewClientData(obj));
50089 return SWIG_Py_Void();
50090 }
50091
50092 SWIGINTERN PyObject *SizerFlags_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50093 return SWIG_Python_InitShadowInstance(args);
50094 }
50095
50096 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50097 PyObject *resultobj = 0;
50098 wxSizerItem *result = 0 ;
50099
50100 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
50101 {
50102 PyThreadState* __tstate = wxPyBeginAllowThreads();
50103 result = (wxSizerItem *)new wxSizerItem();
50104 wxPyEndAllowThreads(__tstate);
50105 if (PyErr_Occurred()) SWIG_fail;
50106 }
50107 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
50108 return resultobj;
50109 fail:
50110 return NULL;
50111 }
50112
50113
50114 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50115 PyObject *resultobj = 0;
50116 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50117 void *argp1 = 0 ;
50118 int res1 = 0 ;
50119 PyObject *swig_obj[1] ;
50120
50121 if (!args) SWIG_fail;
50122 swig_obj[0] = args;
50123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50124 if (!SWIG_IsOK(res1)) {
50125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50126 }
50127 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50128 {
50129 PyThreadState* __tstate = wxPyBeginAllowThreads();
50130 delete arg1;
50131
50132 wxPyEndAllowThreads(__tstate);
50133 if (PyErr_Occurred()) SWIG_fail;
50134 }
50135 resultobj = SWIG_Py_Void();
50136 return resultobj;
50137 fail:
50138 return NULL;
50139 }
50140
50141
50142 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50143 PyObject *resultobj = 0;
50144 wxWindow *arg1 = (wxWindow *) 0 ;
50145 int arg2 ;
50146 int arg3 ;
50147 int arg4 ;
50148 PyObject *arg5 = (PyObject *) NULL ;
50149 wxSizerItem *result = 0 ;
50150 void *argp1 = 0 ;
50151 int res1 = 0 ;
50152 int val2 ;
50153 int ecode2 = 0 ;
50154 int val3 ;
50155 int ecode3 = 0 ;
50156 int val4 ;
50157 int ecode4 = 0 ;
50158 PyObject * obj0 = 0 ;
50159 PyObject * obj1 = 0 ;
50160 PyObject * obj2 = 0 ;
50161 PyObject * obj3 = 0 ;
50162 PyObject * obj4 = 0 ;
50163 char * kwnames[] = {
50164 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
50165 };
50166
50167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
50168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
50169 if (!SWIG_IsOK(res1)) {
50170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
50171 }
50172 arg1 = reinterpret_cast< wxWindow * >(argp1);
50173 ecode2 = SWIG_AsVal_int(obj1, &val2);
50174 if (!SWIG_IsOK(ecode2)) {
50175 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
50176 }
50177 arg2 = static_cast< int >(val2);
50178 ecode3 = SWIG_AsVal_int(obj2, &val3);
50179 if (!SWIG_IsOK(ecode3)) {
50180 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
50181 }
50182 arg3 = static_cast< int >(val3);
50183 ecode4 = SWIG_AsVal_int(obj3, &val4);
50184 if (!SWIG_IsOK(ecode4)) {
50185 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
50186 }
50187 arg4 = static_cast< int >(val4);
50188 if (obj4) {
50189 arg5 = obj4;
50190 }
50191 {
50192 PyThreadState* __tstate = wxPyBeginAllowThreads();
50193 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
50194 wxPyEndAllowThreads(__tstate);
50195 if (PyErr_Occurred()) SWIG_fail;
50196 }
50197 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
50198 return resultobj;
50199 fail:
50200 return NULL;
50201 }
50202
50203
50204 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50205 PyObject *resultobj = 0;
50206 int arg1 ;
50207 int arg2 ;
50208 int arg3 ;
50209 int arg4 ;
50210 int arg5 ;
50211 PyObject *arg6 = (PyObject *) NULL ;
50212 wxSizerItem *result = 0 ;
50213 int val1 ;
50214 int ecode1 = 0 ;
50215 int val2 ;
50216 int ecode2 = 0 ;
50217 int val3 ;
50218 int ecode3 = 0 ;
50219 int val4 ;
50220 int ecode4 = 0 ;
50221 int val5 ;
50222 int ecode5 = 0 ;
50223 PyObject * obj0 = 0 ;
50224 PyObject * obj1 = 0 ;
50225 PyObject * obj2 = 0 ;
50226 PyObject * obj3 = 0 ;
50227 PyObject * obj4 = 0 ;
50228 PyObject * obj5 = 0 ;
50229 char * kwnames[] = {
50230 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
50231 };
50232
50233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50234 ecode1 = SWIG_AsVal_int(obj0, &val1);
50235 if (!SWIG_IsOK(ecode1)) {
50236 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
50237 }
50238 arg1 = static_cast< int >(val1);
50239 ecode2 = SWIG_AsVal_int(obj1, &val2);
50240 if (!SWIG_IsOK(ecode2)) {
50241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
50242 }
50243 arg2 = static_cast< int >(val2);
50244 ecode3 = SWIG_AsVal_int(obj2, &val3);
50245 if (!SWIG_IsOK(ecode3)) {
50246 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
50247 }
50248 arg3 = static_cast< int >(val3);
50249 ecode4 = SWIG_AsVal_int(obj3, &val4);
50250 if (!SWIG_IsOK(ecode4)) {
50251 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
50252 }
50253 arg4 = static_cast< int >(val4);
50254 ecode5 = SWIG_AsVal_int(obj4, &val5);
50255 if (!SWIG_IsOK(ecode5)) {
50256 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
50257 }
50258 arg5 = static_cast< int >(val5);
50259 if (obj5) {
50260 arg6 = obj5;
50261 }
50262 {
50263 PyThreadState* __tstate = wxPyBeginAllowThreads();
50264 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
50265 wxPyEndAllowThreads(__tstate);
50266 if (PyErr_Occurred()) SWIG_fail;
50267 }
50268 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
50269 return resultobj;
50270 fail:
50271 return NULL;
50272 }
50273
50274
50275 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50276 PyObject *resultobj = 0;
50277 wxSizer *arg1 = (wxSizer *) 0 ;
50278 int arg2 ;
50279 int arg3 ;
50280 int arg4 ;
50281 PyObject *arg5 = (PyObject *) NULL ;
50282 wxSizerItem *result = 0 ;
50283 int res1 = 0 ;
50284 int val2 ;
50285 int ecode2 = 0 ;
50286 int val3 ;
50287 int ecode3 = 0 ;
50288 int val4 ;
50289 int ecode4 = 0 ;
50290 PyObject * obj0 = 0 ;
50291 PyObject * obj1 = 0 ;
50292 PyObject * obj2 = 0 ;
50293 PyObject * obj3 = 0 ;
50294 PyObject * obj4 = 0 ;
50295 char * kwnames[] = {
50296 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
50297 };
50298
50299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
50300 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
50301 if (!SWIG_IsOK(res1)) {
50302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50303 }
50304 ecode2 = SWIG_AsVal_int(obj1, &val2);
50305 if (!SWIG_IsOK(ecode2)) {
50306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
50307 }
50308 arg2 = static_cast< int >(val2);
50309 ecode3 = SWIG_AsVal_int(obj2, &val3);
50310 if (!SWIG_IsOK(ecode3)) {
50311 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
50312 }
50313 arg3 = static_cast< int >(val3);
50314 ecode4 = SWIG_AsVal_int(obj3, &val4);
50315 if (!SWIG_IsOK(ecode4)) {
50316 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
50317 }
50318 arg4 = static_cast< int >(val4);
50319 if (obj4) {
50320 arg5 = obj4;
50321 }
50322 {
50323 PyThreadState* __tstate = wxPyBeginAllowThreads();
50324 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
50325 wxPyEndAllowThreads(__tstate);
50326 if (PyErr_Occurred()) SWIG_fail;
50327 }
50328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
50329 return resultobj;
50330 fail:
50331 return NULL;
50332 }
50333
50334
50335 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50336 PyObject *resultobj = 0;
50337 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50338 void *argp1 = 0 ;
50339 int res1 = 0 ;
50340 PyObject *swig_obj[1] ;
50341
50342 if (!args) SWIG_fail;
50343 swig_obj[0] = args;
50344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50345 if (!SWIG_IsOK(res1)) {
50346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50347 }
50348 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50349 {
50350 PyThreadState* __tstate = wxPyBeginAllowThreads();
50351 (arg1)->DeleteWindows();
50352 wxPyEndAllowThreads(__tstate);
50353 if (PyErr_Occurred()) SWIG_fail;
50354 }
50355 resultobj = SWIG_Py_Void();
50356 return resultobj;
50357 fail:
50358 return NULL;
50359 }
50360
50361
50362 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50363 PyObject *resultobj = 0;
50364 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50365 void *argp1 = 0 ;
50366 int res1 = 0 ;
50367 PyObject *swig_obj[1] ;
50368
50369 if (!args) SWIG_fail;
50370 swig_obj[0] = args;
50371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50372 if (!SWIG_IsOK(res1)) {
50373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50374 }
50375 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50376 {
50377 PyThreadState* __tstate = wxPyBeginAllowThreads();
50378 (arg1)->DetachSizer();
50379 wxPyEndAllowThreads(__tstate);
50380 if (PyErr_Occurred()) SWIG_fail;
50381 }
50382 resultobj = SWIG_Py_Void();
50383 return resultobj;
50384 fail:
50385 return NULL;
50386 }
50387
50388
50389 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50390 PyObject *resultobj = 0;
50391 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50392 wxSize result;
50393 void *argp1 = 0 ;
50394 int res1 = 0 ;
50395 PyObject *swig_obj[1] ;
50396
50397 if (!args) SWIG_fail;
50398 swig_obj[0] = args;
50399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50400 if (!SWIG_IsOK(res1)) {
50401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50402 }
50403 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50404 {
50405 PyThreadState* __tstate = wxPyBeginAllowThreads();
50406 result = (arg1)->GetSize();
50407 wxPyEndAllowThreads(__tstate);
50408 if (PyErr_Occurred()) SWIG_fail;
50409 }
50410 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50411 return resultobj;
50412 fail:
50413 return NULL;
50414 }
50415
50416
50417 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50418 PyObject *resultobj = 0;
50419 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50420 wxSize result;
50421 void *argp1 = 0 ;
50422 int res1 = 0 ;
50423 PyObject *swig_obj[1] ;
50424
50425 if (!args) SWIG_fail;
50426 swig_obj[0] = args;
50427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50428 if (!SWIG_IsOK(res1)) {
50429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50430 }
50431 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50432 {
50433 PyThreadState* __tstate = wxPyBeginAllowThreads();
50434 result = (arg1)->CalcMin();
50435 wxPyEndAllowThreads(__tstate);
50436 if (PyErr_Occurred()) SWIG_fail;
50437 }
50438 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50439 return resultobj;
50440 fail:
50441 return NULL;
50442 }
50443
50444
50445 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50446 PyObject *resultobj = 0;
50447 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50448 wxPoint *arg2 = 0 ;
50449 wxSize *arg3 = 0 ;
50450 void *argp1 = 0 ;
50451 int res1 = 0 ;
50452 wxPoint temp2 ;
50453 wxSize temp3 ;
50454 PyObject * obj0 = 0 ;
50455 PyObject * obj1 = 0 ;
50456 PyObject * obj2 = 0 ;
50457 char * kwnames[] = {
50458 (char *) "self",(char *) "pos",(char *) "size", NULL
50459 };
50460
50461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50463 if (!SWIG_IsOK(res1)) {
50464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50465 }
50466 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50467 {
50468 arg2 = &temp2;
50469 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
50470 }
50471 {
50472 arg3 = &temp3;
50473 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
50474 }
50475 {
50476 PyThreadState* __tstate = wxPyBeginAllowThreads();
50477 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
50478 wxPyEndAllowThreads(__tstate);
50479 if (PyErr_Occurred()) SWIG_fail;
50480 }
50481 resultobj = SWIG_Py_Void();
50482 return resultobj;
50483 fail:
50484 return NULL;
50485 }
50486
50487
50488 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50489 PyObject *resultobj = 0;
50490 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50491 wxSize result;
50492 void *argp1 = 0 ;
50493 int res1 = 0 ;
50494 PyObject *swig_obj[1] ;
50495
50496 if (!args) SWIG_fail;
50497 swig_obj[0] = args;
50498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50499 if (!SWIG_IsOK(res1)) {
50500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50501 }
50502 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50503 {
50504 PyThreadState* __tstate = wxPyBeginAllowThreads();
50505 result = (arg1)->GetMinSize();
50506 wxPyEndAllowThreads(__tstate);
50507 if (PyErr_Occurred()) SWIG_fail;
50508 }
50509 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50510 return resultobj;
50511 fail:
50512 return NULL;
50513 }
50514
50515
50516 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50517 PyObject *resultobj = 0;
50518 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50519 wxSize result;
50520 void *argp1 = 0 ;
50521 int res1 = 0 ;
50522 PyObject *swig_obj[1] ;
50523
50524 if (!args) SWIG_fail;
50525 swig_obj[0] = args;
50526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50527 if (!SWIG_IsOK(res1)) {
50528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
50529 }
50530 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50531 {
50532 PyThreadState* __tstate = wxPyBeginAllowThreads();
50533 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
50534 wxPyEndAllowThreads(__tstate);
50535 if (PyErr_Occurred()) SWIG_fail;
50536 }
50537 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50538 return resultobj;
50539 fail:
50540 return NULL;
50541 }
50542
50543
50544 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50545 PyObject *resultobj = 0;
50546 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50547 int arg2 ;
50548 int arg3 ;
50549 void *argp1 = 0 ;
50550 int res1 = 0 ;
50551 int val2 ;
50552 int ecode2 = 0 ;
50553 int val3 ;
50554 int ecode3 = 0 ;
50555 PyObject * obj0 = 0 ;
50556 PyObject * obj1 = 0 ;
50557 PyObject * obj2 = 0 ;
50558 char * kwnames[] = {
50559 (char *) "self",(char *) "x",(char *) "y", NULL
50560 };
50561
50562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50564 if (!SWIG_IsOK(res1)) {
50565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50566 }
50567 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50568 ecode2 = SWIG_AsVal_int(obj1, &val2);
50569 if (!SWIG_IsOK(ecode2)) {
50570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
50571 }
50572 arg2 = static_cast< int >(val2);
50573 ecode3 = SWIG_AsVal_int(obj2, &val3);
50574 if (!SWIG_IsOK(ecode3)) {
50575 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
50576 }
50577 arg3 = static_cast< int >(val3);
50578 {
50579 PyThreadState* __tstate = wxPyBeginAllowThreads();
50580 (arg1)->SetInitSize(arg2,arg3);
50581 wxPyEndAllowThreads(__tstate);
50582 if (PyErr_Occurred()) SWIG_fail;
50583 }
50584 resultobj = SWIG_Py_Void();
50585 return resultobj;
50586 fail:
50587 return NULL;
50588 }
50589
50590
50591 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50592 PyObject *resultobj = 0;
50593 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50594 int arg2 ;
50595 int arg3 ;
50596 void *argp1 = 0 ;
50597 int res1 = 0 ;
50598 int val2 ;
50599 int ecode2 = 0 ;
50600 int val3 ;
50601 int ecode3 = 0 ;
50602 PyObject * obj0 = 0 ;
50603 PyObject * obj1 = 0 ;
50604 PyObject * obj2 = 0 ;
50605 char * kwnames[] = {
50606 (char *) "self",(char *) "width",(char *) "height", NULL
50607 };
50608
50609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50611 if (!SWIG_IsOK(res1)) {
50612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50613 }
50614 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50615 ecode2 = SWIG_AsVal_int(obj1, &val2);
50616 if (!SWIG_IsOK(ecode2)) {
50617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
50618 }
50619 arg2 = static_cast< int >(val2);
50620 ecode3 = SWIG_AsVal_int(obj2, &val3);
50621 if (!SWIG_IsOK(ecode3)) {
50622 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
50623 }
50624 arg3 = static_cast< int >(val3);
50625 {
50626 PyThreadState* __tstate = wxPyBeginAllowThreads();
50627 (arg1)->SetRatio(arg2,arg3);
50628 wxPyEndAllowThreads(__tstate);
50629 if (PyErr_Occurred()) SWIG_fail;
50630 }
50631 resultobj = SWIG_Py_Void();
50632 return resultobj;
50633 fail:
50634 return NULL;
50635 }
50636
50637
50638 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50639 PyObject *resultobj = 0;
50640 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50641 wxSize *arg2 = 0 ;
50642 void *argp1 = 0 ;
50643 int res1 = 0 ;
50644 wxSize temp2 ;
50645 PyObject * obj0 = 0 ;
50646 PyObject * obj1 = 0 ;
50647 char * kwnames[] = {
50648 (char *) "self",(char *) "size", NULL
50649 };
50650
50651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
50652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50653 if (!SWIG_IsOK(res1)) {
50654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50655 }
50656 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50657 {
50658 arg2 = &temp2;
50659 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50660 }
50661 {
50662 PyThreadState* __tstate = wxPyBeginAllowThreads();
50663 (arg1)->SetRatio((wxSize const &)*arg2);
50664 wxPyEndAllowThreads(__tstate);
50665 if (PyErr_Occurred()) SWIG_fail;
50666 }
50667 resultobj = SWIG_Py_Void();
50668 return resultobj;
50669 fail:
50670 return NULL;
50671 }
50672
50673
50674 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50675 PyObject *resultobj = 0;
50676 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50677 float arg2 ;
50678 void *argp1 = 0 ;
50679 int res1 = 0 ;
50680 float val2 ;
50681 int ecode2 = 0 ;
50682 PyObject * obj0 = 0 ;
50683 PyObject * obj1 = 0 ;
50684 char * kwnames[] = {
50685 (char *) "self",(char *) "ratio", NULL
50686 };
50687
50688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
50689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50690 if (!SWIG_IsOK(res1)) {
50691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50692 }
50693 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50694 ecode2 = SWIG_AsVal_float(obj1, &val2);
50695 if (!SWIG_IsOK(ecode2)) {
50696 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
50697 }
50698 arg2 = static_cast< float >(val2);
50699 {
50700 PyThreadState* __tstate = wxPyBeginAllowThreads();
50701 (arg1)->SetRatio(arg2);
50702 wxPyEndAllowThreads(__tstate);
50703 if (PyErr_Occurred()) SWIG_fail;
50704 }
50705 resultobj = SWIG_Py_Void();
50706 return resultobj;
50707 fail:
50708 return NULL;
50709 }
50710
50711
50712 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50713 PyObject *resultobj = 0;
50714 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50715 float result;
50716 void *argp1 = 0 ;
50717 int res1 = 0 ;
50718 PyObject *swig_obj[1] ;
50719
50720 if (!args) SWIG_fail;
50721 swig_obj[0] = args;
50722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50723 if (!SWIG_IsOK(res1)) {
50724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50725 }
50726 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50727 {
50728 PyThreadState* __tstate = wxPyBeginAllowThreads();
50729 result = (float)(arg1)->GetRatio();
50730 wxPyEndAllowThreads(__tstate);
50731 if (PyErr_Occurred()) SWIG_fail;
50732 }
50733 resultobj = SWIG_From_float(static_cast< float >(result));
50734 return resultobj;
50735 fail:
50736 return NULL;
50737 }
50738
50739
50740 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50741 PyObject *resultobj = 0;
50742 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50743 wxRect result;
50744 void *argp1 = 0 ;
50745 int res1 = 0 ;
50746 PyObject *swig_obj[1] ;
50747
50748 if (!args) SWIG_fail;
50749 swig_obj[0] = args;
50750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50751 if (!SWIG_IsOK(res1)) {
50752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50753 }
50754 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50755 {
50756 PyThreadState* __tstate = wxPyBeginAllowThreads();
50757 result = (arg1)->GetRect();
50758 wxPyEndAllowThreads(__tstate);
50759 if (PyErr_Occurred()) SWIG_fail;
50760 }
50761 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
50762 return resultobj;
50763 fail:
50764 return NULL;
50765 }
50766
50767
50768 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50769 PyObject *resultobj = 0;
50770 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50771 bool result;
50772 void *argp1 = 0 ;
50773 int res1 = 0 ;
50774 PyObject *swig_obj[1] ;
50775
50776 if (!args) SWIG_fail;
50777 swig_obj[0] = args;
50778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50779 if (!SWIG_IsOK(res1)) {
50780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50781 }
50782 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50783 {
50784 PyThreadState* __tstate = wxPyBeginAllowThreads();
50785 result = (bool)(arg1)->IsWindow();
50786 wxPyEndAllowThreads(__tstate);
50787 if (PyErr_Occurred()) SWIG_fail;
50788 }
50789 {
50790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50791 }
50792 return resultobj;
50793 fail:
50794 return NULL;
50795 }
50796
50797
50798 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50799 PyObject *resultobj = 0;
50800 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50801 bool result;
50802 void *argp1 = 0 ;
50803 int res1 = 0 ;
50804 PyObject *swig_obj[1] ;
50805
50806 if (!args) SWIG_fail;
50807 swig_obj[0] = args;
50808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50809 if (!SWIG_IsOK(res1)) {
50810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50811 }
50812 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50813 {
50814 PyThreadState* __tstate = wxPyBeginAllowThreads();
50815 result = (bool)(arg1)->IsSizer();
50816 wxPyEndAllowThreads(__tstate);
50817 if (PyErr_Occurred()) SWIG_fail;
50818 }
50819 {
50820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50821 }
50822 return resultobj;
50823 fail:
50824 return NULL;
50825 }
50826
50827
50828 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50829 PyObject *resultobj = 0;
50830 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50831 bool result;
50832 void *argp1 = 0 ;
50833 int res1 = 0 ;
50834 PyObject *swig_obj[1] ;
50835
50836 if (!args) SWIG_fail;
50837 swig_obj[0] = args;
50838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50839 if (!SWIG_IsOK(res1)) {
50840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50841 }
50842 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50843 {
50844 PyThreadState* __tstate = wxPyBeginAllowThreads();
50845 result = (bool)(arg1)->IsSpacer();
50846 wxPyEndAllowThreads(__tstate);
50847 if (PyErr_Occurred()) SWIG_fail;
50848 }
50849 {
50850 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50851 }
50852 return resultobj;
50853 fail:
50854 return NULL;
50855 }
50856
50857
50858 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50859 PyObject *resultobj = 0;
50860 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50861 int arg2 ;
50862 void *argp1 = 0 ;
50863 int res1 = 0 ;
50864 int val2 ;
50865 int ecode2 = 0 ;
50866 PyObject * obj0 = 0 ;
50867 PyObject * obj1 = 0 ;
50868 char * kwnames[] = {
50869 (char *) "self",(char *) "proportion", NULL
50870 };
50871
50872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
50873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50874 if (!SWIG_IsOK(res1)) {
50875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50876 }
50877 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50878 ecode2 = SWIG_AsVal_int(obj1, &val2);
50879 if (!SWIG_IsOK(ecode2)) {
50880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
50881 }
50882 arg2 = static_cast< int >(val2);
50883 {
50884 PyThreadState* __tstate = wxPyBeginAllowThreads();
50885 (arg1)->SetProportion(arg2);
50886 wxPyEndAllowThreads(__tstate);
50887 if (PyErr_Occurred()) SWIG_fail;
50888 }
50889 resultobj = SWIG_Py_Void();
50890 return resultobj;
50891 fail:
50892 return NULL;
50893 }
50894
50895
50896 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50897 PyObject *resultobj = 0;
50898 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50899 int result;
50900 void *argp1 = 0 ;
50901 int res1 = 0 ;
50902 PyObject *swig_obj[1] ;
50903
50904 if (!args) SWIG_fail;
50905 swig_obj[0] = args;
50906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50907 if (!SWIG_IsOK(res1)) {
50908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50909 }
50910 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50911 {
50912 PyThreadState* __tstate = wxPyBeginAllowThreads();
50913 result = (int)(arg1)->GetProportion();
50914 wxPyEndAllowThreads(__tstate);
50915 if (PyErr_Occurred()) SWIG_fail;
50916 }
50917 resultobj = SWIG_From_int(static_cast< int >(result));
50918 return resultobj;
50919 fail:
50920 return NULL;
50921 }
50922
50923
50924 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50925 PyObject *resultobj = 0;
50926 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50927 int arg2 ;
50928 void *argp1 = 0 ;
50929 int res1 = 0 ;
50930 int val2 ;
50931 int ecode2 = 0 ;
50932 PyObject * obj0 = 0 ;
50933 PyObject * obj1 = 0 ;
50934 char * kwnames[] = {
50935 (char *) "self",(char *) "flag", NULL
50936 };
50937
50938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
50939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50940 if (!SWIG_IsOK(res1)) {
50941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50942 }
50943 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50944 ecode2 = SWIG_AsVal_int(obj1, &val2);
50945 if (!SWIG_IsOK(ecode2)) {
50946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
50947 }
50948 arg2 = static_cast< int >(val2);
50949 {
50950 PyThreadState* __tstate = wxPyBeginAllowThreads();
50951 (arg1)->SetFlag(arg2);
50952 wxPyEndAllowThreads(__tstate);
50953 if (PyErr_Occurred()) SWIG_fail;
50954 }
50955 resultobj = SWIG_Py_Void();
50956 return resultobj;
50957 fail:
50958 return NULL;
50959 }
50960
50961
50962 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50963 PyObject *resultobj = 0;
50964 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50965 int result;
50966 void *argp1 = 0 ;
50967 int res1 = 0 ;
50968 PyObject *swig_obj[1] ;
50969
50970 if (!args) SWIG_fail;
50971 swig_obj[0] = args;
50972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50973 if (!SWIG_IsOK(res1)) {
50974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50975 }
50976 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50977 {
50978 PyThreadState* __tstate = wxPyBeginAllowThreads();
50979 result = (int)(arg1)->GetFlag();
50980 wxPyEndAllowThreads(__tstate);
50981 if (PyErr_Occurred()) SWIG_fail;
50982 }
50983 resultobj = SWIG_From_int(static_cast< int >(result));
50984 return resultobj;
50985 fail:
50986 return NULL;
50987 }
50988
50989
50990 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50991 PyObject *resultobj = 0;
50992 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50993 int arg2 ;
50994 void *argp1 = 0 ;
50995 int res1 = 0 ;
50996 int val2 ;
50997 int ecode2 = 0 ;
50998 PyObject * obj0 = 0 ;
50999 PyObject * obj1 = 0 ;
51000 char * kwnames[] = {
51001 (char *) "self",(char *) "border", NULL
51002 };
51003
51004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
51005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51006 if (!SWIG_IsOK(res1)) {
51007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51008 }
51009 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51010 ecode2 = SWIG_AsVal_int(obj1, &val2);
51011 if (!SWIG_IsOK(ecode2)) {
51012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
51013 }
51014 arg2 = static_cast< int >(val2);
51015 {
51016 PyThreadState* __tstate = wxPyBeginAllowThreads();
51017 (arg1)->SetBorder(arg2);
51018 wxPyEndAllowThreads(__tstate);
51019 if (PyErr_Occurred()) SWIG_fail;
51020 }
51021 resultobj = SWIG_Py_Void();
51022 return resultobj;
51023 fail:
51024 return NULL;
51025 }
51026
51027
51028 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51029 PyObject *resultobj = 0;
51030 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51031 int result;
51032 void *argp1 = 0 ;
51033 int res1 = 0 ;
51034 PyObject *swig_obj[1] ;
51035
51036 if (!args) SWIG_fail;
51037 swig_obj[0] = args;
51038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51039 if (!SWIG_IsOK(res1)) {
51040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51041 }
51042 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51043 {
51044 PyThreadState* __tstate = wxPyBeginAllowThreads();
51045 result = (int)(arg1)->GetBorder();
51046 wxPyEndAllowThreads(__tstate);
51047 if (PyErr_Occurred()) SWIG_fail;
51048 }
51049 resultobj = SWIG_From_int(static_cast< int >(result));
51050 return resultobj;
51051 fail:
51052 return NULL;
51053 }
51054
51055
51056 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51057 PyObject *resultobj = 0;
51058 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51059 wxWindow *result = 0 ;
51060 void *argp1 = 0 ;
51061 int res1 = 0 ;
51062 PyObject *swig_obj[1] ;
51063
51064 if (!args) SWIG_fail;
51065 swig_obj[0] = args;
51066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51067 if (!SWIG_IsOK(res1)) {
51068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51069 }
51070 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51071 {
51072 PyThreadState* __tstate = wxPyBeginAllowThreads();
51073 result = (wxWindow *)(arg1)->GetWindow();
51074 wxPyEndAllowThreads(__tstate);
51075 if (PyErr_Occurred()) SWIG_fail;
51076 }
51077 {
51078 resultobj = wxPyMake_wxObject(result, 0);
51079 }
51080 return resultobj;
51081 fail:
51082 return NULL;
51083 }
51084
51085
51086 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51087 PyObject *resultobj = 0;
51088 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51089 wxSizer *result = 0 ;
51090 void *argp1 = 0 ;
51091 int res1 = 0 ;
51092 PyObject *swig_obj[1] ;
51093
51094 if (!args) SWIG_fail;
51095 swig_obj[0] = args;
51096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51097 if (!SWIG_IsOK(res1)) {
51098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51099 }
51100 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51101 {
51102 PyThreadState* __tstate = wxPyBeginAllowThreads();
51103 result = (wxSizer *)(arg1)->GetSizer();
51104 wxPyEndAllowThreads(__tstate);
51105 if (PyErr_Occurred()) SWIG_fail;
51106 }
51107 {
51108 resultobj = wxPyMake_wxObject(result, (bool)0);
51109 }
51110 return resultobj;
51111 fail:
51112 return NULL;
51113 }
51114
51115
51116 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51117 PyObject *resultobj = 0;
51118 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51119 wxSize result;
51120 void *argp1 = 0 ;
51121 int res1 = 0 ;
51122 PyObject *swig_obj[1] ;
51123
51124 if (!args) SWIG_fail;
51125 swig_obj[0] = args;
51126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51127 if (!SWIG_IsOK(res1)) {
51128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51129 }
51130 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51131 {
51132 PyThreadState* __tstate = wxPyBeginAllowThreads();
51133 result = (arg1)->GetSpacer();
51134 wxPyEndAllowThreads(__tstate);
51135 if (PyErr_Occurred()) SWIG_fail;
51136 }
51137 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51138 return resultobj;
51139 fail:
51140 return NULL;
51141 }
51142
51143
51144 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51145 PyObject *resultobj = 0;
51146 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51147 wxWindow *arg2 = (wxWindow *) 0 ;
51148 void *argp1 = 0 ;
51149 int res1 = 0 ;
51150 void *argp2 = 0 ;
51151 int res2 = 0 ;
51152 PyObject * obj0 = 0 ;
51153 PyObject * obj1 = 0 ;
51154 char * kwnames[] = {
51155 (char *) "self",(char *) "window", NULL
51156 };
51157
51158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
51159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51160 if (!SWIG_IsOK(res1)) {
51161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51162 }
51163 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51164 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51165 if (!SWIG_IsOK(res2)) {
51166 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
51167 }
51168 arg2 = reinterpret_cast< wxWindow * >(argp2);
51169 {
51170 PyThreadState* __tstate = wxPyBeginAllowThreads();
51171 (arg1)->SetWindow(arg2);
51172 wxPyEndAllowThreads(__tstate);
51173 if (PyErr_Occurred()) SWIG_fail;
51174 }
51175 resultobj = SWIG_Py_Void();
51176 return resultobj;
51177 fail:
51178 return NULL;
51179 }
51180
51181
51182 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51183 PyObject *resultobj = 0;
51184 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51185 wxSizer *arg2 = (wxSizer *) 0 ;
51186 void *argp1 = 0 ;
51187 int res1 = 0 ;
51188 int res2 = 0 ;
51189 PyObject * obj0 = 0 ;
51190 PyObject * obj1 = 0 ;
51191 char * kwnames[] = {
51192 (char *) "self",(char *) "sizer", NULL
51193 };
51194
51195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51197 if (!SWIG_IsOK(res1)) {
51198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51199 }
51200 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51201 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
51202 if (!SWIG_IsOK(res2)) {
51203 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
51204 }
51205 {
51206 PyThreadState* __tstate = wxPyBeginAllowThreads();
51207 (arg1)->SetSizer(arg2);
51208 wxPyEndAllowThreads(__tstate);
51209 if (PyErr_Occurred()) SWIG_fail;
51210 }
51211 resultobj = SWIG_Py_Void();
51212 return resultobj;
51213 fail:
51214 return NULL;
51215 }
51216
51217
51218 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51219 PyObject *resultobj = 0;
51220 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51221 wxSize *arg2 = 0 ;
51222 void *argp1 = 0 ;
51223 int res1 = 0 ;
51224 wxSize temp2 ;
51225 PyObject * obj0 = 0 ;
51226 PyObject * obj1 = 0 ;
51227 char * kwnames[] = {
51228 (char *) "self",(char *) "size", NULL
51229 };
51230
51231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
51232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51233 if (!SWIG_IsOK(res1)) {
51234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51235 }
51236 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51237 {
51238 arg2 = &temp2;
51239 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
51240 }
51241 {
51242 PyThreadState* __tstate = wxPyBeginAllowThreads();
51243 (arg1)->SetSpacer((wxSize const &)*arg2);
51244 wxPyEndAllowThreads(__tstate);
51245 if (PyErr_Occurred()) SWIG_fail;
51246 }
51247 resultobj = SWIG_Py_Void();
51248 return resultobj;
51249 fail:
51250 return NULL;
51251 }
51252
51253
51254 SWIGINTERN PyObject *_wrap_SizerItem_AssignWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51255 PyObject *resultobj = 0;
51256 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51257 wxWindow *arg2 = (wxWindow *) 0 ;
51258 void *argp1 = 0 ;
51259 int res1 = 0 ;
51260 void *argp2 = 0 ;
51261 int res2 = 0 ;
51262 PyObject * obj0 = 0 ;
51263 PyObject * obj1 = 0 ;
51264 char * kwnames[] = {
51265 (char *) "self",(char *) "window", NULL
51266 };
51267
51268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_AssignWindow",kwnames,&obj0,&obj1)) SWIG_fail;
51269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51270 if (!SWIG_IsOK(res1)) {
51271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_AssignWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51272 }
51273 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51274 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51275 if (!SWIG_IsOK(res2)) {
51276 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_AssignWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
51277 }
51278 arg2 = reinterpret_cast< wxWindow * >(argp2);
51279 {
51280 PyThreadState* __tstate = wxPyBeginAllowThreads();
51281 (arg1)->AssignWindow(arg2);
51282 wxPyEndAllowThreads(__tstate);
51283 if (PyErr_Occurred()) SWIG_fail;
51284 }
51285 resultobj = SWIG_Py_Void();
51286 return resultobj;
51287 fail:
51288 return NULL;
51289 }
51290
51291
51292 SWIGINTERN PyObject *_wrap_SizerItem_AssignSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51293 PyObject *resultobj = 0;
51294 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51295 wxSizer *arg2 = (wxSizer *) 0 ;
51296 void *argp1 = 0 ;
51297 int res1 = 0 ;
51298 void *argp2 = 0 ;
51299 int res2 = 0 ;
51300 PyObject * obj0 = 0 ;
51301 PyObject * obj1 = 0 ;
51302 char * kwnames[] = {
51303 (char *) "self",(char *) "sizer", NULL
51304 };
51305
51306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_AssignSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51308 if (!SWIG_IsOK(res1)) {
51309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_AssignSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51310 }
51311 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51312 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51313 if (!SWIG_IsOK(res2)) {
51314 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_AssignSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
51315 }
51316 arg2 = reinterpret_cast< wxSizer * >(argp2);
51317 {
51318 PyThreadState* __tstate = wxPyBeginAllowThreads();
51319 (arg1)->AssignSizer(arg2);
51320 wxPyEndAllowThreads(__tstate);
51321 if (PyErr_Occurred()) SWIG_fail;
51322 }
51323 resultobj = SWIG_Py_Void();
51324 return resultobj;
51325 fail:
51326 return NULL;
51327 }
51328
51329
51330 SWIGINTERN PyObject *_wrap_SizerItem_AssignSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51331 PyObject *resultobj = 0;
51332 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51333 wxSize *arg2 = 0 ;
51334 void *argp1 = 0 ;
51335 int res1 = 0 ;
51336 wxSize temp2 ;
51337 PyObject * obj0 = 0 ;
51338 PyObject * obj1 = 0 ;
51339 char * kwnames[] = {
51340 (char *) "self",(char *) "size", NULL
51341 };
51342
51343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_AssignSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
51344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51345 if (!SWIG_IsOK(res1)) {
51346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_AssignSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51347 }
51348 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51349 {
51350 arg2 = &temp2;
51351 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
51352 }
51353 {
51354 PyThreadState* __tstate = wxPyBeginAllowThreads();
51355 (arg1)->AssignSpacer((wxSize const &)*arg2);
51356 wxPyEndAllowThreads(__tstate);
51357 if (PyErr_Occurred()) SWIG_fail;
51358 }
51359 resultobj = SWIG_Py_Void();
51360 return resultobj;
51361 fail:
51362 return NULL;
51363 }
51364
51365
51366 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51367 PyObject *resultobj = 0;
51368 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51369 bool arg2 ;
51370 void *argp1 = 0 ;
51371 int res1 = 0 ;
51372 bool val2 ;
51373 int ecode2 = 0 ;
51374 PyObject * obj0 = 0 ;
51375 PyObject * obj1 = 0 ;
51376 char * kwnames[] = {
51377 (char *) "self",(char *) "show", NULL
51378 };
51379
51380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
51381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51382 if (!SWIG_IsOK(res1)) {
51383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51384 }
51385 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51386 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51387 if (!SWIG_IsOK(ecode2)) {
51388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
51389 }
51390 arg2 = static_cast< bool >(val2);
51391 {
51392 PyThreadState* __tstate = wxPyBeginAllowThreads();
51393 (arg1)->Show(arg2);
51394 wxPyEndAllowThreads(__tstate);
51395 if (PyErr_Occurred()) SWIG_fail;
51396 }
51397 resultobj = SWIG_Py_Void();
51398 return resultobj;
51399 fail:
51400 return NULL;
51401 }
51402
51403
51404 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51405 PyObject *resultobj = 0;
51406 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51407 bool result;
51408 void *argp1 = 0 ;
51409 int res1 = 0 ;
51410 PyObject *swig_obj[1] ;
51411
51412 if (!args) SWIG_fail;
51413 swig_obj[0] = args;
51414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51415 if (!SWIG_IsOK(res1)) {
51416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51417 }
51418 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51419 {
51420 PyThreadState* __tstate = wxPyBeginAllowThreads();
51421 result = (bool)(arg1)->IsShown();
51422 wxPyEndAllowThreads(__tstate);
51423 if (PyErr_Occurred()) SWIG_fail;
51424 }
51425 {
51426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51427 }
51428 return resultobj;
51429 fail:
51430 return NULL;
51431 }
51432
51433
51434 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51435 PyObject *resultobj = 0;
51436 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51437 wxPoint result;
51438 void *argp1 = 0 ;
51439 int res1 = 0 ;
51440 PyObject *swig_obj[1] ;
51441
51442 if (!args) SWIG_fail;
51443 swig_obj[0] = args;
51444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51445 if (!SWIG_IsOK(res1)) {
51446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51447 }
51448 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51449 {
51450 PyThreadState* __tstate = wxPyBeginAllowThreads();
51451 result = (arg1)->GetPosition();
51452 wxPyEndAllowThreads(__tstate);
51453 if (PyErr_Occurred()) SWIG_fail;
51454 }
51455 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
51456 return resultobj;
51457 fail:
51458 return NULL;
51459 }
51460
51461
51462 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51463 PyObject *resultobj = 0;
51464 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51465 PyObject *result = 0 ;
51466 void *argp1 = 0 ;
51467 int res1 = 0 ;
51468 PyObject *swig_obj[1] ;
51469
51470 if (!args) SWIG_fail;
51471 swig_obj[0] = args;
51472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51473 if (!SWIG_IsOK(res1)) {
51474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51475 }
51476 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51477 {
51478 PyThreadState* __tstate = wxPyBeginAllowThreads();
51479 result = (PyObject *)wxSizerItem_GetUserData(arg1);
51480 wxPyEndAllowThreads(__tstate);
51481 if (PyErr_Occurred()) SWIG_fail;
51482 }
51483 resultobj = result;
51484 return resultobj;
51485 fail:
51486 return NULL;
51487 }
51488
51489
51490 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51491 PyObject *resultobj = 0;
51492 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51493 PyObject *arg2 = (PyObject *) 0 ;
51494 void *argp1 = 0 ;
51495 int res1 = 0 ;
51496 PyObject * obj0 = 0 ;
51497 PyObject * obj1 = 0 ;
51498 char * kwnames[] = {
51499 (char *) "self",(char *) "userData", NULL
51500 };
51501
51502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
51503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51504 if (!SWIG_IsOK(res1)) {
51505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51506 }
51507 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51508 arg2 = obj1;
51509 {
51510 PyThreadState* __tstate = wxPyBeginAllowThreads();
51511 wxSizerItem_SetUserData(arg1,arg2);
51512 wxPyEndAllowThreads(__tstate);
51513 if (PyErr_Occurred()) SWIG_fail;
51514 }
51515 resultobj = SWIG_Py_Void();
51516 return resultobj;
51517 fail:
51518 return NULL;
51519 }
51520
51521
51522 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51523 PyObject *obj;
51524 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51525 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
51526 return SWIG_Py_Void();
51527 }
51528
51529 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51530 return SWIG_Python_InitShadowInstance(args);
51531 }
51532
51533 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51534 PyObject *resultobj = 0;
51535 wxSizer *arg1 = (wxSizer *) 0 ;
51536 void *argp1 = 0 ;
51537 int res1 = 0 ;
51538 PyObject *swig_obj[1] ;
51539
51540 if (!args) SWIG_fail;
51541 swig_obj[0] = args;
51542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
51543 if (!SWIG_IsOK(res1)) {
51544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
51545 }
51546 arg1 = reinterpret_cast< wxSizer * >(argp1);
51547 {
51548 PyThreadState* __tstate = wxPyBeginAllowThreads();
51549 delete arg1;
51550
51551 wxPyEndAllowThreads(__tstate);
51552 if (PyErr_Occurred()) SWIG_fail;
51553 }
51554 resultobj = SWIG_Py_Void();
51555 return resultobj;
51556 fail:
51557 return NULL;
51558 }
51559
51560
51561 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51562 PyObject *resultobj = 0;
51563 wxSizer *arg1 = (wxSizer *) 0 ;
51564 PyObject *arg2 = (PyObject *) 0 ;
51565 void *argp1 = 0 ;
51566 int res1 = 0 ;
51567 PyObject * obj0 = 0 ;
51568 PyObject * obj1 = 0 ;
51569 char * kwnames[] = {
51570 (char *) "self",(char *) "_self", NULL
51571 };
51572
51573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
51574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51575 if (!SWIG_IsOK(res1)) {
51576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
51577 }
51578 arg1 = reinterpret_cast< wxSizer * >(argp1);
51579 arg2 = obj1;
51580 {
51581 PyThreadState* __tstate = wxPyBeginAllowThreads();
51582 wxSizer__setOORInfo(arg1,arg2);
51583 wxPyEndAllowThreads(__tstate);
51584 if (PyErr_Occurred()) SWIG_fail;
51585 }
51586 resultobj = SWIG_Py_Void();
51587 return resultobj;
51588 fail:
51589 return NULL;
51590 }
51591
51592
51593 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51594 PyObject *resultobj = 0;
51595 wxSizer *arg1 = (wxSizer *) 0 ;
51596 PyObject *arg2 = (PyObject *) 0 ;
51597 int arg3 = (int) 0 ;
51598 int arg4 = (int) 0 ;
51599 int arg5 = (int) 0 ;
51600 PyObject *arg6 = (PyObject *) NULL ;
51601 wxSizerItem *result = 0 ;
51602 void *argp1 = 0 ;
51603 int res1 = 0 ;
51604 int val3 ;
51605 int ecode3 = 0 ;
51606 int val4 ;
51607 int ecode4 = 0 ;
51608 int val5 ;
51609 int ecode5 = 0 ;
51610 PyObject * obj0 = 0 ;
51611 PyObject * obj1 = 0 ;
51612 PyObject * obj2 = 0 ;
51613 PyObject * obj3 = 0 ;
51614 PyObject * obj4 = 0 ;
51615 PyObject * obj5 = 0 ;
51616 char * kwnames[] = {
51617 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
51618 };
51619
51620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51622 if (!SWIG_IsOK(res1)) {
51623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
51624 }
51625 arg1 = reinterpret_cast< wxSizer * >(argp1);
51626 arg2 = obj1;
51627 if (obj2) {
51628 ecode3 = SWIG_AsVal_int(obj2, &val3);
51629 if (!SWIG_IsOK(ecode3)) {
51630 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
51631 }
51632 arg3 = static_cast< int >(val3);
51633 }
51634 if (obj3) {
51635 ecode4 = SWIG_AsVal_int(obj3, &val4);
51636 if (!SWIG_IsOK(ecode4)) {
51637 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
51638 }
51639 arg4 = static_cast< int >(val4);
51640 }
51641 if (obj4) {
51642 ecode5 = SWIG_AsVal_int(obj4, &val5);
51643 if (!SWIG_IsOK(ecode5)) {
51644 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
51645 }
51646 arg5 = static_cast< int >(val5);
51647 }
51648 if (obj5) {
51649 arg6 = obj5;
51650 }
51651 {
51652 PyThreadState* __tstate = wxPyBeginAllowThreads();
51653 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
51654 wxPyEndAllowThreads(__tstate);
51655 if (PyErr_Occurred()) SWIG_fail;
51656 }
51657 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51658 return resultobj;
51659 fail:
51660 return NULL;
51661 }
51662
51663
51664 SWIGINTERN PyObject *_wrap_Sizer_AddF(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51665 PyObject *resultobj = 0;
51666 wxSizer *arg1 = (wxSizer *) 0 ;
51667 PyObject *arg2 = (PyObject *) 0 ;
51668 wxSizerFlags *arg3 = 0 ;
51669 wxSizerItem *result = 0 ;
51670 void *argp1 = 0 ;
51671 int res1 = 0 ;
51672 void *argp3 = 0 ;
51673 int res3 = 0 ;
51674 PyObject * obj0 = 0 ;
51675 PyObject * obj1 = 0 ;
51676 PyObject * obj2 = 0 ;
51677 char * kwnames[] = {
51678 (char *) "self",(char *) "item",(char *) "flags", NULL
51679 };
51680
51681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_AddF",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51683 if (!SWIG_IsOK(res1)) {
51684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddF" "', expected argument " "1"" of type '" "wxSizer *""'");
51685 }
51686 arg1 = reinterpret_cast< wxSizer * >(argp1);
51687 arg2 = obj1;
51688 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxSizerFlags, 0 );
51689 if (!SWIG_IsOK(res3)) {
51690 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_AddF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51691 }
51692 if (!argp3) {
51693 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sizer_AddF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51694 }
51695 arg3 = reinterpret_cast< wxSizerFlags * >(argp3);
51696 {
51697 PyThreadState* __tstate = wxPyBeginAllowThreads();
51698 result = (wxSizerItem *)wxSizer_AddF(arg1,arg2,*arg3);
51699 wxPyEndAllowThreads(__tstate);
51700 if (PyErr_Occurred()) SWIG_fail;
51701 }
51702 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51703 return resultobj;
51704 fail:
51705 return NULL;
51706 }
51707
51708
51709 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51710 PyObject *resultobj = 0;
51711 wxSizer *arg1 = (wxSizer *) 0 ;
51712 int arg2 ;
51713 PyObject *arg3 = (PyObject *) 0 ;
51714 int arg4 = (int) 0 ;
51715 int arg5 = (int) 0 ;
51716 int arg6 = (int) 0 ;
51717 PyObject *arg7 = (PyObject *) NULL ;
51718 wxSizerItem *result = 0 ;
51719 void *argp1 = 0 ;
51720 int res1 = 0 ;
51721 int val2 ;
51722 int ecode2 = 0 ;
51723 int val4 ;
51724 int ecode4 = 0 ;
51725 int val5 ;
51726 int ecode5 = 0 ;
51727 int val6 ;
51728 int ecode6 = 0 ;
51729 PyObject * obj0 = 0 ;
51730 PyObject * obj1 = 0 ;
51731 PyObject * obj2 = 0 ;
51732 PyObject * obj3 = 0 ;
51733 PyObject * obj4 = 0 ;
51734 PyObject * obj5 = 0 ;
51735 PyObject * obj6 = 0 ;
51736 char * kwnames[] = {
51737 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
51738 };
51739
51740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51742 if (!SWIG_IsOK(res1)) {
51743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
51744 }
51745 arg1 = reinterpret_cast< wxSizer * >(argp1);
51746 ecode2 = SWIG_AsVal_int(obj1, &val2);
51747 if (!SWIG_IsOK(ecode2)) {
51748 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
51749 }
51750 arg2 = static_cast< int >(val2);
51751 arg3 = obj2;
51752 if (obj3) {
51753 ecode4 = SWIG_AsVal_int(obj3, &val4);
51754 if (!SWIG_IsOK(ecode4)) {
51755 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
51756 }
51757 arg4 = static_cast< int >(val4);
51758 }
51759 if (obj4) {
51760 ecode5 = SWIG_AsVal_int(obj4, &val5);
51761 if (!SWIG_IsOK(ecode5)) {
51762 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
51763 }
51764 arg5 = static_cast< int >(val5);
51765 }
51766 if (obj5) {
51767 ecode6 = SWIG_AsVal_int(obj5, &val6);
51768 if (!SWIG_IsOK(ecode6)) {
51769 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
51770 }
51771 arg6 = static_cast< int >(val6);
51772 }
51773 if (obj6) {
51774 arg7 = obj6;
51775 }
51776 {
51777 PyThreadState* __tstate = wxPyBeginAllowThreads();
51778 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
51779 wxPyEndAllowThreads(__tstate);
51780 if (PyErr_Occurred()) SWIG_fail;
51781 }
51782 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51783 return resultobj;
51784 fail:
51785 return NULL;
51786 }
51787
51788
51789 SWIGINTERN PyObject *_wrap_Sizer_InsertF(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51790 PyObject *resultobj = 0;
51791 wxSizer *arg1 = (wxSizer *) 0 ;
51792 int arg2 ;
51793 PyObject *arg3 = (PyObject *) 0 ;
51794 wxSizerFlags *arg4 = 0 ;
51795 wxSizerItem *result = 0 ;
51796 void *argp1 = 0 ;
51797 int res1 = 0 ;
51798 int val2 ;
51799 int ecode2 = 0 ;
51800 void *argp4 = 0 ;
51801 int res4 = 0 ;
51802 PyObject * obj0 = 0 ;
51803 PyObject * obj1 = 0 ;
51804 PyObject * obj2 = 0 ;
51805 PyObject * obj3 = 0 ;
51806 char * kwnames[] = {
51807 (char *) "self",(char *) "before",(char *) "item",(char *) "flags", NULL
51808 };
51809
51810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Sizer_InsertF",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51812 if (!SWIG_IsOK(res1)) {
51813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertF" "', expected argument " "1"" of type '" "wxSizer *""'");
51814 }
51815 arg1 = reinterpret_cast< wxSizer * >(argp1);
51816 ecode2 = SWIG_AsVal_int(obj1, &val2);
51817 if (!SWIG_IsOK(ecode2)) {
51818 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertF" "', expected argument " "2"" of type '" "int""'");
51819 }
51820 arg2 = static_cast< int >(val2);
51821 arg3 = obj2;
51822 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxSizerFlags, 0 );
51823 if (!SWIG_IsOK(res4)) {
51824 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Sizer_InsertF" "', expected argument " "4"" of type '" "wxSizerFlags &""'");
51825 }
51826 if (!argp4) {
51827 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sizer_InsertF" "', expected argument " "4"" of type '" "wxSizerFlags &""'");
51828 }
51829 arg4 = reinterpret_cast< wxSizerFlags * >(argp4);
51830 {
51831 PyThreadState* __tstate = wxPyBeginAllowThreads();
51832 result = (wxSizerItem *)wxSizer_InsertF(arg1,arg2,arg3,*arg4);
51833 wxPyEndAllowThreads(__tstate);
51834 if (PyErr_Occurred()) SWIG_fail;
51835 }
51836 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51837 return resultobj;
51838 fail:
51839 return NULL;
51840 }
51841
51842
51843 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51844 PyObject *resultobj = 0;
51845 wxSizer *arg1 = (wxSizer *) 0 ;
51846 PyObject *arg2 = (PyObject *) 0 ;
51847 int arg3 = (int) 0 ;
51848 int arg4 = (int) 0 ;
51849 int arg5 = (int) 0 ;
51850 PyObject *arg6 = (PyObject *) NULL ;
51851 wxSizerItem *result = 0 ;
51852 void *argp1 = 0 ;
51853 int res1 = 0 ;
51854 int val3 ;
51855 int ecode3 = 0 ;
51856 int val4 ;
51857 int ecode4 = 0 ;
51858 int val5 ;
51859 int ecode5 = 0 ;
51860 PyObject * obj0 = 0 ;
51861 PyObject * obj1 = 0 ;
51862 PyObject * obj2 = 0 ;
51863 PyObject * obj3 = 0 ;
51864 PyObject * obj4 = 0 ;
51865 PyObject * obj5 = 0 ;
51866 char * kwnames[] = {
51867 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
51868 };
51869
51870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51872 if (!SWIG_IsOK(res1)) {
51873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
51874 }
51875 arg1 = reinterpret_cast< wxSizer * >(argp1);
51876 arg2 = obj1;
51877 if (obj2) {
51878 ecode3 = SWIG_AsVal_int(obj2, &val3);
51879 if (!SWIG_IsOK(ecode3)) {
51880 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
51881 }
51882 arg3 = static_cast< int >(val3);
51883 }
51884 if (obj3) {
51885 ecode4 = SWIG_AsVal_int(obj3, &val4);
51886 if (!SWIG_IsOK(ecode4)) {
51887 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
51888 }
51889 arg4 = static_cast< int >(val4);
51890 }
51891 if (obj4) {
51892 ecode5 = SWIG_AsVal_int(obj4, &val5);
51893 if (!SWIG_IsOK(ecode5)) {
51894 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
51895 }
51896 arg5 = static_cast< int >(val5);
51897 }
51898 if (obj5) {
51899 arg6 = obj5;
51900 }
51901 {
51902 PyThreadState* __tstate = wxPyBeginAllowThreads();
51903 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
51904 wxPyEndAllowThreads(__tstate);
51905 if (PyErr_Occurred()) SWIG_fail;
51906 }
51907 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51908 return resultobj;
51909 fail:
51910 return NULL;
51911 }
51912
51913
51914 SWIGINTERN PyObject *_wrap_Sizer_PrependF(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51915 PyObject *resultobj = 0;
51916 wxSizer *arg1 = (wxSizer *) 0 ;
51917 PyObject *arg2 = (PyObject *) 0 ;
51918 wxSizerFlags *arg3 = 0 ;
51919 wxSizerItem *result = 0 ;
51920 void *argp1 = 0 ;
51921 int res1 = 0 ;
51922 void *argp3 = 0 ;
51923 int res3 = 0 ;
51924 PyObject * obj0 = 0 ;
51925 PyObject * obj1 = 0 ;
51926 PyObject * obj2 = 0 ;
51927 char * kwnames[] = {
51928 (char *) "self",(char *) "item",(char *) "flags", NULL
51929 };
51930
51931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_PrependF",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51933 if (!SWIG_IsOK(res1)) {
51934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependF" "', expected argument " "1"" of type '" "wxSizer *""'");
51935 }
51936 arg1 = reinterpret_cast< wxSizer * >(argp1);
51937 arg2 = obj1;
51938 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxSizerFlags, 0 );
51939 if (!SWIG_IsOK(res3)) {
51940 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_PrependF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51941 }
51942 if (!argp3) {
51943 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sizer_PrependF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51944 }
51945 arg3 = reinterpret_cast< wxSizerFlags * >(argp3);
51946 {
51947 PyThreadState* __tstate = wxPyBeginAllowThreads();
51948 result = (wxSizerItem *)wxSizer_PrependF(arg1,arg2,*arg3);
51949 wxPyEndAllowThreads(__tstate);
51950 if (PyErr_Occurred()) SWIG_fail;
51951 }
51952 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51953 return resultobj;
51954 fail:
51955 return NULL;
51956 }
51957
51958
51959 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51960 PyObject *resultobj = 0;
51961 wxSizer *arg1 = (wxSizer *) 0 ;
51962 PyObject *arg2 = (PyObject *) 0 ;
51963 bool result;
51964 void *argp1 = 0 ;
51965 int res1 = 0 ;
51966 PyObject * obj0 = 0 ;
51967 PyObject * obj1 = 0 ;
51968 char * kwnames[] = {
51969 (char *) "self",(char *) "item", NULL
51970 };
51971
51972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
51973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51974 if (!SWIG_IsOK(res1)) {
51975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
51976 }
51977 arg1 = reinterpret_cast< wxSizer * >(argp1);
51978 arg2 = obj1;
51979 {
51980 PyThreadState* __tstate = wxPyBeginAllowThreads();
51981 result = (bool)wxSizer_Remove(arg1,arg2);
51982 wxPyEndAllowThreads(__tstate);
51983 if (PyErr_Occurred()) SWIG_fail;
51984 }
51985 {
51986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51987 }
51988 return resultobj;
51989 fail:
51990 return NULL;
51991 }
51992
51993
51994 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51995 PyObject *resultobj = 0;
51996 wxSizer *arg1 = (wxSizer *) 0 ;
51997 PyObject *arg2 = (PyObject *) 0 ;
51998 bool result;
51999 void *argp1 = 0 ;
52000 int res1 = 0 ;
52001 PyObject * obj0 = 0 ;
52002 PyObject * obj1 = 0 ;
52003 char * kwnames[] = {
52004 (char *) "self",(char *) "item", NULL
52005 };
52006
52007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
52008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52009 if (!SWIG_IsOK(res1)) {
52010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
52011 }
52012 arg1 = reinterpret_cast< wxSizer * >(argp1);
52013 arg2 = obj1;
52014 {
52015 PyThreadState* __tstate = wxPyBeginAllowThreads();
52016 result = (bool)wxSizer_Detach(arg1,arg2);
52017 wxPyEndAllowThreads(__tstate);
52018 if (PyErr_Occurred()) SWIG_fail;
52019 }
52020 {
52021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52022 }
52023 return resultobj;
52024 fail:
52025 return NULL;
52026 }
52027
52028
52029 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52030 PyObject *resultobj = 0;
52031 wxSizer *arg1 = (wxSizer *) 0 ;
52032 PyObject *arg2 = (PyObject *) 0 ;
52033 bool arg3 = (bool) false ;
52034 wxSizerItem *result = 0 ;
52035 void *argp1 = 0 ;
52036 int res1 = 0 ;
52037 bool val3 ;
52038 int ecode3 = 0 ;
52039 PyObject * obj0 = 0 ;
52040 PyObject * obj1 = 0 ;
52041 PyObject * obj2 = 0 ;
52042 char * kwnames[] = {
52043 (char *) "self",(char *) "item",(char *) "recursive", NULL
52044 };
52045
52046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Sizer_GetItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52048 if (!SWIG_IsOK(res1)) {
52049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
52050 }
52051 arg1 = reinterpret_cast< wxSizer * >(argp1);
52052 arg2 = obj1;
52053 if (obj2) {
52054 ecode3 = SWIG_AsVal_bool(obj2, &val3);
52055 if (!SWIG_IsOK(ecode3)) {
52056 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_GetItem" "', expected argument " "3"" of type '" "bool""'");
52057 }
52058 arg3 = static_cast< bool >(val3);
52059 }
52060 {
52061 PyThreadState* __tstate = wxPyBeginAllowThreads();
52062 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2,arg3);
52063 wxPyEndAllowThreads(__tstate);
52064 if (PyErr_Occurred()) SWIG_fail;
52065 }
52066 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
52067 return resultobj;
52068 fail:
52069 return NULL;
52070 }
52071
52072
52073 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52074 PyObject *resultobj = 0;
52075 wxSizer *arg1 = (wxSizer *) 0 ;
52076 PyObject *arg2 = (PyObject *) 0 ;
52077 wxSize *arg3 = 0 ;
52078 void *argp1 = 0 ;
52079 int res1 = 0 ;
52080 wxSize temp3 ;
52081 PyObject * obj0 = 0 ;
52082 PyObject * obj1 = 0 ;
52083 PyObject * obj2 = 0 ;
52084 char * kwnames[] = {
52085 (char *) "self",(char *) "item",(char *) "size", NULL
52086 };
52087
52088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52090 if (!SWIG_IsOK(res1)) {
52091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
52092 }
52093 arg1 = reinterpret_cast< wxSizer * >(argp1);
52094 arg2 = obj1;
52095 {
52096 arg3 = &temp3;
52097 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
52098 }
52099 {
52100 PyThreadState* __tstate = wxPyBeginAllowThreads();
52101 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
52102 wxPyEndAllowThreads(__tstate);
52103 if (PyErr_Occurred()) SWIG_fail;
52104 }
52105 resultobj = SWIG_Py_Void();
52106 return resultobj;
52107 fail:
52108 return NULL;
52109 }
52110
52111
52112 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52113 PyObject *resultobj = 0;
52114 wxSizer *arg1 = (wxSizer *) 0 ;
52115 wxWindow *arg2 = (wxWindow *) 0 ;
52116 wxWindow *arg3 = (wxWindow *) 0 ;
52117 bool arg4 = (bool) false ;
52118 bool result;
52119 void *argp1 = 0 ;
52120 int res1 = 0 ;
52121 void *argp2 = 0 ;
52122 int res2 = 0 ;
52123 void *argp3 = 0 ;
52124 int res3 = 0 ;
52125 bool val4 ;
52126 int ecode4 = 0 ;
52127 PyObject * obj0 = 0 ;
52128 PyObject * obj1 = 0 ;
52129 PyObject * obj2 = 0 ;
52130 PyObject * obj3 = 0 ;
52131 char * kwnames[] = {
52132 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
52133 };
52134
52135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52137 if (!SWIG_IsOK(res1)) {
52138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
52139 }
52140 arg1 = reinterpret_cast< wxSizer * >(argp1);
52141 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52142 if (!SWIG_IsOK(res2)) {
52143 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52144 }
52145 arg2 = reinterpret_cast< wxWindow * >(argp2);
52146 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52147 if (!SWIG_IsOK(res3)) {
52148 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
52149 }
52150 arg3 = reinterpret_cast< wxWindow * >(argp3);
52151 if (obj3) {
52152 ecode4 = SWIG_AsVal_bool(obj3, &val4);
52153 if (!SWIG_IsOK(ecode4)) {
52154 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
52155 }
52156 arg4 = static_cast< bool >(val4);
52157 }
52158 {
52159 PyThreadState* __tstate = wxPyBeginAllowThreads();
52160 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
52161 wxPyEndAllowThreads(__tstate);
52162 if (PyErr_Occurred()) SWIG_fail;
52163 }
52164 {
52165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52166 }
52167 return resultobj;
52168 fail:
52169 return NULL;
52170 }
52171
52172
52173 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52174 PyObject *resultobj = 0;
52175 wxSizer *arg1 = (wxSizer *) 0 ;
52176 wxSizer *arg2 = (wxSizer *) 0 ;
52177 wxSizer *arg3 = (wxSizer *) 0 ;
52178 bool arg4 = (bool) false ;
52179 bool result;
52180 void *argp1 = 0 ;
52181 int res1 = 0 ;
52182 void *argp2 = 0 ;
52183 int res2 = 0 ;
52184 void *argp3 = 0 ;
52185 int res3 = 0 ;
52186 bool val4 ;
52187 int ecode4 = 0 ;
52188 PyObject * obj0 = 0 ;
52189 PyObject * obj1 = 0 ;
52190 PyObject * obj2 = 0 ;
52191 PyObject * obj3 = 0 ;
52192 char * kwnames[] = {
52193 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
52194 };
52195
52196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52198 if (!SWIG_IsOK(res1)) {
52199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
52200 }
52201 arg1 = reinterpret_cast< wxSizer * >(argp1);
52202 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52203 if (!SWIG_IsOK(res2)) {
52204 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
52205 }
52206 arg2 = reinterpret_cast< wxSizer * >(argp2);
52207 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
52208 if (!SWIG_IsOK(res3)) {
52209 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
52210 }
52211 arg3 = reinterpret_cast< wxSizer * >(argp3);
52212 if (obj3) {
52213 ecode4 = SWIG_AsVal_bool(obj3, &val4);
52214 if (!SWIG_IsOK(ecode4)) {
52215 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
52216 }
52217 arg4 = static_cast< bool >(val4);
52218 }
52219 {
52220 PyThreadState* __tstate = wxPyBeginAllowThreads();
52221 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
52222 wxPyEndAllowThreads(__tstate);
52223 if (PyErr_Occurred()) SWIG_fail;
52224 }
52225 {
52226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52227 }
52228 return resultobj;
52229 fail:
52230 return NULL;
52231 }
52232
52233
52234 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52235 PyObject *resultobj = 0;
52236 wxSizer *arg1 = (wxSizer *) 0 ;
52237 size_t arg2 ;
52238 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
52239 bool result;
52240 void *argp1 = 0 ;
52241 int res1 = 0 ;
52242 size_t val2 ;
52243 int ecode2 = 0 ;
52244 void *argp3 = 0 ;
52245 int res3 = 0 ;
52246 PyObject * obj0 = 0 ;
52247 PyObject * obj1 = 0 ;
52248 PyObject * obj2 = 0 ;
52249 char * kwnames[] = {
52250 (char *) "self",(char *) "index",(char *) "newitem", NULL
52251 };
52252
52253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52255 if (!SWIG_IsOK(res1)) {
52256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
52257 }
52258 arg1 = reinterpret_cast< wxSizer * >(argp1);
52259 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
52260 if (!SWIG_IsOK(ecode2)) {
52261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
52262 }
52263 arg2 = static_cast< size_t >(val2);
52264 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
52265 if (!SWIG_IsOK(res3)) {
52266 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
52267 }
52268 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
52269 {
52270 PyThreadState* __tstate = wxPyBeginAllowThreads();
52271 result = (bool)(arg1)->Replace(arg2,arg3);
52272 wxPyEndAllowThreads(__tstate);
52273 if (PyErr_Occurred()) SWIG_fail;
52274 }
52275 {
52276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52277 }
52278 return resultobj;
52279 fail:
52280 return NULL;
52281 }
52282
52283
52284 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52285 PyObject *resultobj = 0;
52286 wxSizer *arg1 = (wxSizer *) 0 ;
52287 wxWindow *arg2 = (wxWindow *) 0 ;
52288 void *argp1 = 0 ;
52289 int res1 = 0 ;
52290 void *argp2 = 0 ;
52291 int res2 = 0 ;
52292 PyObject * obj0 = 0 ;
52293 PyObject * obj1 = 0 ;
52294 char * kwnames[] = {
52295 (char *) "self",(char *) "window", NULL
52296 };
52297
52298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
52299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52300 if (!SWIG_IsOK(res1)) {
52301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
52302 }
52303 arg1 = reinterpret_cast< wxSizer * >(argp1);
52304 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52305 if (!SWIG_IsOK(res2)) {
52306 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
52307 }
52308 arg2 = reinterpret_cast< wxWindow * >(argp2);
52309 {
52310 PyThreadState* __tstate = wxPyBeginAllowThreads();
52311 (arg1)->SetContainingWindow(arg2);
52312 wxPyEndAllowThreads(__tstate);
52313 if (PyErr_Occurred()) SWIG_fail;
52314 }
52315 resultobj = SWIG_Py_Void();
52316 return resultobj;
52317 fail:
52318 return NULL;
52319 }
52320
52321
52322 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52323 PyObject *resultobj = 0;
52324 wxSizer *arg1 = (wxSizer *) 0 ;
52325 wxWindow *result = 0 ;
52326 void *argp1 = 0 ;
52327 int res1 = 0 ;
52328 PyObject *swig_obj[1] ;
52329
52330 if (!args) SWIG_fail;
52331 swig_obj[0] = args;
52332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52333 if (!SWIG_IsOK(res1)) {
52334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
52335 }
52336 arg1 = reinterpret_cast< wxSizer * >(argp1);
52337 {
52338 PyThreadState* __tstate = wxPyBeginAllowThreads();
52339 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
52340 wxPyEndAllowThreads(__tstate);
52341 if (PyErr_Occurred()) SWIG_fail;
52342 }
52343 {
52344 resultobj = wxPyMake_wxObject(result, 0);
52345 }
52346 return resultobj;
52347 fail:
52348 return NULL;
52349 }
52350
52351
52352 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52353 PyObject *resultobj = 0;
52354 wxSizer *arg1 = (wxSizer *) 0 ;
52355 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
52356 wxSizerItem *result = 0 ;
52357 void *argp1 = 0 ;
52358 int res1 = 0 ;
52359 int res2 = 0 ;
52360 PyObject * obj0 = 0 ;
52361 PyObject * obj1 = 0 ;
52362 char * kwnames[] = {
52363 (char *) "self",(char *) "item", NULL
52364 };
52365
52366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
52367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52368 if (!SWIG_IsOK(res1)) {
52369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
52370 }
52371 arg1 = reinterpret_cast< wxSizer * >(argp1);
52372 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
52373 if (!SWIG_IsOK(res2)) {
52374 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
52375 }
52376 {
52377 PyThreadState* __tstate = wxPyBeginAllowThreads();
52378 result = (wxSizerItem *)(arg1)->Add(arg2);
52379 wxPyEndAllowThreads(__tstate);
52380 if (PyErr_Occurred()) SWIG_fail;
52381 }
52382 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
52383 return resultobj;
52384 fail:
52385 return NULL;
52386 }
52387
52388
52389 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52390 PyObject *resultobj = 0;
52391 wxSizer *arg1 = (wxSizer *) 0 ;
52392 size_t arg2 ;
52393 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
52394 wxSizerItem *result = 0 ;
52395 void *argp1 = 0 ;
52396 int res1 = 0 ;
52397 size_t val2 ;
52398 int ecode2 = 0 ;
52399 int res3 = 0 ;
52400 PyObject * obj0 = 0 ;
52401 PyObject * obj1 = 0 ;
52402 PyObject * obj2 = 0 ;
52403 char * kwnames[] = {
52404 (char *) "self",(char *) "index",(char *) "item", NULL
52405 };
52406
52407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52409 if (!SWIG_IsOK(res1)) {
52410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
52411 }
52412 arg1 = reinterpret_cast< wxSizer * >(argp1);
52413 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
52414 if (!SWIG_IsOK(ecode2)) {
52415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
52416 }
52417 arg2 = static_cast< size_t >(val2);
52418 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
52419 if (!SWIG_IsOK(res3)) {
52420 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
52421 }
52422 {
52423 PyThreadState* __tstate = wxPyBeginAllowThreads();
52424 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
52425 wxPyEndAllowThreads(__tstate);
52426 if (PyErr_Occurred()) SWIG_fail;
52427 }
52428 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
52429 return resultobj;
52430 fail:
52431 return NULL;
52432 }
52433
52434
52435 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52436 PyObject *resultobj = 0;
52437 wxSizer *arg1 = (wxSizer *) 0 ;
52438 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
52439 wxSizerItem *result = 0 ;
52440 void *argp1 = 0 ;
52441 int res1 = 0 ;
52442 int res2 = 0 ;
52443 PyObject * obj0 = 0 ;
52444 PyObject * obj1 = 0 ;
52445 char * kwnames[] = {
52446 (char *) "self",(char *) "item", NULL
52447 };
52448
52449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
52450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52451 if (!SWIG_IsOK(res1)) {
52452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
52453 }
52454 arg1 = reinterpret_cast< wxSizer * >(argp1);
52455 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
52456 if (!SWIG_IsOK(res2)) {
52457 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
52458 }
52459 {
52460 PyThreadState* __tstate = wxPyBeginAllowThreads();
52461 result = (wxSizerItem *)(arg1)->Prepend(arg2);
52462 wxPyEndAllowThreads(__tstate);
52463 if (PyErr_Occurred()) SWIG_fail;
52464 }
52465 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
52466 return resultobj;
52467 fail:
52468 return NULL;
52469 }
52470
52471
52472 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52473 PyObject *resultobj = 0;
52474 wxSizer *arg1 = (wxSizer *) 0 ;
52475 int arg2 ;
52476 int arg3 ;
52477 int arg4 ;
52478 int arg5 ;
52479 void *argp1 = 0 ;
52480 int res1 = 0 ;
52481 int val2 ;
52482 int ecode2 = 0 ;
52483 int val3 ;
52484 int ecode3 = 0 ;
52485 int val4 ;
52486 int ecode4 = 0 ;
52487 int val5 ;
52488 int ecode5 = 0 ;
52489 PyObject * obj0 = 0 ;
52490 PyObject * obj1 = 0 ;
52491 PyObject * obj2 = 0 ;
52492 PyObject * obj3 = 0 ;
52493 PyObject * obj4 = 0 ;
52494 char * kwnames[] = {
52495 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
52496 };
52497
52498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
52499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52500 if (!SWIG_IsOK(res1)) {
52501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
52502 }
52503 arg1 = reinterpret_cast< wxSizer * >(argp1);
52504 ecode2 = SWIG_AsVal_int(obj1, &val2);
52505 if (!SWIG_IsOK(ecode2)) {
52506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
52507 }
52508 arg2 = static_cast< int >(val2);
52509 ecode3 = SWIG_AsVal_int(obj2, &val3);
52510 if (!SWIG_IsOK(ecode3)) {
52511 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
52512 }
52513 arg3 = static_cast< int >(val3);
52514 ecode4 = SWIG_AsVal_int(obj3, &val4);
52515 if (!SWIG_IsOK(ecode4)) {
52516 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
52517 }
52518 arg4 = static_cast< int >(val4);
52519 ecode5 = SWIG_AsVal_int(obj4, &val5);
52520 if (!SWIG_IsOK(ecode5)) {
52521 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
52522 }
52523 arg5 = static_cast< int >(val5);
52524 {
52525 PyThreadState* __tstate = wxPyBeginAllowThreads();
52526 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
52527 wxPyEndAllowThreads(__tstate);
52528 if (PyErr_Occurred()) SWIG_fail;
52529 }
52530 resultobj = SWIG_Py_Void();
52531 return resultobj;
52532 fail:
52533 return NULL;
52534 }
52535
52536
52537 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52538 PyObject *resultobj = 0;
52539 wxSizer *arg1 = (wxSizer *) 0 ;
52540 wxSize *arg2 = 0 ;
52541 void *argp1 = 0 ;
52542 int res1 = 0 ;
52543 wxSize temp2 ;
52544 PyObject * obj0 = 0 ;
52545 PyObject * obj1 = 0 ;
52546 char * kwnames[] = {
52547 (char *) "self",(char *) "size", NULL
52548 };
52549
52550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
52551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52552 if (!SWIG_IsOK(res1)) {
52553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
52554 }
52555 arg1 = reinterpret_cast< wxSizer * >(argp1);
52556 {
52557 arg2 = &temp2;
52558 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
52559 }
52560 {
52561 PyThreadState* __tstate = wxPyBeginAllowThreads();
52562 (arg1)->SetMinSize((wxSize const &)*arg2);
52563 wxPyEndAllowThreads(__tstate);
52564 if (PyErr_Occurred()) SWIG_fail;
52565 }
52566 resultobj = SWIG_Py_Void();
52567 return resultobj;
52568 fail:
52569 return NULL;
52570 }
52571
52572
52573 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52574 PyObject *resultobj = 0;
52575 wxSizer *arg1 = (wxSizer *) 0 ;
52576 wxSize result;
52577 void *argp1 = 0 ;
52578 int res1 = 0 ;
52579 PyObject *swig_obj[1] ;
52580
52581 if (!args) SWIG_fail;
52582 swig_obj[0] = args;
52583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52584 if (!SWIG_IsOK(res1)) {
52585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
52586 }
52587 arg1 = reinterpret_cast< wxSizer * >(argp1);
52588 {
52589 PyThreadState* __tstate = wxPyBeginAllowThreads();
52590 result = (arg1)->GetSize();
52591 wxPyEndAllowThreads(__tstate);
52592 if (PyErr_Occurred()) SWIG_fail;
52593 }
52594 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
52595 return resultobj;
52596 fail:
52597 return NULL;
52598 }
52599
52600
52601 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52602 PyObject *resultobj = 0;
52603 wxSizer *arg1 = (wxSizer *) 0 ;
52604 wxPoint result;
52605 void *argp1 = 0 ;
52606 int res1 = 0 ;
52607 PyObject *swig_obj[1] ;
52608
52609 if (!args) SWIG_fail;
52610 swig_obj[0] = args;
52611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52612 if (!SWIG_IsOK(res1)) {
52613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
52614 }
52615 arg1 = reinterpret_cast< wxSizer * >(argp1);
52616 {
52617 PyThreadState* __tstate = wxPyBeginAllowThreads();
52618 result = (arg1)->GetPosition();
52619 wxPyEndAllowThreads(__tstate);
52620 if (PyErr_Occurred()) SWIG_fail;
52621 }
52622 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
52623 return resultobj;
52624 fail:
52625 return NULL;
52626 }
52627
52628
52629 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52630 PyObject *resultobj = 0;
52631 wxSizer *arg1 = (wxSizer *) 0 ;
52632 wxSize result;
52633 void *argp1 = 0 ;
52634 int res1 = 0 ;
52635 PyObject *swig_obj[1] ;
52636
52637 if (!args) SWIG_fail;
52638 swig_obj[0] = args;
52639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52640 if (!SWIG_IsOK(res1)) {
52641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
52642 }
52643 arg1 = reinterpret_cast< wxSizer * >(argp1);
52644 {
52645 PyThreadState* __tstate = wxPyBeginAllowThreads();
52646 result = (arg1)->GetMinSize();
52647 wxPyEndAllowThreads(__tstate);
52648 if (PyErr_Occurred()) SWIG_fail;
52649 }
52650 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
52651 return resultobj;
52652 fail:
52653 return NULL;
52654 }
52655
52656
52657 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52658 PyObject *resultobj = 0;
52659 wxSizer *arg1 = (wxSizer *) 0 ;
52660 void *argp1 = 0 ;
52661 int res1 = 0 ;
52662 PyObject *swig_obj[1] ;
52663
52664 if (!args) SWIG_fail;
52665 swig_obj[0] = args;
52666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52667 if (!SWIG_IsOK(res1)) {
52668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
52669 }
52670 arg1 = reinterpret_cast< wxSizer * >(argp1);
52671 {
52672 PyThreadState* __tstate = wxPyBeginAllowThreads();
52673 (arg1)->RecalcSizes();
52674 wxPyEndAllowThreads(__tstate);
52675 if (PyErr_Occurred()) SWIG_fail;
52676 }
52677 resultobj = SWIG_Py_Void();
52678 return resultobj;
52679 fail:
52680 return NULL;
52681 }
52682
52683
52684 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52685 PyObject *resultobj = 0;
52686 wxSizer *arg1 = (wxSizer *) 0 ;
52687 wxSize result;
52688 void *argp1 = 0 ;
52689 int res1 = 0 ;
52690 PyObject *swig_obj[1] ;
52691
52692 if (!args) SWIG_fail;
52693 swig_obj[0] = args;
52694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52695 if (!SWIG_IsOK(res1)) {
52696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
52697 }
52698 arg1 = reinterpret_cast< wxSizer * >(argp1);
52699 {
52700 PyThreadState* __tstate = wxPyBeginAllowThreads();
52701 result = (arg1)->CalcMin();
52702 wxPyEndAllowThreads(__tstate);
52703 if (PyErr_Occurred()) SWIG_fail;
52704 }
52705 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
52706 return resultobj;
52707 fail:
52708 return NULL;
52709 }
52710
52711
52712 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52713 PyObject *resultobj = 0;
52714 wxSizer *arg1 = (wxSizer *) 0 ;
52715 void *argp1 = 0 ;
52716 int res1 = 0 ;
52717 PyObject *swig_obj[1] ;
52718
52719 if (!args) SWIG_fail;
52720 swig_obj[0] = args;
52721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52722 if (!SWIG_IsOK(res1)) {
52723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
52724 }
52725 arg1 = reinterpret_cast< wxSizer * >(argp1);
52726 {
52727 PyThreadState* __tstate = wxPyBeginAllowThreads();
52728 (arg1)->Layout();
52729 wxPyEndAllowThreads(__tstate);
52730 if (PyErr_Occurred()) SWIG_fail;
52731 }
52732 resultobj = SWIG_Py_Void();
52733 return resultobj;
52734 fail:
52735 return NULL;
52736 }
52737
52738
52739 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52740 PyObject *resultobj = 0;
52741 wxSizer *arg1 = (wxSizer *) 0 ;
52742 wxWindow *arg2 = (wxWindow *) 0 ;
52743 wxSize result;
52744 void *argp1 = 0 ;
52745 int res1 = 0 ;
52746 void *argp2 = 0 ;
52747 int res2 = 0 ;
52748 PyObject * obj0 = 0 ;
52749 PyObject * obj1 = 0 ;
52750 char * kwnames[] = {
52751 (char *) "self",(char *) "window", NULL
52752 };
52753
52754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
52755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52756 if (!SWIG_IsOK(res1)) {
52757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
52758 }
52759 arg1 = reinterpret_cast< wxSizer * >(argp1);
52760 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52761 if (!SWIG_IsOK(res2)) {
52762 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
52763 }
52764 arg2 = reinterpret_cast< wxWindow * >(argp2);
52765 {
52766 PyThreadState* __tstate = wxPyBeginAllowThreads();
52767 result = (arg1)->Fit(arg2);
52768 wxPyEndAllowThreads(__tstate);
52769 if (PyErr_Occurred()) SWIG_fail;
52770 }
52771 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
52772 return resultobj;
52773 fail:
52774 return NULL;
52775 }
52776
52777
52778 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52779 PyObject *resultobj = 0;
52780 wxSizer *arg1 = (wxSizer *) 0 ;
52781 wxWindow *arg2 = (wxWindow *) 0 ;
52782 void *argp1 = 0 ;
52783 int res1 = 0 ;
52784 void *argp2 = 0 ;
52785 int res2 = 0 ;
52786 PyObject * obj0 = 0 ;
52787 PyObject * obj1 = 0 ;
52788 char * kwnames[] = {
52789 (char *) "self",(char *) "window", NULL
52790 };
52791
52792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
52793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52794 if (!SWIG_IsOK(res1)) {
52795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
52796 }
52797 arg1 = reinterpret_cast< wxSizer * >(argp1);
52798 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52799 if (!SWIG_IsOK(res2)) {
52800 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
52801 }
52802 arg2 = reinterpret_cast< wxWindow * >(argp2);
52803 {
52804 PyThreadState* __tstate = wxPyBeginAllowThreads();
52805 (arg1)->FitInside(arg2);
52806 wxPyEndAllowThreads(__tstate);
52807 if (PyErr_Occurred()) SWIG_fail;
52808 }
52809 resultobj = SWIG_Py_Void();
52810 return resultobj;
52811 fail:
52812 return NULL;
52813 }
52814
52815
52816 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52817 PyObject *resultobj = 0;
52818 wxSizer *arg1 = (wxSizer *) 0 ;
52819 wxWindow *arg2 = (wxWindow *) 0 ;
52820 void *argp1 = 0 ;
52821 int res1 = 0 ;
52822 void *argp2 = 0 ;
52823 int res2 = 0 ;
52824 PyObject * obj0 = 0 ;
52825 PyObject * obj1 = 0 ;
52826 char * kwnames[] = {
52827 (char *) "self",(char *) "window", NULL
52828 };
52829
52830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
52831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52832 if (!SWIG_IsOK(res1)) {
52833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
52834 }
52835 arg1 = reinterpret_cast< wxSizer * >(argp1);
52836 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52837 if (!SWIG_IsOK(res2)) {
52838 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
52839 }
52840 arg2 = reinterpret_cast< wxWindow * >(argp2);
52841 {
52842 PyThreadState* __tstate = wxPyBeginAllowThreads();
52843 (arg1)->SetSizeHints(arg2);
52844 wxPyEndAllowThreads(__tstate);
52845 if (PyErr_Occurred()) SWIG_fail;
52846 }
52847 resultobj = SWIG_Py_Void();
52848 return resultobj;
52849 fail:
52850 return NULL;
52851 }
52852
52853
52854 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52855 PyObject *resultobj = 0;
52856 wxSizer *arg1 = (wxSizer *) 0 ;
52857 wxWindow *arg2 = (wxWindow *) 0 ;
52858 void *argp1 = 0 ;
52859 int res1 = 0 ;
52860 void *argp2 = 0 ;
52861 int res2 = 0 ;
52862 PyObject * obj0 = 0 ;
52863 PyObject * obj1 = 0 ;
52864 char * kwnames[] = {
52865 (char *) "self",(char *) "window", NULL
52866 };
52867
52868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
52869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52870 if (!SWIG_IsOK(res1)) {
52871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
52872 }
52873 arg1 = reinterpret_cast< wxSizer * >(argp1);
52874 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52875 if (!SWIG_IsOK(res2)) {
52876 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
52877 }
52878 arg2 = reinterpret_cast< wxWindow * >(argp2);
52879 {
52880 PyThreadState* __tstate = wxPyBeginAllowThreads();
52881 (arg1)->SetVirtualSizeHints(arg2);
52882 wxPyEndAllowThreads(__tstate);
52883 if (PyErr_Occurred()) SWIG_fail;
52884 }
52885 resultobj = SWIG_Py_Void();
52886 return resultobj;
52887 fail:
52888 return NULL;
52889 }
52890
52891
52892 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52893 PyObject *resultobj = 0;
52894 wxSizer *arg1 = (wxSizer *) 0 ;
52895 bool arg2 = (bool) false ;
52896 void *argp1 = 0 ;
52897 int res1 = 0 ;
52898 bool val2 ;
52899 int ecode2 = 0 ;
52900 PyObject * obj0 = 0 ;
52901 PyObject * obj1 = 0 ;
52902 char * kwnames[] = {
52903 (char *) "self",(char *) "deleteWindows", NULL
52904 };
52905
52906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
52907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52908 if (!SWIG_IsOK(res1)) {
52909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
52910 }
52911 arg1 = reinterpret_cast< wxSizer * >(argp1);
52912 if (obj1) {
52913 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52914 if (!SWIG_IsOK(ecode2)) {
52915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
52916 }
52917 arg2 = static_cast< bool >(val2);
52918 }
52919 {
52920 PyThreadState* __tstate = wxPyBeginAllowThreads();
52921 (arg1)->Clear(arg2);
52922 wxPyEndAllowThreads(__tstate);
52923 if (PyErr_Occurred()) SWIG_fail;
52924 }
52925 resultobj = SWIG_Py_Void();
52926 return resultobj;
52927 fail:
52928 return NULL;
52929 }
52930
52931
52932 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52933 PyObject *resultobj = 0;
52934 wxSizer *arg1 = (wxSizer *) 0 ;
52935 void *argp1 = 0 ;
52936 int res1 = 0 ;
52937 PyObject *swig_obj[1] ;
52938
52939 if (!args) SWIG_fail;
52940 swig_obj[0] = args;
52941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52942 if (!SWIG_IsOK(res1)) {
52943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
52944 }
52945 arg1 = reinterpret_cast< wxSizer * >(argp1);
52946 {
52947 PyThreadState* __tstate = wxPyBeginAllowThreads();
52948 (arg1)->DeleteWindows();
52949 wxPyEndAllowThreads(__tstate);
52950 if (PyErr_Occurred()) SWIG_fail;
52951 }
52952 resultobj = SWIG_Py_Void();
52953 return resultobj;
52954 fail:
52955 return NULL;
52956 }
52957
52958
52959 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52960 PyObject *resultobj = 0;
52961 wxSizer *arg1 = (wxSizer *) 0 ;
52962 PyObject *result = 0 ;
52963 void *argp1 = 0 ;
52964 int res1 = 0 ;
52965 PyObject *swig_obj[1] ;
52966
52967 if (!args) SWIG_fail;
52968 swig_obj[0] = args;
52969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52970 if (!SWIG_IsOK(res1)) {
52971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
52972 }
52973 arg1 = reinterpret_cast< wxSizer * >(argp1);
52974 {
52975 PyThreadState* __tstate = wxPyBeginAllowThreads();
52976 result = (PyObject *)wxSizer_GetChildren(arg1);
52977 wxPyEndAllowThreads(__tstate);
52978 if (PyErr_Occurred()) SWIG_fail;
52979 }
52980 resultobj = result;
52981 return resultobj;
52982 fail:
52983 return NULL;
52984 }
52985
52986
52987 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52988 PyObject *resultobj = 0;
52989 wxSizer *arg1 = (wxSizer *) 0 ;
52990 PyObject *arg2 = (PyObject *) 0 ;
52991 bool arg3 = (bool) true ;
52992 bool arg4 = (bool) false ;
52993 bool result;
52994 void *argp1 = 0 ;
52995 int res1 = 0 ;
52996 bool val3 ;
52997 int ecode3 = 0 ;
52998 bool val4 ;
52999 int ecode4 = 0 ;
53000 PyObject * obj0 = 0 ;
53001 PyObject * obj1 = 0 ;
53002 PyObject * obj2 = 0 ;
53003 PyObject * obj3 = 0 ;
53004 char * kwnames[] = {
53005 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
53006 };
53007
53008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
53010 if (!SWIG_IsOK(res1)) {
53011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
53012 }
53013 arg1 = reinterpret_cast< wxSizer * >(argp1);
53014 arg2 = obj1;
53015 if (obj2) {
53016 ecode3 = SWIG_AsVal_bool(obj2, &val3);
53017 if (!SWIG_IsOK(ecode3)) {
53018 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
53019 }
53020 arg3 = static_cast< bool >(val3);
53021 }
53022 if (obj3) {
53023 ecode4 = SWIG_AsVal_bool(obj3, &val4);
53024 if (!SWIG_IsOK(ecode4)) {
53025 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
53026 }
53027 arg4 = static_cast< bool >(val4);
53028 }
53029 {
53030 PyThreadState* __tstate = wxPyBeginAllowThreads();
53031 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
53032 wxPyEndAllowThreads(__tstate);
53033 if (PyErr_Occurred()) SWIG_fail;
53034 }
53035 {
53036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53037 }
53038 return resultobj;
53039 fail:
53040 return NULL;
53041 }
53042
53043
53044 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53045 PyObject *resultobj = 0;
53046 wxSizer *arg1 = (wxSizer *) 0 ;
53047 PyObject *arg2 = (PyObject *) 0 ;
53048 bool result;
53049 void *argp1 = 0 ;
53050 int res1 = 0 ;
53051 PyObject * obj0 = 0 ;
53052 PyObject * obj1 = 0 ;
53053 char * kwnames[] = {
53054 (char *) "self",(char *) "item", NULL
53055 };
53056
53057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
53058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
53059 if (!SWIG_IsOK(res1)) {
53060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
53061 }
53062 arg1 = reinterpret_cast< wxSizer * >(argp1);
53063 arg2 = obj1;
53064 {
53065 PyThreadState* __tstate = wxPyBeginAllowThreads();
53066 result = (bool)wxSizer_IsShown(arg1,arg2);
53067 wxPyEndAllowThreads(__tstate);
53068 if (PyErr_Occurred()) SWIG_fail;
53069 }
53070 {
53071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53072 }
53073 return resultobj;
53074 fail:
53075 return NULL;
53076 }
53077
53078
53079 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53080 PyObject *resultobj = 0;
53081 wxSizer *arg1 = (wxSizer *) 0 ;
53082 bool arg2 ;
53083 void *argp1 = 0 ;
53084 int res1 = 0 ;
53085 bool val2 ;
53086 int ecode2 = 0 ;
53087 PyObject * obj0 = 0 ;
53088 PyObject * obj1 = 0 ;
53089 char * kwnames[] = {
53090 (char *) "self",(char *) "show", NULL
53091 };
53092
53093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
53094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
53095 if (!SWIG_IsOK(res1)) {
53096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
53097 }
53098 arg1 = reinterpret_cast< wxSizer * >(argp1);
53099 ecode2 = SWIG_AsVal_bool(obj1, &val2);
53100 if (!SWIG_IsOK(ecode2)) {
53101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
53102 }
53103 arg2 = static_cast< bool >(val2);
53104 {
53105 PyThreadState* __tstate = wxPyBeginAllowThreads();
53106 (arg1)->ShowItems(arg2);
53107 wxPyEndAllowThreads(__tstate);
53108 if (PyErr_Occurred()) SWIG_fail;
53109 }
53110 resultobj = SWIG_Py_Void();
53111 return resultobj;
53112 fail:
53113 return NULL;
53114 }
53115
53116
53117 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53118 PyObject *obj;
53119 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53120 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
53121 return SWIG_Py_Void();
53122 }
53123
53124 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53125 PyObject *resultobj = 0;
53126 wxPySizer *result = 0 ;
53127
53128 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
53129 {
53130 PyThreadState* __tstate = wxPyBeginAllowThreads();
53131 result = (wxPySizer *)new wxPySizer();
53132 wxPyEndAllowThreads(__tstate);
53133 if (PyErr_Occurred()) SWIG_fail;
53134 }
53135 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
53136 return resultobj;
53137 fail:
53138 return NULL;
53139 }
53140
53141
53142 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53143 PyObject *resultobj = 0;
53144 wxPySizer *arg1 = (wxPySizer *) 0 ;
53145 PyObject *arg2 = (PyObject *) 0 ;
53146 PyObject *arg3 = (PyObject *) 0 ;
53147 void *argp1 = 0 ;
53148 int res1 = 0 ;
53149 PyObject * obj0 = 0 ;
53150 PyObject * obj1 = 0 ;
53151 PyObject * obj2 = 0 ;
53152 char * kwnames[] = {
53153 (char *) "self",(char *) "self",(char *) "_class", NULL
53154 };
53155
53156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
53158 if (!SWIG_IsOK(res1)) {
53159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
53160 }
53161 arg1 = reinterpret_cast< wxPySizer * >(argp1);
53162 arg2 = obj1;
53163 arg3 = obj2;
53164 {
53165 PyThreadState* __tstate = wxPyBeginAllowThreads();
53166 (arg1)->_setCallbackInfo(arg2,arg3);
53167 wxPyEndAllowThreads(__tstate);
53168 if (PyErr_Occurred()) SWIG_fail;
53169 }
53170 resultobj = SWIG_Py_Void();
53171 return resultobj;
53172 fail:
53173 return NULL;
53174 }
53175
53176
53177 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53178 PyObject *obj;
53179 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53180 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
53181 return SWIG_Py_Void();
53182 }
53183
53184 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53185 return SWIG_Python_InitShadowInstance(args);
53186 }
53187
53188 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53189 PyObject *resultobj = 0;
53190 int arg1 = (int) wxHORIZONTAL ;
53191 wxBoxSizer *result = 0 ;
53192 int val1 ;
53193 int ecode1 = 0 ;
53194 PyObject * obj0 = 0 ;
53195 char * kwnames[] = {
53196 (char *) "orient", NULL
53197 };
53198
53199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
53200 if (obj0) {
53201 ecode1 = SWIG_AsVal_int(obj0, &val1);
53202 if (!SWIG_IsOK(ecode1)) {
53203 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
53204 }
53205 arg1 = static_cast< int >(val1);
53206 }
53207 {
53208 PyThreadState* __tstate = wxPyBeginAllowThreads();
53209 result = (wxBoxSizer *)new wxBoxSizer(arg1);
53210 wxPyEndAllowThreads(__tstate);
53211 if (PyErr_Occurred()) SWIG_fail;
53212 }
53213 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
53214 return resultobj;
53215 fail:
53216 return NULL;
53217 }
53218
53219
53220 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53221 PyObject *resultobj = 0;
53222 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
53223 int result;
53224 void *argp1 = 0 ;
53225 int res1 = 0 ;
53226 PyObject *swig_obj[1] ;
53227
53228 if (!args) SWIG_fail;
53229 swig_obj[0] = args;
53230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
53231 if (!SWIG_IsOK(res1)) {
53232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
53233 }
53234 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
53235 {
53236 PyThreadState* __tstate = wxPyBeginAllowThreads();
53237 result = (int)(arg1)->GetOrientation();
53238 wxPyEndAllowThreads(__tstate);
53239 if (PyErr_Occurred()) SWIG_fail;
53240 }
53241 resultobj = SWIG_From_int(static_cast< int >(result));
53242 return resultobj;
53243 fail:
53244 return NULL;
53245 }
53246
53247
53248 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53249 PyObject *resultobj = 0;
53250 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
53251 int arg2 ;
53252 void *argp1 = 0 ;
53253 int res1 = 0 ;
53254 int val2 ;
53255 int ecode2 = 0 ;
53256 PyObject * obj0 = 0 ;
53257 PyObject * obj1 = 0 ;
53258 char * kwnames[] = {
53259 (char *) "self",(char *) "orient", NULL
53260 };
53261
53262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
53263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
53264 if (!SWIG_IsOK(res1)) {
53265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
53266 }
53267 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
53268 ecode2 = SWIG_AsVal_int(obj1, &val2);
53269 if (!SWIG_IsOK(ecode2)) {
53270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
53271 }
53272 arg2 = static_cast< int >(val2);
53273 {
53274 PyThreadState* __tstate = wxPyBeginAllowThreads();
53275 (arg1)->SetOrientation(arg2);
53276 wxPyEndAllowThreads(__tstate);
53277 if (PyErr_Occurred()) SWIG_fail;
53278 }
53279 resultobj = SWIG_Py_Void();
53280 return resultobj;
53281 fail:
53282 return NULL;
53283 }
53284
53285
53286 SWIGINTERN PyObject *_wrap_BoxSizer_IsVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53287 PyObject *resultobj = 0;
53288 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
53289 bool result;
53290 void *argp1 = 0 ;
53291 int res1 = 0 ;
53292 PyObject *swig_obj[1] ;
53293
53294 if (!args) SWIG_fail;
53295 swig_obj[0] = args;
53296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
53297 if (!SWIG_IsOK(res1)) {
53298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_IsVertical" "', expected argument " "1"" of type '" "wxBoxSizer const *""'");
53299 }
53300 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
53301 {
53302 PyThreadState* __tstate = wxPyBeginAllowThreads();
53303 result = (bool)((wxBoxSizer const *)arg1)->IsVertical();
53304 wxPyEndAllowThreads(__tstate);
53305 if (PyErr_Occurred()) SWIG_fail;
53306 }
53307 {
53308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53309 }
53310 return resultobj;
53311 fail:
53312 return NULL;
53313 }
53314
53315
53316 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53317 PyObject *obj;
53318 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53319 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
53320 return SWIG_Py_Void();
53321 }
53322
53323 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53324 return SWIG_Python_InitShadowInstance(args);
53325 }
53326
53327 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53328 PyObject *resultobj = 0;
53329 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
53330 int arg2 = (int) wxHORIZONTAL ;
53331 wxStaticBoxSizer *result = 0 ;
53332 void *argp1 = 0 ;
53333 int res1 = 0 ;
53334 int val2 ;
53335 int ecode2 = 0 ;
53336 PyObject * obj0 = 0 ;
53337 PyObject * obj1 = 0 ;
53338 char * kwnames[] = {
53339 (char *) "box",(char *) "orient", NULL
53340 };
53341
53342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
53344 if (!SWIG_IsOK(res1)) {
53345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
53346 }
53347 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
53348 if (obj1) {
53349 ecode2 = SWIG_AsVal_int(obj1, &val2);
53350 if (!SWIG_IsOK(ecode2)) {
53351 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
53352 }
53353 arg2 = static_cast< int >(val2);
53354 }
53355 {
53356 PyThreadState* __tstate = wxPyBeginAllowThreads();
53357 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
53358 wxPyEndAllowThreads(__tstate);
53359 if (PyErr_Occurred()) SWIG_fail;
53360 }
53361 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
53362 return resultobj;
53363 fail:
53364 return NULL;
53365 }
53366
53367
53368 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53369 PyObject *resultobj = 0;
53370 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
53371 wxStaticBox *result = 0 ;
53372 void *argp1 = 0 ;
53373 int res1 = 0 ;
53374 PyObject *swig_obj[1] ;
53375
53376 if (!args) SWIG_fail;
53377 swig_obj[0] = args;
53378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
53379 if (!SWIG_IsOK(res1)) {
53380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
53381 }
53382 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
53383 {
53384 PyThreadState* __tstate = wxPyBeginAllowThreads();
53385 result = (wxStaticBox *)(arg1)->GetStaticBox();
53386 wxPyEndAllowThreads(__tstate);
53387 if (PyErr_Occurred()) SWIG_fail;
53388 }
53389 {
53390 resultobj = wxPyMake_wxObject(result, (bool)0);
53391 }
53392 return resultobj;
53393 fail:
53394 return NULL;
53395 }
53396
53397
53398 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53399 PyObject *obj;
53400 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53401 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
53402 return SWIG_Py_Void();
53403 }
53404
53405 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53406 return SWIG_Python_InitShadowInstance(args);
53407 }
53408
53409 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53410 PyObject *resultobj = 0;
53411 int arg1 = (int) 1 ;
53412 int arg2 = (int) 0 ;
53413 int arg3 = (int) 0 ;
53414 int arg4 = (int) 0 ;
53415 wxGridSizer *result = 0 ;
53416 int val1 ;
53417 int ecode1 = 0 ;
53418 int val2 ;
53419 int ecode2 = 0 ;
53420 int val3 ;
53421 int ecode3 = 0 ;
53422 int val4 ;
53423 int ecode4 = 0 ;
53424 PyObject * obj0 = 0 ;
53425 PyObject * obj1 = 0 ;
53426 PyObject * obj2 = 0 ;
53427 PyObject * obj3 = 0 ;
53428 char * kwnames[] = {
53429 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
53430 };
53431
53432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53433 if (obj0) {
53434 ecode1 = SWIG_AsVal_int(obj0, &val1);
53435 if (!SWIG_IsOK(ecode1)) {
53436 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
53437 }
53438 arg1 = static_cast< int >(val1);
53439 }
53440 if (obj1) {
53441 ecode2 = SWIG_AsVal_int(obj1, &val2);
53442 if (!SWIG_IsOK(ecode2)) {
53443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
53444 }
53445 arg2 = static_cast< int >(val2);
53446 }
53447 if (obj2) {
53448 ecode3 = SWIG_AsVal_int(obj2, &val3);
53449 if (!SWIG_IsOK(ecode3)) {
53450 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
53451 }
53452 arg3 = static_cast< int >(val3);
53453 }
53454 if (obj3) {
53455 ecode4 = SWIG_AsVal_int(obj3, &val4);
53456 if (!SWIG_IsOK(ecode4)) {
53457 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
53458 }
53459 arg4 = static_cast< int >(val4);
53460 }
53461 {
53462 PyThreadState* __tstate = wxPyBeginAllowThreads();
53463 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
53464 wxPyEndAllowThreads(__tstate);
53465 if (PyErr_Occurred()) SWIG_fail;
53466 }
53467 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
53468 return resultobj;
53469 fail:
53470 return NULL;
53471 }
53472
53473
53474 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53475 PyObject *resultobj = 0;
53476 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53477 int arg2 ;
53478 void *argp1 = 0 ;
53479 int res1 = 0 ;
53480 int val2 ;
53481 int ecode2 = 0 ;
53482 PyObject * obj0 = 0 ;
53483 PyObject * obj1 = 0 ;
53484 char * kwnames[] = {
53485 (char *) "self",(char *) "cols", NULL
53486 };
53487
53488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
53489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53490 if (!SWIG_IsOK(res1)) {
53491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53492 }
53493 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53494 ecode2 = SWIG_AsVal_int(obj1, &val2);
53495 if (!SWIG_IsOK(ecode2)) {
53496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
53497 }
53498 arg2 = static_cast< int >(val2);
53499 {
53500 PyThreadState* __tstate = wxPyBeginAllowThreads();
53501 (arg1)->SetCols(arg2);
53502 wxPyEndAllowThreads(__tstate);
53503 if (PyErr_Occurred()) SWIG_fail;
53504 }
53505 resultobj = SWIG_Py_Void();
53506 return resultobj;
53507 fail:
53508 return NULL;
53509 }
53510
53511
53512 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53513 PyObject *resultobj = 0;
53514 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53515 int arg2 ;
53516 void *argp1 = 0 ;
53517 int res1 = 0 ;
53518 int val2 ;
53519 int ecode2 = 0 ;
53520 PyObject * obj0 = 0 ;
53521 PyObject * obj1 = 0 ;
53522 char * kwnames[] = {
53523 (char *) "self",(char *) "rows", NULL
53524 };
53525
53526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
53527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53528 if (!SWIG_IsOK(res1)) {
53529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53530 }
53531 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53532 ecode2 = SWIG_AsVal_int(obj1, &val2);
53533 if (!SWIG_IsOK(ecode2)) {
53534 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
53535 }
53536 arg2 = static_cast< int >(val2);
53537 {
53538 PyThreadState* __tstate = wxPyBeginAllowThreads();
53539 (arg1)->SetRows(arg2);
53540 wxPyEndAllowThreads(__tstate);
53541 if (PyErr_Occurred()) SWIG_fail;
53542 }
53543 resultobj = SWIG_Py_Void();
53544 return resultobj;
53545 fail:
53546 return NULL;
53547 }
53548
53549
53550 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53551 PyObject *resultobj = 0;
53552 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53553 int arg2 ;
53554 void *argp1 = 0 ;
53555 int res1 = 0 ;
53556 int val2 ;
53557 int ecode2 = 0 ;
53558 PyObject * obj0 = 0 ;
53559 PyObject * obj1 = 0 ;
53560 char * kwnames[] = {
53561 (char *) "self",(char *) "gap", NULL
53562 };
53563
53564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
53565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53566 if (!SWIG_IsOK(res1)) {
53567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53568 }
53569 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53570 ecode2 = SWIG_AsVal_int(obj1, &val2);
53571 if (!SWIG_IsOK(ecode2)) {
53572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
53573 }
53574 arg2 = static_cast< int >(val2);
53575 {
53576 PyThreadState* __tstate = wxPyBeginAllowThreads();
53577 (arg1)->SetVGap(arg2);
53578 wxPyEndAllowThreads(__tstate);
53579 if (PyErr_Occurred()) SWIG_fail;
53580 }
53581 resultobj = SWIG_Py_Void();
53582 return resultobj;
53583 fail:
53584 return NULL;
53585 }
53586
53587
53588 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53589 PyObject *resultobj = 0;
53590 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53591 int arg2 ;
53592 void *argp1 = 0 ;
53593 int res1 = 0 ;
53594 int val2 ;
53595 int ecode2 = 0 ;
53596 PyObject * obj0 = 0 ;
53597 PyObject * obj1 = 0 ;
53598 char * kwnames[] = {
53599 (char *) "self",(char *) "gap", NULL
53600 };
53601
53602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
53603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53604 if (!SWIG_IsOK(res1)) {
53605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53606 }
53607 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53608 ecode2 = SWIG_AsVal_int(obj1, &val2);
53609 if (!SWIG_IsOK(ecode2)) {
53610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
53611 }
53612 arg2 = static_cast< int >(val2);
53613 {
53614 PyThreadState* __tstate = wxPyBeginAllowThreads();
53615 (arg1)->SetHGap(arg2);
53616 wxPyEndAllowThreads(__tstate);
53617 if (PyErr_Occurred()) SWIG_fail;
53618 }
53619 resultobj = SWIG_Py_Void();
53620 return resultobj;
53621 fail:
53622 return NULL;
53623 }
53624
53625
53626 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53627 PyObject *resultobj = 0;
53628 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53629 int result;
53630 void *argp1 = 0 ;
53631 int res1 = 0 ;
53632 PyObject *swig_obj[1] ;
53633
53634 if (!args) SWIG_fail;
53635 swig_obj[0] = args;
53636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53637 if (!SWIG_IsOK(res1)) {
53638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53639 }
53640 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53641 {
53642 PyThreadState* __tstate = wxPyBeginAllowThreads();
53643 result = (int)(arg1)->GetCols();
53644 wxPyEndAllowThreads(__tstate);
53645 if (PyErr_Occurred()) SWIG_fail;
53646 }
53647 resultobj = SWIG_From_int(static_cast< int >(result));
53648 return resultobj;
53649 fail:
53650 return NULL;
53651 }
53652
53653
53654 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53655 PyObject *resultobj = 0;
53656 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53657 int result;
53658 void *argp1 = 0 ;
53659 int res1 = 0 ;
53660 PyObject *swig_obj[1] ;
53661
53662 if (!args) SWIG_fail;
53663 swig_obj[0] = args;
53664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53665 if (!SWIG_IsOK(res1)) {
53666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53667 }
53668 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53669 {
53670 PyThreadState* __tstate = wxPyBeginAllowThreads();
53671 result = (int)(arg1)->GetRows();
53672 wxPyEndAllowThreads(__tstate);
53673 if (PyErr_Occurred()) SWIG_fail;
53674 }
53675 resultobj = SWIG_From_int(static_cast< int >(result));
53676 return resultobj;
53677 fail:
53678 return NULL;
53679 }
53680
53681
53682 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53683 PyObject *resultobj = 0;
53684 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53685 int result;
53686 void *argp1 = 0 ;
53687 int res1 = 0 ;
53688 PyObject *swig_obj[1] ;
53689
53690 if (!args) SWIG_fail;
53691 swig_obj[0] = args;
53692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53693 if (!SWIG_IsOK(res1)) {
53694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53695 }
53696 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53697 {
53698 PyThreadState* __tstate = wxPyBeginAllowThreads();
53699 result = (int)(arg1)->GetVGap();
53700 wxPyEndAllowThreads(__tstate);
53701 if (PyErr_Occurred()) SWIG_fail;
53702 }
53703 resultobj = SWIG_From_int(static_cast< int >(result));
53704 return resultobj;
53705 fail:
53706 return NULL;
53707 }
53708
53709
53710 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53711 PyObject *resultobj = 0;
53712 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53713 int result;
53714 void *argp1 = 0 ;
53715 int res1 = 0 ;
53716 PyObject *swig_obj[1] ;
53717
53718 if (!args) SWIG_fail;
53719 swig_obj[0] = args;
53720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53721 if (!SWIG_IsOK(res1)) {
53722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53723 }
53724 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53725 {
53726 PyThreadState* __tstate = wxPyBeginAllowThreads();
53727 result = (int)(arg1)->GetHGap();
53728 wxPyEndAllowThreads(__tstate);
53729 if (PyErr_Occurred()) SWIG_fail;
53730 }
53731 resultobj = SWIG_From_int(static_cast< int >(result));
53732 return resultobj;
53733 fail:
53734 return NULL;
53735 }
53736
53737
53738 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53739 PyObject *obj;
53740 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53741 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
53742 return SWIG_Py_Void();
53743 }
53744
53745 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53746 return SWIG_Python_InitShadowInstance(args);
53747 }
53748
53749 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53750 PyObject *resultobj = 0;
53751 int arg1 = (int) 1 ;
53752 int arg2 = (int) 0 ;
53753 int arg3 = (int) 0 ;
53754 int arg4 = (int) 0 ;
53755 wxFlexGridSizer *result = 0 ;
53756 int val1 ;
53757 int ecode1 = 0 ;
53758 int val2 ;
53759 int ecode2 = 0 ;
53760 int val3 ;
53761 int ecode3 = 0 ;
53762 int val4 ;
53763 int ecode4 = 0 ;
53764 PyObject * obj0 = 0 ;
53765 PyObject * obj1 = 0 ;
53766 PyObject * obj2 = 0 ;
53767 PyObject * obj3 = 0 ;
53768 char * kwnames[] = {
53769 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
53770 };
53771
53772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53773 if (obj0) {
53774 ecode1 = SWIG_AsVal_int(obj0, &val1);
53775 if (!SWIG_IsOK(ecode1)) {
53776 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
53777 }
53778 arg1 = static_cast< int >(val1);
53779 }
53780 if (obj1) {
53781 ecode2 = SWIG_AsVal_int(obj1, &val2);
53782 if (!SWIG_IsOK(ecode2)) {
53783 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
53784 }
53785 arg2 = static_cast< int >(val2);
53786 }
53787 if (obj2) {
53788 ecode3 = SWIG_AsVal_int(obj2, &val3);
53789 if (!SWIG_IsOK(ecode3)) {
53790 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
53791 }
53792 arg3 = static_cast< int >(val3);
53793 }
53794 if (obj3) {
53795 ecode4 = SWIG_AsVal_int(obj3, &val4);
53796 if (!SWIG_IsOK(ecode4)) {
53797 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
53798 }
53799 arg4 = static_cast< int >(val4);
53800 }
53801 {
53802 PyThreadState* __tstate = wxPyBeginAllowThreads();
53803 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
53804 wxPyEndAllowThreads(__tstate);
53805 if (PyErr_Occurred()) SWIG_fail;
53806 }
53807 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
53808 return resultobj;
53809 fail:
53810 return NULL;
53811 }
53812
53813
53814 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53815 PyObject *resultobj = 0;
53816 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53817 size_t arg2 ;
53818 int arg3 = (int) 0 ;
53819 void *argp1 = 0 ;
53820 int res1 = 0 ;
53821 size_t val2 ;
53822 int ecode2 = 0 ;
53823 int val3 ;
53824 int ecode3 = 0 ;
53825 PyObject * obj0 = 0 ;
53826 PyObject * obj1 = 0 ;
53827 PyObject * obj2 = 0 ;
53828 char * kwnames[] = {
53829 (char *) "self",(char *) "idx",(char *) "proportion", NULL
53830 };
53831
53832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53834 if (!SWIG_IsOK(res1)) {
53835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53836 }
53837 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53838 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53839 if (!SWIG_IsOK(ecode2)) {
53840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
53841 }
53842 arg2 = static_cast< size_t >(val2);
53843 if (obj2) {
53844 ecode3 = SWIG_AsVal_int(obj2, &val3);
53845 if (!SWIG_IsOK(ecode3)) {
53846 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
53847 }
53848 arg3 = static_cast< int >(val3);
53849 }
53850 {
53851 PyThreadState* __tstate = wxPyBeginAllowThreads();
53852 (arg1)->AddGrowableRow(arg2,arg3);
53853 wxPyEndAllowThreads(__tstate);
53854 if (PyErr_Occurred()) SWIG_fail;
53855 }
53856 resultobj = SWIG_Py_Void();
53857 return resultobj;
53858 fail:
53859 return NULL;
53860 }
53861
53862
53863 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53864 PyObject *resultobj = 0;
53865 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53866 size_t arg2 ;
53867 void *argp1 = 0 ;
53868 int res1 = 0 ;
53869 size_t val2 ;
53870 int ecode2 = 0 ;
53871 PyObject * obj0 = 0 ;
53872 PyObject * obj1 = 0 ;
53873 char * kwnames[] = {
53874 (char *) "self",(char *) "idx", NULL
53875 };
53876
53877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
53878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53879 if (!SWIG_IsOK(res1)) {
53880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53881 }
53882 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53883 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53884 if (!SWIG_IsOK(ecode2)) {
53885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
53886 }
53887 arg2 = static_cast< size_t >(val2);
53888 {
53889 PyThreadState* __tstate = wxPyBeginAllowThreads();
53890 (arg1)->RemoveGrowableRow(arg2);
53891 wxPyEndAllowThreads(__tstate);
53892 if (PyErr_Occurred()) SWIG_fail;
53893 }
53894 resultobj = SWIG_Py_Void();
53895 return resultobj;
53896 fail:
53897 return NULL;
53898 }
53899
53900
53901 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53902 PyObject *resultobj = 0;
53903 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53904 size_t arg2 ;
53905 int arg3 = (int) 0 ;
53906 void *argp1 = 0 ;
53907 int res1 = 0 ;
53908 size_t val2 ;
53909 int ecode2 = 0 ;
53910 int val3 ;
53911 int ecode3 = 0 ;
53912 PyObject * obj0 = 0 ;
53913 PyObject * obj1 = 0 ;
53914 PyObject * obj2 = 0 ;
53915 char * kwnames[] = {
53916 (char *) "self",(char *) "idx",(char *) "proportion", NULL
53917 };
53918
53919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53921 if (!SWIG_IsOK(res1)) {
53922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53923 }
53924 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53925 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53926 if (!SWIG_IsOK(ecode2)) {
53927 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
53928 }
53929 arg2 = static_cast< size_t >(val2);
53930 if (obj2) {
53931 ecode3 = SWIG_AsVal_int(obj2, &val3);
53932 if (!SWIG_IsOK(ecode3)) {
53933 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
53934 }
53935 arg3 = static_cast< int >(val3);
53936 }
53937 {
53938 PyThreadState* __tstate = wxPyBeginAllowThreads();
53939 (arg1)->AddGrowableCol(arg2,arg3);
53940 wxPyEndAllowThreads(__tstate);
53941 if (PyErr_Occurred()) SWIG_fail;
53942 }
53943 resultobj = SWIG_Py_Void();
53944 return resultobj;
53945 fail:
53946 return NULL;
53947 }
53948
53949
53950 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53951 PyObject *resultobj = 0;
53952 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53953 size_t arg2 ;
53954 void *argp1 = 0 ;
53955 int res1 = 0 ;
53956 size_t val2 ;
53957 int ecode2 = 0 ;
53958 PyObject * obj0 = 0 ;
53959 PyObject * obj1 = 0 ;
53960 char * kwnames[] = {
53961 (char *) "self",(char *) "idx", NULL
53962 };
53963
53964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
53965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53966 if (!SWIG_IsOK(res1)) {
53967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53968 }
53969 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53970 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53971 if (!SWIG_IsOK(ecode2)) {
53972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
53973 }
53974 arg2 = static_cast< size_t >(val2);
53975 {
53976 PyThreadState* __tstate = wxPyBeginAllowThreads();
53977 (arg1)->RemoveGrowableCol(arg2);
53978 wxPyEndAllowThreads(__tstate);
53979 if (PyErr_Occurred()) SWIG_fail;
53980 }
53981 resultobj = SWIG_Py_Void();
53982 return resultobj;
53983 fail:
53984 return NULL;
53985 }
53986
53987
53988 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53989 PyObject *resultobj = 0;
53990 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53991 int arg2 ;
53992 void *argp1 = 0 ;
53993 int res1 = 0 ;
53994 int val2 ;
53995 int ecode2 = 0 ;
53996 PyObject * obj0 = 0 ;
53997 PyObject * obj1 = 0 ;
53998 char * kwnames[] = {
53999 (char *) "self",(char *) "direction", NULL
54000 };
54001
54002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
54003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
54004 if (!SWIG_IsOK(res1)) {
54005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
54006 }
54007 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
54008 ecode2 = SWIG_AsVal_int(obj1, &val2);
54009 if (!SWIG_IsOK(ecode2)) {
54010 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
54011 }
54012 arg2 = static_cast< int >(val2);
54013 {
54014 PyThreadState* __tstate = wxPyBeginAllowThreads();
54015 (arg1)->SetFlexibleDirection(arg2);
54016 wxPyEndAllowThreads(__tstate);
54017 if (PyErr_Occurred()) SWIG_fail;
54018 }
54019 resultobj = SWIG_Py_Void();
54020 return resultobj;
54021 fail:
54022 return NULL;
54023 }
54024
54025
54026 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54027 PyObject *resultobj = 0;
54028 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
54029 int result;
54030 void *argp1 = 0 ;
54031 int res1 = 0 ;
54032 PyObject *swig_obj[1] ;
54033
54034 if (!args) SWIG_fail;
54035 swig_obj[0] = args;
54036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
54037 if (!SWIG_IsOK(res1)) {
54038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
54039 }
54040 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
54041 {
54042 PyThreadState* __tstate = wxPyBeginAllowThreads();
54043 result = (int)(arg1)->GetFlexibleDirection();
54044 wxPyEndAllowThreads(__tstate);
54045 if (PyErr_Occurred()) SWIG_fail;
54046 }
54047 resultobj = SWIG_From_int(static_cast< int >(result));
54048 return resultobj;
54049 fail:
54050 return NULL;
54051 }
54052
54053
54054 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54055 PyObject *resultobj = 0;
54056 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
54057 wxFlexSizerGrowMode arg2 ;
54058 void *argp1 = 0 ;
54059 int res1 = 0 ;
54060 int val2 ;
54061 int ecode2 = 0 ;
54062 PyObject * obj0 = 0 ;
54063 PyObject * obj1 = 0 ;
54064 char * kwnames[] = {
54065 (char *) "self",(char *) "mode", NULL
54066 };
54067
54068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
54069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
54070 if (!SWIG_IsOK(res1)) {
54071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
54072 }
54073 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
54074 ecode2 = SWIG_AsVal_int(obj1, &val2);
54075 if (!SWIG_IsOK(ecode2)) {
54076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
54077 }
54078 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
54079 {
54080 PyThreadState* __tstate = wxPyBeginAllowThreads();
54081 (arg1)->SetNonFlexibleGrowMode(arg2);
54082 wxPyEndAllowThreads(__tstate);
54083 if (PyErr_Occurred()) SWIG_fail;
54084 }
54085 resultobj = SWIG_Py_Void();
54086 return resultobj;
54087 fail:
54088 return NULL;
54089 }
54090
54091
54092 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54093 PyObject *resultobj = 0;
54094 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
54095 wxFlexSizerGrowMode result;
54096 void *argp1 = 0 ;
54097 int res1 = 0 ;
54098 PyObject *swig_obj[1] ;
54099
54100 if (!args) SWIG_fail;
54101 swig_obj[0] = args;
54102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
54103 if (!SWIG_IsOK(res1)) {
54104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
54105 }
54106 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
54107 {
54108 PyThreadState* __tstate = wxPyBeginAllowThreads();
54109 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
54110 wxPyEndAllowThreads(__tstate);
54111 if (PyErr_Occurred()) SWIG_fail;
54112 }
54113 resultobj = SWIG_From_int(static_cast< int >(result));
54114 return resultobj;
54115 fail:
54116 return NULL;
54117 }
54118
54119
54120 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54121 PyObject *resultobj = 0;
54122 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
54123 wxArrayInt *result = 0 ;
54124 void *argp1 = 0 ;
54125 int res1 = 0 ;
54126 PyObject *swig_obj[1] ;
54127
54128 if (!args) SWIG_fail;
54129 swig_obj[0] = args;
54130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
54131 if (!SWIG_IsOK(res1)) {
54132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
54133 }
54134 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
54135 {
54136 PyThreadState* __tstate = wxPyBeginAllowThreads();
54137 {
54138 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
54139 result = (wxArrayInt *) &_result_ref;
54140 }
54141 wxPyEndAllowThreads(__tstate);
54142 if (PyErr_Occurred()) SWIG_fail;
54143 }
54144 {
54145 resultobj = wxArrayInt2PyList_helper(*result);
54146 }
54147 return resultobj;
54148 fail:
54149 return NULL;
54150 }
54151
54152
54153 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54154 PyObject *resultobj = 0;
54155 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
54156 wxArrayInt *result = 0 ;
54157 void *argp1 = 0 ;
54158 int res1 = 0 ;
54159 PyObject *swig_obj[1] ;
54160
54161 if (!args) SWIG_fail;
54162 swig_obj[0] = args;
54163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
54164 if (!SWIG_IsOK(res1)) {
54165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
54166 }
54167 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
54168 {
54169 PyThreadState* __tstate = wxPyBeginAllowThreads();
54170 {
54171 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
54172 result = (wxArrayInt *) &_result_ref;
54173 }
54174 wxPyEndAllowThreads(__tstate);
54175 if (PyErr_Occurred()) SWIG_fail;
54176 }
54177 {
54178 resultobj = wxArrayInt2PyList_helper(*result);
54179 }
54180 return resultobj;
54181 fail:
54182 return NULL;
54183 }
54184
54185
54186 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54187 PyObject *obj;
54188 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54189 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
54190 return SWIG_Py_Void();
54191 }
54192
54193 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54194 return SWIG_Python_InitShadowInstance(args);
54195 }
54196
54197 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54198 PyObject *resultobj = 0;
54199 wxStdDialogButtonSizer *result = 0 ;
54200
54201 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
54202 {
54203 PyThreadState* __tstate = wxPyBeginAllowThreads();
54204 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
54205 wxPyEndAllowThreads(__tstate);
54206 if (PyErr_Occurred()) SWIG_fail;
54207 }
54208 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
54209 return resultobj;
54210 fail:
54211 return NULL;
54212 }
54213
54214
54215 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54216 PyObject *resultobj = 0;
54217 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54218 wxButton *arg2 = (wxButton *) 0 ;
54219 void *argp1 = 0 ;
54220 int res1 = 0 ;
54221 void *argp2 = 0 ;
54222 int res2 = 0 ;
54223 PyObject * obj0 = 0 ;
54224 PyObject * obj1 = 0 ;
54225 char * kwnames[] = {
54226 (char *) "self",(char *) "button", NULL
54227 };
54228
54229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
54230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54231 if (!SWIG_IsOK(res1)) {
54232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
54233 }
54234 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54235 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
54236 if (!SWIG_IsOK(res2)) {
54237 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
54238 }
54239 arg2 = reinterpret_cast< wxButton * >(argp2);
54240 {
54241 PyThreadState* __tstate = wxPyBeginAllowThreads();
54242 (arg1)->AddButton(arg2);
54243 wxPyEndAllowThreads(__tstate);
54244 if (PyErr_Occurred()) SWIG_fail;
54245 }
54246 resultobj = SWIG_Py_Void();
54247 return resultobj;
54248 fail:
54249 return NULL;
54250 }
54251
54252
54253 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54254 PyObject *resultobj = 0;
54255 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54256 void *argp1 = 0 ;
54257 int res1 = 0 ;
54258 PyObject *swig_obj[1] ;
54259
54260 if (!args) SWIG_fail;
54261 swig_obj[0] = args;
54262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54263 if (!SWIG_IsOK(res1)) {
54264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
54265 }
54266 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54267 {
54268 PyThreadState* __tstate = wxPyBeginAllowThreads();
54269 (arg1)->Realize();
54270 wxPyEndAllowThreads(__tstate);
54271 if (PyErr_Occurred()) SWIG_fail;
54272 }
54273 resultobj = SWIG_Py_Void();
54274 return resultobj;
54275 fail:
54276 return NULL;
54277 }
54278
54279
54280 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54281 PyObject *resultobj = 0;
54282 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54283 wxButton *arg2 = (wxButton *) 0 ;
54284 void *argp1 = 0 ;
54285 int res1 = 0 ;
54286 void *argp2 = 0 ;
54287 int res2 = 0 ;
54288 PyObject * obj0 = 0 ;
54289 PyObject * obj1 = 0 ;
54290 char * kwnames[] = {
54291 (char *) "self",(char *) "button", NULL
54292 };
54293
54294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
54295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54296 if (!SWIG_IsOK(res1)) {
54297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
54298 }
54299 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54300 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
54301 if (!SWIG_IsOK(res2)) {
54302 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
54303 }
54304 arg2 = reinterpret_cast< wxButton * >(argp2);
54305 {
54306 PyThreadState* __tstate = wxPyBeginAllowThreads();
54307 (arg1)->SetAffirmativeButton(arg2);
54308 wxPyEndAllowThreads(__tstate);
54309 if (PyErr_Occurred()) SWIG_fail;
54310 }
54311 resultobj = SWIG_Py_Void();
54312 return resultobj;
54313 fail:
54314 return NULL;
54315 }
54316
54317
54318 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54319 PyObject *resultobj = 0;
54320 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54321 wxButton *arg2 = (wxButton *) 0 ;
54322 void *argp1 = 0 ;
54323 int res1 = 0 ;
54324 void *argp2 = 0 ;
54325 int res2 = 0 ;
54326 PyObject * obj0 = 0 ;
54327 PyObject * obj1 = 0 ;
54328 char * kwnames[] = {
54329 (char *) "self",(char *) "button", NULL
54330 };
54331
54332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
54333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54334 if (!SWIG_IsOK(res1)) {
54335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
54336 }
54337 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54338 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
54339 if (!SWIG_IsOK(res2)) {
54340 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
54341 }
54342 arg2 = reinterpret_cast< wxButton * >(argp2);
54343 {
54344 PyThreadState* __tstate = wxPyBeginAllowThreads();
54345 (arg1)->SetNegativeButton(arg2);
54346 wxPyEndAllowThreads(__tstate);
54347 if (PyErr_Occurred()) SWIG_fail;
54348 }
54349 resultobj = SWIG_Py_Void();
54350 return resultobj;
54351 fail:
54352 return NULL;
54353 }
54354
54355
54356 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54357 PyObject *resultobj = 0;
54358 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54359 wxButton *arg2 = (wxButton *) 0 ;
54360 void *argp1 = 0 ;
54361 int res1 = 0 ;
54362 void *argp2 = 0 ;
54363 int res2 = 0 ;
54364 PyObject * obj0 = 0 ;
54365 PyObject * obj1 = 0 ;
54366 char * kwnames[] = {
54367 (char *) "self",(char *) "button", NULL
54368 };
54369
54370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
54371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54372 if (!SWIG_IsOK(res1)) {
54373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
54374 }
54375 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54376 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
54377 if (!SWIG_IsOK(res2)) {
54378 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
54379 }
54380 arg2 = reinterpret_cast< wxButton * >(argp2);
54381 {
54382 PyThreadState* __tstate = wxPyBeginAllowThreads();
54383 (arg1)->SetCancelButton(arg2);
54384 wxPyEndAllowThreads(__tstate);
54385 if (PyErr_Occurred()) SWIG_fail;
54386 }
54387 resultobj = SWIG_Py_Void();
54388 return resultobj;
54389 fail:
54390 return NULL;
54391 }
54392
54393
54394 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54395 PyObject *resultobj = 0;
54396 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54397 wxButton *result = 0 ;
54398 void *argp1 = 0 ;
54399 int res1 = 0 ;
54400 PyObject *swig_obj[1] ;
54401
54402 if (!args) SWIG_fail;
54403 swig_obj[0] = args;
54404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54405 if (!SWIG_IsOK(res1)) {
54406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
54407 }
54408 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54409 {
54410 PyThreadState* __tstate = wxPyBeginAllowThreads();
54411 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
54412 wxPyEndAllowThreads(__tstate);
54413 if (PyErr_Occurred()) SWIG_fail;
54414 }
54415 {
54416 resultobj = wxPyMake_wxObject(result, (bool)0);
54417 }
54418 return resultobj;
54419 fail:
54420 return NULL;
54421 }
54422
54423
54424 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54425 PyObject *resultobj = 0;
54426 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54427 wxButton *result = 0 ;
54428 void *argp1 = 0 ;
54429 int res1 = 0 ;
54430 PyObject *swig_obj[1] ;
54431
54432 if (!args) SWIG_fail;
54433 swig_obj[0] = args;
54434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54435 if (!SWIG_IsOK(res1)) {
54436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
54437 }
54438 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54439 {
54440 PyThreadState* __tstate = wxPyBeginAllowThreads();
54441 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
54442 wxPyEndAllowThreads(__tstate);
54443 if (PyErr_Occurred()) SWIG_fail;
54444 }
54445 {
54446 resultobj = wxPyMake_wxObject(result, (bool)0);
54447 }
54448 return resultobj;
54449 fail:
54450 return NULL;
54451 }
54452
54453
54454 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54455 PyObject *resultobj = 0;
54456 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54457 wxButton *result = 0 ;
54458 void *argp1 = 0 ;
54459 int res1 = 0 ;
54460 PyObject *swig_obj[1] ;
54461
54462 if (!args) SWIG_fail;
54463 swig_obj[0] = args;
54464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54465 if (!SWIG_IsOK(res1)) {
54466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
54467 }
54468 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54469 {
54470 PyThreadState* __tstate = wxPyBeginAllowThreads();
54471 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
54472 wxPyEndAllowThreads(__tstate);
54473 if (PyErr_Occurred()) SWIG_fail;
54474 }
54475 {
54476 resultobj = wxPyMake_wxObject(result, (bool)0);
54477 }
54478 return resultobj;
54479 fail:
54480 return NULL;
54481 }
54482
54483
54484 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54485 PyObject *resultobj = 0;
54486 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54487 wxButton *result = 0 ;
54488 void *argp1 = 0 ;
54489 int res1 = 0 ;
54490 PyObject *swig_obj[1] ;
54491
54492 if (!args) SWIG_fail;
54493 swig_obj[0] = args;
54494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54495 if (!SWIG_IsOK(res1)) {
54496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
54497 }
54498 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54499 {
54500 PyThreadState* __tstate = wxPyBeginAllowThreads();
54501 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
54502 wxPyEndAllowThreads(__tstate);
54503 if (PyErr_Occurred()) SWIG_fail;
54504 }
54505 {
54506 resultobj = wxPyMake_wxObject(result, (bool)0);
54507 }
54508 return resultobj;
54509 fail:
54510 return NULL;
54511 }
54512
54513
54514 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54515 PyObject *resultobj = 0;
54516 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54517 wxButton *result = 0 ;
54518 void *argp1 = 0 ;
54519 int res1 = 0 ;
54520 PyObject *swig_obj[1] ;
54521
54522 if (!args) SWIG_fail;
54523 swig_obj[0] = args;
54524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54525 if (!SWIG_IsOK(res1)) {
54526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
54527 }
54528 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54529 {
54530 PyThreadState* __tstate = wxPyBeginAllowThreads();
54531 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
54532 wxPyEndAllowThreads(__tstate);
54533 if (PyErr_Occurred()) SWIG_fail;
54534 }
54535 {
54536 resultobj = wxPyMake_wxObject(result, (bool)0);
54537 }
54538 return resultobj;
54539 fail:
54540 return NULL;
54541 }
54542
54543
54544 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54545 PyObject *obj;
54546 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54547 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
54548 return SWIG_Py_Void();
54549 }
54550
54551 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54552 return SWIG_Python_InitShadowInstance(args);
54553 }
54554
54555 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54556 PyObject *resultobj = 0;
54557 int arg1 = (int) 0 ;
54558 int arg2 = (int) 0 ;
54559 wxGBPosition *result = 0 ;
54560 int val1 ;
54561 int ecode1 = 0 ;
54562 int val2 ;
54563 int ecode2 = 0 ;
54564 PyObject * obj0 = 0 ;
54565 PyObject * obj1 = 0 ;
54566 char * kwnames[] = {
54567 (char *) "row",(char *) "col", NULL
54568 };
54569
54570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
54571 if (obj0) {
54572 ecode1 = SWIG_AsVal_int(obj0, &val1);
54573 if (!SWIG_IsOK(ecode1)) {
54574 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
54575 }
54576 arg1 = static_cast< int >(val1);
54577 }
54578 if (obj1) {
54579 ecode2 = SWIG_AsVal_int(obj1, &val2);
54580 if (!SWIG_IsOK(ecode2)) {
54581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
54582 }
54583 arg2 = static_cast< int >(val2);
54584 }
54585 {
54586 PyThreadState* __tstate = wxPyBeginAllowThreads();
54587 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
54588 wxPyEndAllowThreads(__tstate);
54589 if (PyErr_Occurred()) SWIG_fail;
54590 }
54591 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
54592 return resultobj;
54593 fail:
54594 return NULL;
54595 }
54596
54597
54598 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54599 PyObject *resultobj = 0;
54600 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54601 void *argp1 = 0 ;
54602 int res1 = 0 ;
54603 PyObject *swig_obj[1] ;
54604
54605 if (!args) SWIG_fail;
54606 swig_obj[0] = args;
54607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
54608 if (!SWIG_IsOK(res1)) {
54609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54610 }
54611 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54612 {
54613 PyThreadState* __tstate = wxPyBeginAllowThreads();
54614 delete arg1;
54615
54616 wxPyEndAllowThreads(__tstate);
54617 if (PyErr_Occurred()) SWIG_fail;
54618 }
54619 resultobj = SWIG_Py_Void();
54620 return resultobj;
54621 fail:
54622 return NULL;
54623 }
54624
54625
54626 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54627 PyObject *resultobj = 0;
54628 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54629 int result;
54630 void *argp1 = 0 ;
54631 int res1 = 0 ;
54632 PyObject *swig_obj[1] ;
54633
54634 if (!args) SWIG_fail;
54635 swig_obj[0] = args;
54636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54637 if (!SWIG_IsOK(res1)) {
54638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
54639 }
54640 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54641 {
54642 PyThreadState* __tstate = wxPyBeginAllowThreads();
54643 result = (int)((wxGBPosition const *)arg1)->GetRow();
54644 wxPyEndAllowThreads(__tstate);
54645 if (PyErr_Occurred()) SWIG_fail;
54646 }
54647 resultobj = SWIG_From_int(static_cast< int >(result));
54648 return resultobj;
54649 fail:
54650 return NULL;
54651 }
54652
54653
54654 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54655 PyObject *resultobj = 0;
54656 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54657 int result;
54658 void *argp1 = 0 ;
54659 int res1 = 0 ;
54660 PyObject *swig_obj[1] ;
54661
54662 if (!args) SWIG_fail;
54663 swig_obj[0] = args;
54664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54665 if (!SWIG_IsOK(res1)) {
54666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
54667 }
54668 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54669 {
54670 PyThreadState* __tstate = wxPyBeginAllowThreads();
54671 result = (int)((wxGBPosition const *)arg1)->GetCol();
54672 wxPyEndAllowThreads(__tstate);
54673 if (PyErr_Occurred()) SWIG_fail;
54674 }
54675 resultobj = SWIG_From_int(static_cast< int >(result));
54676 return resultobj;
54677 fail:
54678 return NULL;
54679 }
54680
54681
54682 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54683 PyObject *resultobj = 0;
54684 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54685 int arg2 ;
54686 void *argp1 = 0 ;
54687 int res1 = 0 ;
54688 int val2 ;
54689 int ecode2 = 0 ;
54690 PyObject * obj0 = 0 ;
54691 PyObject * obj1 = 0 ;
54692 char * kwnames[] = {
54693 (char *) "self",(char *) "row", NULL
54694 };
54695
54696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
54697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54698 if (!SWIG_IsOK(res1)) {
54699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54700 }
54701 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54702 ecode2 = SWIG_AsVal_int(obj1, &val2);
54703 if (!SWIG_IsOK(ecode2)) {
54704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
54705 }
54706 arg2 = static_cast< int >(val2);
54707 {
54708 PyThreadState* __tstate = wxPyBeginAllowThreads();
54709 (arg1)->SetRow(arg2);
54710 wxPyEndAllowThreads(__tstate);
54711 if (PyErr_Occurred()) SWIG_fail;
54712 }
54713 resultobj = SWIG_Py_Void();
54714 return resultobj;
54715 fail:
54716 return NULL;
54717 }
54718
54719
54720 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54721 PyObject *resultobj = 0;
54722 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54723 int arg2 ;
54724 void *argp1 = 0 ;
54725 int res1 = 0 ;
54726 int val2 ;
54727 int ecode2 = 0 ;
54728 PyObject * obj0 = 0 ;
54729 PyObject * obj1 = 0 ;
54730 char * kwnames[] = {
54731 (char *) "self",(char *) "col", NULL
54732 };
54733
54734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
54735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54736 if (!SWIG_IsOK(res1)) {
54737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54738 }
54739 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54740 ecode2 = SWIG_AsVal_int(obj1, &val2);
54741 if (!SWIG_IsOK(ecode2)) {
54742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
54743 }
54744 arg2 = static_cast< int >(val2);
54745 {
54746 PyThreadState* __tstate = wxPyBeginAllowThreads();
54747 (arg1)->SetCol(arg2);
54748 wxPyEndAllowThreads(__tstate);
54749 if (PyErr_Occurred()) SWIG_fail;
54750 }
54751 resultobj = SWIG_Py_Void();
54752 return resultobj;
54753 fail:
54754 return NULL;
54755 }
54756
54757
54758 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54759 PyObject *resultobj = 0;
54760 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54761 PyObject *arg2 = (PyObject *) 0 ;
54762 bool result;
54763 void *argp1 = 0 ;
54764 int res1 = 0 ;
54765 PyObject * obj0 = 0 ;
54766 PyObject * obj1 = 0 ;
54767 char * kwnames[] = {
54768 (char *) "self",(char *) "other", NULL
54769 };
54770
54771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
54772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54773 if (!SWIG_IsOK(res1)) {
54774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54775 }
54776 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54777 arg2 = obj1;
54778 {
54779 result = (bool)wxGBPosition___eq__(arg1,arg2);
54780 if (PyErr_Occurred()) SWIG_fail;
54781 }
54782 {
54783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54784 }
54785 return resultobj;
54786 fail:
54787 return NULL;
54788 }
54789
54790
54791 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54792 PyObject *resultobj = 0;
54793 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54794 PyObject *arg2 = (PyObject *) 0 ;
54795 bool result;
54796 void *argp1 = 0 ;
54797 int res1 = 0 ;
54798 PyObject * obj0 = 0 ;
54799 PyObject * obj1 = 0 ;
54800 char * kwnames[] = {
54801 (char *) "self",(char *) "other", NULL
54802 };
54803
54804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
54805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54806 if (!SWIG_IsOK(res1)) {
54807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54808 }
54809 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54810 arg2 = obj1;
54811 {
54812 result = (bool)wxGBPosition___ne__(arg1,arg2);
54813 if (PyErr_Occurred()) SWIG_fail;
54814 }
54815 {
54816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54817 }
54818 return resultobj;
54819 fail:
54820 return NULL;
54821 }
54822
54823
54824 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54825 PyObject *resultobj = 0;
54826 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54827 int arg2 = (int) 0 ;
54828 int arg3 = (int) 0 ;
54829 void *argp1 = 0 ;
54830 int res1 = 0 ;
54831 int val2 ;
54832 int ecode2 = 0 ;
54833 int val3 ;
54834 int ecode3 = 0 ;
54835 PyObject * obj0 = 0 ;
54836 PyObject * obj1 = 0 ;
54837 PyObject * obj2 = 0 ;
54838 char * kwnames[] = {
54839 (char *) "self",(char *) "row",(char *) "col", NULL
54840 };
54841
54842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54844 if (!SWIG_IsOK(res1)) {
54845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54846 }
54847 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54848 if (obj1) {
54849 ecode2 = SWIG_AsVal_int(obj1, &val2);
54850 if (!SWIG_IsOK(ecode2)) {
54851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
54852 }
54853 arg2 = static_cast< int >(val2);
54854 }
54855 if (obj2) {
54856 ecode3 = SWIG_AsVal_int(obj2, &val3);
54857 if (!SWIG_IsOK(ecode3)) {
54858 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
54859 }
54860 arg3 = static_cast< int >(val3);
54861 }
54862 {
54863 PyThreadState* __tstate = wxPyBeginAllowThreads();
54864 wxGBPosition_Set(arg1,arg2,arg3);
54865 wxPyEndAllowThreads(__tstate);
54866 if (PyErr_Occurred()) SWIG_fail;
54867 }
54868 resultobj = SWIG_Py_Void();
54869 return resultobj;
54870 fail:
54871 return NULL;
54872 }
54873
54874
54875 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54876 PyObject *resultobj = 0;
54877 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54878 PyObject *result = 0 ;
54879 void *argp1 = 0 ;
54880 int res1 = 0 ;
54881 PyObject *swig_obj[1] ;
54882
54883 if (!args) SWIG_fail;
54884 swig_obj[0] = args;
54885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54886 if (!SWIG_IsOK(res1)) {
54887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54888 }
54889 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54890 {
54891 PyThreadState* __tstate = wxPyBeginAllowThreads();
54892 result = (PyObject *)wxGBPosition_Get(arg1);
54893 wxPyEndAllowThreads(__tstate);
54894 if (PyErr_Occurred()) SWIG_fail;
54895 }
54896 resultobj = result;
54897 return resultobj;
54898 fail:
54899 return NULL;
54900 }
54901
54902
54903 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54904 PyObject *obj;
54905 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54906 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
54907 return SWIG_Py_Void();
54908 }
54909
54910 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54911 return SWIG_Python_InitShadowInstance(args);
54912 }
54913
54914 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54915 PyObject *resultobj = 0;
54916 int arg1 = (int) 1 ;
54917 int arg2 = (int) 1 ;
54918 wxGBSpan *result = 0 ;
54919 int val1 ;
54920 int ecode1 = 0 ;
54921 int val2 ;
54922 int ecode2 = 0 ;
54923 PyObject * obj0 = 0 ;
54924 PyObject * obj1 = 0 ;
54925 char * kwnames[] = {
54926 (char *) "rowspan",(char *) "colspan", NULL
54927 };
54928
54929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
54930 if (obj0) {
54931 ecode1 = SWIG_AsVal_int(obj0, &val1);
54932 if (!SWIG_IsOK(ecode1)) {
54933 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
54934 }
54935 arg1 = static_cast< int >(val1);
54936 }
54937 if (obj1) {
54938 ecode2 = SWIG_AsVal_int(obj1, &val2);
54939 if (!SWIG_IsOK(ecode2)) {
54940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
54941 }
54942 arg2 = static_cast< int >(val2);
54943 }
54944 {
54945 PyThreadState* __tstate = wxPyBeginAllowThreads();
54946 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
54947 wxPyEndAllowThreads(__tstate);
54948 if (PyErr_Occurred()) SWIG_fail;
54949 }
54950 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
54951 return resultobj;
54952 fail:
54953 return NULL;
54954 }
54955
54956
54957 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54958 PyObject *resultobj = 0;
54959 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54960 void *argp1 = 0 ;
54961 int res1 = 0 ;
54962 PyObject *swig_obj[1] ;
54963
54964 if (!args) SWIG_fail;
54965 swig_obj[0] = args;
54966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
54967 if (!SWIG_IsOK(res1)) {
54968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54969 }
54970 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54971 {
54972 PyThreadState* __tstate = wxPyBeginAllowThreads();
54973 delete arg1;
54974
54975 wxPyEndAllowThreads(__tstate);
54976 if (PyErr_Occurred()) SWIG_fail;
54977 }
54978 resultobj = SWIG_Py_Void();
54979 return resultobj;
54980 fail:
54981 return NULL;
54982 }
54983
54984
54985 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54986 PyObject *resultobj = 0;
54987 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54988 int result;
54989 void *argp1 = 0 ;
54990 int res1 = 0 ;
54991 PyObject *swig_obj[1] ;
54992
54993 if (!args) SWIG_fail;
54994 swig_obj[0] = args;
54995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54996 if (!SWIG_IsOK(res1)) {
54997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
54998 }
54999 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
55000 {
55001 PyThreadState* __tstate = wxPyBeginAllowThreads();
55002 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
55003 wxPyEndAllowThreads(__tstate);
55004 if (PyErr_Occurred()) SWIG_fail;
55005 }
55006 resultobj = SWIG_From_int(static_cast< int >(result));
55007 return resultobj;
55008 fail:
55009 return NULL;
55010 }
55011
55012
55013 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55014 PyObject *resultobj = 0;
55015 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
55016 int result;
55017 void *argp1 = 0 ;
55018 int res1 = 0 ;
55019 PyObject *swig_obj[1] ;
55020
55021 if (!args) SWIG_fail;
55022 swig_obj[0] = args;
55023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
55024 if (!SWIG_IsOK(res1)) {
55025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
55026 }
55027 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
55028 {
55029 PyThreadState* __tstate = wxPyBeginAllowThreads();
55030 result = (int)((wxGBSpan const *)arg1)->GetColspan();
55031 wxPyEndAllowThreads(__tstate);
55032 if (PyErr_Occurred()) SWIG_fail;
55033 }
55034 resultobj = SWIG_From_int(static_cast< int >(result));
55035 return resultobj;
55036 fail:
55037 return NULL;
55038 }
55039
55040
55041 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55042 PyObject *resultobj = 0;
55043 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
55044 int arg2 ;
55045 void *argp1 = 0 ;
55046 int res1 = 0 ;
55047 int val2 ;
55048 int ecode2 = 0 ;
55049 PyObject * obj0 = 0 ;
55050 PyObject * obj1 = 0 ;
55051 char * kwnames[] = {
55052 (char *) "self",(char *) "rowspan", NULL
55053 };
55054
55055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
55056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
55057 if (!SWIG_IsOK(res1)) {
55058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
55059 }
55060 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
55061 ecode2 = SWIG_AsVal_int(obj1, &val2);
55062 if (!SWIG_IsOK(ecode2)) {
55063 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
55064 }
55065 arg2 = static_cast< int >(val2);
55066 {
55067 PyThreadState* __tstate = wxPyBeginAllowThreads();
55068 (arg1)->SetRowspan(arg2);
55069 wxPyEndAllowThreads(__tstate);
55070 if (PyErr_Occurred()) SWIG_fail;
55071 }
55072 resultobj = SWIG_Py_Void();
55073 return resultobj;
55074 fail:
55075 return NULL;
55076 }
55077
55078
55079 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55080 PyObject *resultobj = 0;
55081 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
55082 int arg2 ;
55083 void *argp1 = 0 ;
55084 int res1 = 0 ;
55085 int val2 ;
55086 int ecode2 = 0 ;
55087 PyObject * obj0 = 0 ;
55088 PyObject * obj1 = 0 ;
55089 char * kwnames[] = {
55090 (char *) "self",(char *) "colspan", NULL
55091 };
55092
55093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
55094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
55095 if (!SWIG_IsOK(res1)) {
55096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
55097 }
55098 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
55099 ecode2 = SWIG_AsVal_int(obj1, &val2);
55100 if (!SWIG_IsOK(ecode2)) {
55101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
55102 }
55103 arg2 = static_cast< int >(val2);
55104 {
55105 PyThreadState* __tstate = wxPyBeginAllowThreads();
55106 (arg1)->SetColspan(arg2);
55107 wxPyEndAllowThreads(__tstate);
55108 if (PyErr_Occurred()) SWIG_fail;
55109 }
55110 resultobj = SWIG_Py_Void();
55111 return resultobj;
55112 fail:
55113 return NULL;
55114 }
55115
55116
55117 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55118 PyObject *resultobj = 0;
55119 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
55120 PyObject *arg2 = (PyObject *) 0 ;
55121 bool result;
55122 void *argp1 = 0 ;
55123 int res1 = 0 ;
55124 PyObject * obj0 = 0 ;
55125 PyObject * obj1 = 0 ;
55126 char * kwnames[] = {
55127 (char *) "self",(char *) "other", NULL
55128 };
55129
55130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
55131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
55132 if (!SWIG_IsOK(res1)) {
55133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
55134 }
55135 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
55136 arg2 = obj1;
55137 {
55138 result = (bool)wxGBSpan___eq__(arg1,arg2);
55139 if (PyErr_Occurred()) SWIG_fail;
55140 }
55141 {
55142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55143 }
55144 return resultobj;
55145 fail:
55146 return NULL;
55147 }
55148
55149
55150 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55151 PyObject *resultobj = 0;
55152 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
55153 PyObject *arg2 = (PyObject *) 0 ;
55154 bool result;
55155 void *argp1 = 0 ;
55156 int res1 = 0 ;
55157 PyObject * obj0 = 0 ;
55158 PyObject * obj1 = 0 ;
55159 char * kwnames[] = {
55160 (char *) "self",(char *) "other", NULL
55161 };
55162
55163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
55164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
55165 if (!SWIG_IsOK(res1)) {
55166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
55167 }
55168 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
55169 arg2 = obj1;
55170 {
55171 result = (bool)wxGBSpan___ne__(arg1,arg2);
55172 if (PyErr_Occurred()) SWIG_fail;
55173 }
55174 {
55175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55176 }
55177 return resultobj;
55178 fail:
55179 return NULL;
55180 }
55181
55182
55183 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55184 PyObject *resultobj = 0;
55185 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
55186 int arg2 = (int) 1 ;
55187 int arg3 = (int) 1 ;
55188 void *argp1 = 0 ;
55189 int res1 = 0 ;
55190 int val2 ;
55191 int ecode2 = 0 ;
55192 int val3 ;
55193 int ecode3 = 0 ;
55194 PyObject * obj0 = 0 ;
55195 PyObject * obj1 = 0 ;
55196 PyObject * obj2 = 0 ;
55197 char * kwnames[] = {
55198 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
55199 };
55200
55201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
55203 if (!SWIG_IsOK(res1)) {
55204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
55205 }
55206 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
55207 if (obj1) {
55208 ecode2 = SWIG_AsVal_int(obj1, &val2);
55209 if (!SWIG_IsOK(ecode2)) {
55210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
55211 }
55212 arg2 = static_cast< int >(val2);
55213 }
55214 if (obj2) {
55215 ecode3 = SWIG_AsVal_int(obj2, &val3);
55216 if (!SWIG_IsOK(ecode3)) {
55217 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
55218 }
55219 arg3 = static_cast< int >(val3);
55220 }
55221 {
55222 PyThreadState* __tstate = wxPyBeginAllowThreads();
55223 wxGBSpan_Set(arg1,arg2,arg3);
55224 wxPyEndAllowThreads(__tstate);
55225 if (PyErr_Occurred()) SWIG_fail;
55226 }
55227 resultobj = SWIG_Py_Void();
55228 return resultobj;
55229 fail:
55230 return NULL;
55231 }
55232
55233
55234 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55235 PyObject *resultobj = 0;
55236 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
55237 PyObject *result = 0 ;
55238 void *argp1 = 0 ;
55239 int res1 = 0 ;
55240 PyObject *swig_obj[1] ;
55241
55242 if (!args) SWIG_fail;
55243 swig_obj[0] = args;
55244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
55245 if (!SWIG_IsOK(res1)) {
55246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
55247 }
55248 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
55249 {
55250 PyThreadState* __tstate = wxPyBeginAllowThreads();
55251 result = (PyObject *)wxGBSpan_Get(arg1);
55252 wxPyEndAllowThreads(__tstate);
55253 if (PyErr_Occurred()) SWIG_fail;
55254 }
55255 resultobj = result;
55256 return resultobj;
55257 fail:
55258 return NULL;
55259 }
55260
55261
55262 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55263 PyObject *obj;
55264 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
55265 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
55266 return SWIG_Py_Void();
55267 }
55268
55269 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55270 return SWIG_Python_InitShadowInstance(args);
55271 }
55272
55273 SWIGINTERN int DefaultSpan_set(PyObject *) {
55274 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
55275 return 1;
55276 }
55277
55278
55279 SWIGINTERN PyObject *DefaultSpan_get(void) {
55280 PyObject *pyobj = 0;
55281
55282 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
55283 return pyobj;
55284 }
55285
55286
55287 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55288 PyObject *resultobj = 0;
55289 wxGBSizerItem *result = 0 ;
55290
55291 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
55292 {
55293 PyThreadState* __tstate = wxPyBeginAllowThreads();
55294 result = (wxGBSizerItem *)new wxGBSizerItem();
55295 wxPyEndAllowThreads(__tstate);
55296 if (PyErr_Occurred()) SWIG_fail;
55297 }
55298 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
55299 return resultobj;
55300 fail:
55301 return NULL;
55302 }
55303
55304
55305 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55306 PyObject *resultobj = 0;
55307 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55308 void *argp1 = 0 ;
55309 int res1 = 0 ;
55310 PyObject *swig_obj[1] ;
55311
55312 if (!args) SWIG_fail;
55313 swig_obj[0] = args;
55314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
55315 if (!SWIG_IsOK(res1)) {
55316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55317 }
55318 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55319 {
55320 PyThreadState* __tstate = wxPyBeginAllowThreads();
55321 delete arg1;
55322
55323 wxPyEndAllowThreads(__tstate);
55324 if (PyErr_Occurred()) SWIG_fail;
55325 }
55326 resultobj = SWIG_Py_Void();
55327 return resultobj;
55328 fail:
55329 return NULL;
55330 }
55331
55332
55333 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55334 PyObject *resultobj = 0;
55335 wxWindow *arg1 = (wxWindow *) 0 ;
55336 wxGBPosition *arg2 = 0 ;
55337 wxGBSpan *arg3 = 0 ;
55338 int arg4 ;
55339 int arg5 ;
55340 PyObject *arg6 = (PyObject *) NULL ;
55341 wxGBSizerItem *result = 0 ;
55342 void *argp1 = 0 ;
55343 int res1 = 0 ;
55344 wxGBPosition temp2 ;
55345 wxGBSpan temp3 ;
55346 int val4 ;
55347 int ecode4 = 0 ;
55348 int val5 ;
55349 int ecode5 = 0 ;
55350 PyObject * obj0 = 0 ;
55351 PyObject * obj1 = 0 ;
55352 PyObject * obj2 = 0 ;
55353 PyObject * obj3 = 0 ;
55354 PyObject * obj4 = 0 ;
55355 PyObject * obj5 = 0 ;
55356 char * kwnames[] = {
55357 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
55358 };
55359
55360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
55361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
55362 if (!SWIG_IsOK(res1)) {
55363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
55364 }
55365 arg1 = reinterpret_cast< wxWindow * >(argp1);
55366 {
55367 arg2 = &temp2;
55368 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55369 }
55370 {
55371 arg3 = &temp3;
55372 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
55373 }
55374 ecode4 = SWIG_AsVal_int(obj3, &val4);
55375 if (!SWIG_IsOK(ecode4)) {
55376 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
55377 }
55378 arg4 = static_cast< int >(val4);
55379 ecode5 = SWIG_AsVal_int(obj4, &val5);
55380 if (!SWIG_IsOK(ecode5)) {
55381 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
55382 }
55383 arg5 = static_cast< int >(val5);
55384 if (obj5) {
55385 arg6 = obj5;
55386 }
55387 {
55388 PyThreadState* __tstate = wxPyBeginAllowThreads();
55389 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
55390 wxPyEndAllowThreads(__tstate);
55391 if (PyErr_Occurred()) SWIG_fail;
55392 }
55393 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
55394 return resultobj;
55395 fail:
55396 return NULL;
55397 }
55398
55399
55400 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55401 PyObject *resultobj = 0;
55402 wxSizer *arg1 = (wxSizer *) 0 ;
55403 wxGBPosition *arg2 = 0 ;
55404 wxGBSpan *arg3 = 0 ;
55405 int arg4 ;
55406 int arg5 ;
55407 PyObject *arg6 = (PyObject *) NULL ;
55408 wxGBSizerItem *result = 0 ;
55409 int res1 = 0 ;
55410 wxGBPosition temp2 ;
55411 wxGBSpan temp3 ;
55412 int val4 ;
55413 int ecode4 = 0 ;
55414 int val5 ;
55415 int ecode5 = 0 ;
55416 PyObject * obj0 = 0 ;
55417 PyObject * obj1 = 0 ;
55418 PyObject * obj2 = 0 ;
55419 PyObject * obj3 = 0 ;
55420 PyObject * obj4 = 0 ;
55421 PyObject * obj5 = 0 ;
55422 char * kwnames[] = {
55423 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
55424 };
55425
55426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
55427 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
55428 if (!SWIG_IsOK(res1)) {
55429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
55430 }
55431 {
55432 arg2 = &temp2;
55433 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55434 }
55435 {
55436 arg3 = &temp3;
55437 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
55438 }
55439 ecode4 = SWIG_AsVal_int(obj3, &val4);
55440 if (!SWIG_IsOK(ecode4)) {
55441 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
55442 }
55443 arg4 = static_cast< int >(val4);
55444 ecode5 = SWIG_AsVal_int(obj4, &val5);
55445 if (!SWIG_IsOK(ecode5)) {
55446 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
55447 }
55448 arg5 = static_cast< int >(val5);
55449 if (obj5) {
55450 arg6 = obj5;
55451 }
55452 {
55453 PyThreadState* __tstate = wxPyBeginAllowThreads();
55454 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
55455 wxPyEndAllowThreads(__tstate);
55456 if (PyErr_Occurred()) SWIG_fail;
55457 }
55458 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
55459 return resultobj;
55460 fail:
55461 return NULL;
55462 }
55463
55464
55465 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55466 PyObject *resultobj = 0;
55467 int arg1 ;
55468 int arg2 ;
55469 wxGBPosition *arg3 = 0 ;
55470 wxGBSpan *arg4 = 0 ;
55471 int arg5 ;
55472 int arg6 ;
55473 PyObject *arg7 = (PyObject *) NULL ;
55474 wxGBSizerItem *result = 0 ;
55475 int val1 ;
55476 int ecode1 = 0 ;
55477 int val2 ;
55478 int ecode2 = 0 ;
55479 wxGBPosition temp3 ;
55480 wxGBSpan temp4 ;
55481 int val5 ;
55482 int ecode5 = 0 ;
55483 int val6 ;
55484 int ecode6 = 0 ;
55485 PyObject * obj0 = 0 ;
55486 PyObject * obj1 = 0 ;
55487 PyObject * obj2 = 0 ;
55488 PyObject * obj3 = 0 ;
55489 PyObject * obj4 = 0 ;
55490 PyObject * obj5 = 0 ;
55491 PyObject * obj6 = 0 ;
55492 char * kwnames[] = {
55493 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
55494 };
55495
55496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
55497 ecode1 = SWIG_AsVal_int(obj0, &val1);
55498 if (!SWIG_IsOK(ecode1)) {
55499 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
55500 }
55501 arg1 = static_cast< int >(val1);
55502 ecode2 = SWIG_AsVal_int(obj1, &val2);
55503 if (!SWIG_IsOK(ecode2)) {
55504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
55505 }
55506 arg2 = static_cast< int >(val2);
55507 {
55508 arg3 = &temp3;
55509 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
55510 }
55511 {
55512 arg4 = &temp4;
55513 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
55514 }
55515 ecode5 = SWIG_AsVal_int(obj4, &val5);
55516 if (!SWIG_IsOK(ecode5)) {
55517 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
55518 }
55519 arg5 = static_cast< int >(val5);
55520 ecode6 = SWIG_AsVal_int(obj5, &val6);
55521 if (!SWIG_IsOK(ecode6)) {
55522 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
55523 }
55524 arg6 = static_cast< int >(val6);
55525 if (obj6) {
55526 arg7 = obj6;
55527 }
55528 {
55529 PyThreadState* __tstate = wxPyBeginAllowThreads();
55530 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
55531 wxPyEndAllowThreads(__tstate);
55532 if (PyErr_Occurred()) SWIG_fail;
55533 }
55534 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
55535 return resultobj;
55536 fail:
55537 return NULL;
55538 }
55539
55540
55541 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55542 PyObject *resultobj = 0;
55543 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55544 wxGBPosition result;
55545 void *argp1 = 0 ;
55546 int res1 = 0 ;
55547 PyObject *swig_obj[1] ;
55548
55549 if (!args) SWIG_fail;
55550 swig_obj[0] = args;
55551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55552 if (!SWIG_IsOK(res1)) {
55553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
55554 }
55555 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55556 {
55557 PyThreadState* __tstate = wxPyBeginAllowThreads();
55558 result = ((wxGBSizerItem const *)arg1)->GetPos();
55559 wxPyEndAllowThreads(__tstate);
55560 if (PyErr_Occurred()) SWIG_fail;
55561 }
55562 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
55563 return resultobj;
55564 fail:
55565 return NULL;
55566 }
55567
55568
55569 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55570 PyObject *resultobj = 0;
55571 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55572 wxGBSpan result;
55573 void *argp1 = 0 ;
55574 int res1 = 0 ;
55575 PyObject *swig_obj[1] ;
55576
55577 if (!args) SWIG_fail;
55578 swig_obj[0] = args;
55579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55580 if (!SWIG_IsOK(res1)) {
55581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
55582 }
55583 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55584 {
55585 PyThreadState* __tstate = wxPyBeginAllowThreads();
55586 result = ((wxGBSizerItem const *)arg1)->GetSpan();
55587 wxPyEndAllowThreads(__tstate);
55588 if (PyErr_Occurred()) SWIG_fail;
55589 }
55590 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
55591 return resultobj;
55592 fail:
55593 return NULL;
55594 }
55595
55596
55597 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55598 PyObject *resultobj = 0;
55599 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55600 wxGBPosition *arg2 = 0 ;
55601 bool result;
55602 void *argp1 = 0 ;
55603 int res1 = 0 ;
55604 wxGBPosition temp2 ;
55605 PyObject * obj0 = 0 ;
55606 PyObject * obj1 = 0 ;
55607 char * kwnames[] = {
55608 (char *) "self",(char *) "pos", NULL
55609 };
55610
55611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
55612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55613 if (!SWIG_IsOK(res1)) {
55614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55615 }
55616 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55617 {
55618 arg2 = &temp2;
55619 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55620 }
55621 {
55622 PyThreadState* __tstate = wxPyBeginAllowThreads();
55623 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
55624 wxPyEndAllowThreads(__tstate);
55625 if (PyErr_Occurred()) SWIG_fail;
55626 }
55627 {
55628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55629 }
55630 return resultobj;
55631 fail:
55632 return NULL;
55633 }
55634
55635
55636 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55637 PyObject *resultobj = 0;
55638 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55639 wxGBSpan *arg2 = 0 ;
55640 bool result;
55641 void *argp1 = 0 ;
55642 int res1 = 0 ;
55643 wxGBSpan temp2 ;
55644 PyObject * obj0 = 0 ;
55645 PyObject * obj1 = 0 ;
55646 char * kwnames[] = {
55647 (char *) "self",(char *) "span", NULL
55648 };
55649
55650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
55651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55652 if (!SWIG_IsOK(res1)) {
55653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55654 }
55655 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55656 {
55657 arg2 = &temp2;
55658 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
55659 }
55660 {
55661 PyThreadState* __tstate = wxPyBeginAllowThreads();
55662 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
55663 wxPyEndAllowThreads(__tstate);
55664 if (PyErr_Occurred()) SWIG_fail;
55665 }
55666 {
55667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55668 }
55669 return resultobj;
55670 fail:
55671 return NULL;
55672 }
55673
55674
55675 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55676 PyObject *resultobj = 0;
55677 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55678 wxGBSizerItem *arg2 = 0 ;
55679 bool result;
55680 void *argp1 = 0 ;
55681 int res1 = 0 ;
55682 void *argp2 = 0 ;
55683 int res2 = 0 ;
55684 PyObject * obj0 = 0 ;
55685 PyObject * obj1 = 0 ;
55686 char * kwnames[] = {
55687 (char *) "self",(char *) "other", NULL
55688 };
55689
55690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
55691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55692 if (!SWIG_IsOK(res1)) {
55693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55694 }
55695 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55696 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
55697 if (!SWIG_IsOK(res2)) {
55698 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
55699 }
55700 if (!argp2) {
55701 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
55702 }
55703 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
55704 {
55705 PyThreadState* __tstate = wxPyBeginAllowThreads();
55706 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
55707 wxPyEndAllowThreads(__tstate);
55708 if (PyErr_Occurred()) SWIG_fail;
55709 }
55710 {
55711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55712 }
55713 return resultobj;
55714 fail:
55715 return NULL;
55716 }
55717
55718
55719 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55720 PyObject *resultobj = 0;
55721 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55722 wxGBPosition *arg2 = 0 ;
55723 wxGBSpan *arg3 = 0 ;
55724 bool result;
55725 void *argp1 = 0 ;
55726 int res1 = 0 ;
55727 wxGBPosition temp2 ;
55728 wxGBSpan temp3 ;
55729 PyObject * obj0 = 0 ;
55730 PyObject * obj1 = 0 ;
55731 PyObject * obj2 = 0 ;
55732 char * kwnames[] = {
55733 (char *) "self",(char *) "pos",(char *) "span", NULL
55734 };
55735
55736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55738 if (!SWIG_IsOK(res1)) {
55739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55740 }
55741 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55742 {
55743 arg2 = &temp2;
55744 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55745 }
55746 {
55747 arg3 = &temp3;
55748 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
55749 }
55750 {
55751 PyThreadState* __tstate = wxPyBeginAllowThreads();
55752 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
55753 wxPyEndAllowThreads(__tstate);
55754 if (PyErr_Occurred()) SWIG_fail;
55755 }
55756 {
55757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55758 }
55759 return resultobj;
55760 fail:
55761 return NULL;
55762 }
55763
55764
55765 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55766 PyObject *resultobj = 0;
55767 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55768 wxGBPosition result;
55769 void *argp1 = 0 ;
55770 int res1 = 0 ;
55771 PyObject *swig_obj[1] ;
55772
55773 if (!args) SWIG_fail;
55774 swig_obj[0] = args;
55775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55776 if (!SWIG_IsOK(res1)) {
55777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55778 }
55779 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55780 {
55781 PyThreadState* __tstate = wxPyBeginAllowThreads();
55782 result = wxGBSizerItem_GetEndPos(arg1);
55783 wxPyEndAllowThreads(__tstate);
55784 if (PyErr_Occurred()) SWIG_fail;
55785 }
55786 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
55787 return resultobj;
55788 fail:
55789 return NULL;
55790 }
55791
55792
55793 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55794 PyObject *resultobj = 0;
55795 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55796 wxGridBagSizer *result = 0 ;
55797 void *argp1 = 0 ;
55798 int res1 = 0 ;
55799 PyObject *swig_obj[1] ;
55800
55801 if (!args) SWIG_fail;
55802 swig_obj[0] = args;
55803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55804 if (!SWIG_IsOK(res1)) {
55805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
55806 }
55807 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55808 {
55809 PyThreadState* __tstate = wxPyBeginAllowThreads();
55810 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
55811 wxPyEndAllowThreads(__tstate);
55812 if (PyErr_Occurred()) SWIG_fail;
55813 }
55814 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55815 return resultobj;
55816 fail:
55817 return NULL;
55818 }
55819
55820
55821 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55822 PyObject *resultobj = 0;
55823 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55824 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
55825 void *argp1 = 0 ;
55826 int res1 = 0 ;
55827 void *argp2 = 0 ;
55828 int res2 = 0 ;
55829 PyObject * obj0 = 0 ;
55830 PyObject * obj1 = 0 ;
55831 char * kwnames[] = {
55832 (char *) "self",(char *) "sizer", NULL
55833 };
55834
55835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
55836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55837 if (!SWIG_IsOK(res1)) {
55838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55839 }
55840 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55841 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55842 if (!SWIG_IsOK(res2)) {
55843 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
55844 }
55845 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
55846 {
55847 PyThreadState* __tstate = wxPyBeginAllowThreads();
55848 (arg1)->SetGBSizer(arg2);
55849 wxPyEndAllowThreads(__tstate);
55850 if (PyErr_Occurred()) SWIG_fail;
55851 }
55852 resultobj = SWIG_Py_Void();
55853 return resultobj;
55854 fail:
55855 return NULL;
55856 }
55857
55858
55859 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55860 PyObject *obj;
55861 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
55862 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
55863 return SWIG_Py_Void();
55864 }
55865
55866 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55867 return SWIG_Python_InitShadowInstance(args);
55868 }
55869
55870 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55871 PyObject *resultobj = 0;
55872 int arg1 = (int) 0 ;
55873 int arg2 = (int) 0 ;
55874 wxGridBagSizer *result = 0 ;
55875 int val1 ;
55876 int ecode1 = 0 ;
55877 int val2 ;
55878 int ecode2 = 0 ;
55879 PyObject * obj0 = 0 ;
55880 PyObject * obj1 = 0 ;
55881 char * kwnames[] = {
55882 (char *) "vgap",(char *) "hgap", NULL
55883 };
55884
55885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
55886 if (obj0) {
55887 ecode1 = SWIG_AsVal_int(obj0, &val1);
55888 if (!SWIG_IsOK(ecode1)) {
55889 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
55890 }
55891 arg1 = static_cast< int >(val1);
55892 }
55893 if (obj1) {
55894 ecode2 = SWIG_AsVal_int(obj1, &val2);
55895 if (!SWIG_IsOK(ecode2)) {
55896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
55897 }
55898 arg2 = static_cast< int >(val2);
55899 }
55900 {
55901 PyThreadState* __tstate = wxPyBeginAllowThreads();
55902 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
55903 wxPyEndAllowThreads(__tstate);
55904 if (PyErr_Occurred()) SWIG_fail;
55905 }
55906 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
55907 return resultobj;
55908 fail:
55909 return NULL;
55910 }
55911
55912
55913 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55914 PyObject *resultobj = 0;
55915 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55916 PyObject *arg2 = (PyObject *) 0 ;
55917 wxGBPosition *arg3 = 0 ;
55918 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
55919 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
55920 int arg5 = (int) 0 ;
55921 int arg6 = (int) 0 ;
55922 PyObject *arg7 = (PyObject *) NULL ;
55923 wxGBSizerItem *result = 0 ;
55924 void *argp1 = 0 ;
55925 int res1 = 0 ;
55926 wxGBPosition temp3 ;
55927 wxGBSpan temp4 ;
55928 int val5 ;
55929 int ecode5 = 0 ;
55930 int val6 ;
55931 int ecode6 = 0 ;
55932 PyObject * obj0 = 0 ;
55933 PyObject * obj1 = 0 ;
55934 PyObject * obj2 = 0 ;
55935 PyObject * obj3 = 0 ;
55936 PyObject * obj4 = 0 ;
55937 PyObject * obj5 = 0 ;
55938 PyObject * obj6 = 0 ;
55939 char * kwnames[] = {
55940 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
55941 };
55942
55943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
55944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55945 if (!SWIG_IsOK(res1)) {
55946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55947 }
55948 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55949 arg2 = obj1;
55950 {
55951 arg3 = &temp3;
55952 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
55953 }
55954 if (obj3) {
55955 {
55956 arg4 = &temp4;
55957 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
55958 }
55959 }
55960 if (obj4) {
55961 ecode5 = SWIG_AsVal_int(obj4, &val5);
55962 if (!SWIG_IsOK(ecode5)) {
55963 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
55964 }
55965 arg5 = static_cast< int >(val5);
55966 }
55967 if (obj5) {
55968 ecode6 = SWIG_AsVal_int(obj5, &val6);
55969 if (!SWIG_IsOK(ecode6)) {
55970 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
55971 }
55972 arg6 = static_cast< int >(val6);
55973 }
55974 if (obj6) {
55975 arg7 = obj6;
55976 }
55977 {
55978 PyThreadState* __tstate = wxPyBeginAllowThreads();
55979 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
55980 wxPyEndAllowThreads(__tstate);
55981 if (PyErr_Occurred()) SWIG_fail;
55982 }
55983 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55984 return resultobj;
55985 fail:
55986 return NULL;
55987 }
55988
55989
55990 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55991 PyObject *resultobj = 0;
55992 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55993 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
55994 wxGBSizerItem *result = 0 ;
55995 void *argp1 = 0 ;
55996 int res1 = 0 ;
55997 int res2 = 0 ;
55998 PyObject * obj0 = 0 ;
55999 PyObject * obj1 = 0 ;
56000 char * kwnames[] = {
56001 (char *) "self",(char *) "item", NULL
56002 };
56003
56004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
56005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56006 if (!SWIG_IsOK(res1)) {
56007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56008 }
56009 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56010 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
56011 if (!SWIG_IsOK(res2)) {
56012 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
56013 }
56014 {
56015 PyThreadState* __tstate = wxPyBeginAllowThreads();
56016 result = (wxGBSizerItem *)(arg1)->Add(arg2);
56017 wxPyEndAllowThreads(__tstate);
56018 if (PyErr_Occurred()) SWIG_fail;
56019 }
56020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56021 return resultobj;
56022 fail:
56023 return NULL;
56024 }
56025
56026
56027 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56028 PyObject *resultobj = 0;
56029 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56030 int arg2 ;
56031 int arg3 ;
56032 wxSize result;
56033 void *argp1 = 0 ;
56034 int res1 = 0 ;
56035 int val2 ;
56036 int ecode2 = 0 ;
56037 int val3 ;
56038 int ecode3 = 0 ;
56039 PyObject * obj0 = 0 ;
56040 PyObject * obj1 = 0 ;
56041 PyObject * obj2 = 0 ;
56042 char * kwnames[] = {
56043 (char *) "self",(char *) "row",(char *) "col", NULL
56044 };
56045
56046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56048 if (!SWIG_IsOK(res1)) {
56049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
56050 }
56051 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56052 ecode2 = SWIG_AsVal_int(obj1, &val2);
56053 if (!SWIG_IsOK(ecode2)) {
56054 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
56055 }
56056 arg2 = static_cast< int >(val2);
56057 ecode3 = SWIG_AsVal_int(obj2, &val3);
56058 if (!SWIG_IsOK(ecode3)) {
56059 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
56060 }
56061 arg3 = static_cast< int >(val3);
56062 {
56063 PyThreadState* __tstate = wxPyBeginAllowThreads();
56064 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
56065 wxPyEndAllowThreads(__tstate);
56066 if (PyErr_Occurred()) SWIG_fail;
56067 }
56068 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
56069 return resultobj;
56070 fail:
56071 return NULL;
56072 }
56073
56074
56075 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56076 PyObject *resultobj = 0;
56077 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56078 wxSize result;
56079 void *argp1 = 0 ;
56080 int res1 = 0 ;
56081 PyObject *swig_obj[1] ;
56082
56083 if (!args) SWIG_fail;
56084 swig_obj[0] = args;
56085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56086 if (!SWIG_IsOK(res1)) {
56087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
56088 }
56089 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56090 {
56091 PyThreadState* __tstate = wxPyBeginAllowThreads();
56092 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
56093 wxPyEndAllowThreads(__tstate);
56094 if (PyErr_Occurred()) SWIG_fail;
56095 }
56096 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
56097 return resultobj;
56098 fail:
56099 return NULL;
56100 }
56101
56102
56103 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56104 PyObject *resultobj = 0;
56105 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56106 wxSize *arg2 = 0 ;
56107 void *argp1 = 0 ;
56108 int res1 = 0 ;
56109 wxSize temp2 ;
56110 PyObject * obj0 = 0 ;
56111 PyObject * obj1 = 0 ;
56112 char * kwnames[] = {
56113 (char *) "self",(char *) "sz", NULL
56114 };
56115
56116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
56117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56118 if (!SWIG_IsOK(res1)) {
56119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56120 }
56121 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56122 {
56123 arg2 = &temp2;
56124 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
56125 }
56126 {
56127 PyThreadState* __tstate = wxPyBeginAllowThreads();
56128 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
56129 wxPyEndAllowThreads(__tstate);
56130 if (PyErr_Occurred()) SWIG_fail;
56131 }
56132 resultobj = SWIG_Py_Void();
56133 return resultobj;
56134 fail:
56135 return NULL;
56136 }
56137
56138
56139 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56140 PyObject *resultobj = 0;
56141 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56142 wxWindow *arg2 = (wxWindow *) 0 ;
56143 wxGBPosition result;
56144 void *argp1 = 0 ;
56145 int res1 = 0 ;
56146 void *argp2 = 0 ;
56147 int res2 = 0 ;
56148
56149 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56151 if (!SWIG_IsOK(res1)) {
56152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56153 }
56154 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56155 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56156 if (!SWIG_IsOK(res2)) {
56157 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
56158 }
56159 arg2 = reinterpret_cast< wxWindow * >(argp2);
56160 {
56161 PyThreadState* __tstate = wxPyBeginAllowThreads();
56162 result = (arg1)->GetItemPosition(arg2);
56163 wxPyEndAllowThreads(__tstate);
56164 if (PyErr_Occurred()) SWIG_fail;
56165 }
56166 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
56167 return resultobj;
56168 fail:
56169 return NULL;
56170 }
56171
56172
56173 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56174 PyObject *resultobj = 0;
56175 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56176 wxSizer *arg2 = (wxSizer *) 0 ;
56177 wxGBPosition result;
56178 void *argp1 = 0 ;
56179 int res1 = 0 ;
56180 void *argp2 = 0 ;
56181 int res2 = 0 ;
56182
56183 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56185 if (!SWIG_IsOK(res1)) {
56186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56187 }
56188 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56189 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
56190 if (!SWIG_IsOK(res2)) {
56191 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
56192 }
56193 arg2 = reinterpret_cast< wxSizer * >(argp2);
56194 {
56195 PyThreadState* __tstate = wxPyBeginAllowThreads();
56196 result = (arg1)->GetItemPosition(arg2);
56197 wxPyEndAllowThreads(__tstate);
56198 if (PyErr_Occurred()) SWIG_fail;
56199 }
56200 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
56201 return resultobj;
56202 fail:
56203 return NULL;
56204 }
56205
56206
56207 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56208 PyObject *resultobj = 0;
56209 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56210 size_t arg2 ;
56211 wxGBPosition result;
56212 void *argp1 = 0 ;
56213 int res1 = 0 ;
56214 size_t val2 ;
56215 int ecode2 = 0 ;
56216
56217 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56219 if (!SWIG_IsOK(res1)) {
56220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56221 }
56222 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56223 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
56224 if (!SWIG_IsOK(ecode2)) {
56225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
56226 }
56227 arg2 = static_cast< size_t >(val2);
56228 {
56229 PyThreadState* __tstate = wxPyBeginAllowThreads();
56230 result = (arg1)->GetItemPosition(arg2);
56231 wxPyEndAllowThreads(__tstate);
56232 if (PyErr_Occurred()) SWIG_fail;
56233 }
56234 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
56235 return resultobj;
56236 fail:
56237 return NULL;
56238 }
56239
56240
56241 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
56242 int argc;
56243 PyObject *argv[3];
56244
56245 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
56246 --argc;
56247 if (argc == 2) {
56248 int _v = 0;
56249 {
56250 void *vptr = 0;
56251 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
56252 _v = SWIG_CheckState(res);
56253 }
56254 if (!_v) goto check_1;
56255 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
56256 }
56257 check_1:
56258
56259 if (argc == 2) {
56260 int _v = 0;
56261 {
56262 void *vptr = 0;
56263 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
56264 _v = SWIG_CheckState(res);
56265 }
56266 if (!_v) goto check_2;
56267 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
56268 }
56269 check_2:
56270
56271 if (argc == 2) {
56272 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
56273 }
56274
56275 fail:
56276 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
56277 return NULL;
56278 }
56279
56280
56281 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56282 PyObject *resultobj = 0;
56283 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56284 wxWindow *arg2 = (wxWindow *) 0 ;
56285 wxGBPosition *arg3 = 0 ;
56286 bool result;
56287 void *argp1 = 0 ;
56288 int res1 = 0 ;
56289 void *argp2 = 0 ;
56290 int res2 = 0 ;
56291 wxGBPosition temp3 ;
56292
56293 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56295 if (!SWIG_IsOK(res1)) {
56296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56297 }
56298 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56299 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56300 if (!SWIG_IsOK(res2)) {
56301 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
56302 }
56303 arg2 = reinterpret_cast< wxWindow * >(argp2);
56304 {
56305 arg3 = &temp3;
56306 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
56307 }
56308 {
56309 PyThreadState* __tstate = wxPyBeginAllowThreads();
56310 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
56311 wxPyEndAllowThreads(__tstate);
56312 if (PyErr_Occurred()) SWIG_fail;
56313 }
56314 {
56315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56316 }
56317 return resultobj;
56318 fail:
56319 return NULL;
56320 }
56321
56322
56323 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56324 PyObject *resultobj = 0;
56325 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56326 wxSizer *arg2 = (wxSizer *) 0 ;
56327 wxGBPosition *arg3 = 0 ;
56328 bool result;
56329 void *argp1 = 0 ;
56330 int res1 = 0 ;
56331 void *argp2 = 0 ;
56332 int res2 = 0 ;
56333 wxGBPosition temp3 ;
56334
56335 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56337 if (!SWIG_IsOK(res1)) {
56338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56339 }
56340 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56341 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
56342 if (!SWIG_IsOK(res2)) {
56343 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
56344 }
56345 arg2 = reinterpret_cast< wxSizer * >(argp2);
56346 {
56347 arg3 = &temp3;
56348 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
56349 }
56350 {
56351 PyThreadState* __tstate = wxPyBeginAllowThreads();
56352 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
56353 wxPyEndAllowThreads(__tstate);
56354 if (PyErr_Occurred()) SWIG_fail;
56355 }
56356 {
56357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56358 }
56359 return resultobj;
56360 fail:
56361 return NULL;
56362 }
56363
56364
56365 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56366 PyObject *resultobj = 0;
56367 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56368 size_t arg2 ;
56369 wxGBPosition *arg3 = 0 ;
56370 bool result;
56371 void *argp1 = 0 ;
56372 int res1 = 0 ;
56373 size_t val2 ;
56374 int ecode2 = 0 ;
56375 wxGBPosition temp3 ;
56376
56377 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56379 if (!SWIG_IsOK(res1)) {
56380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56381 }
56382 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56383 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
56384 if (!SWIG_IsOK(ecode2)) {
56385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
56386 }
56387 arg2 = static_cast< size_t >(val2);
56388 {
56389 arg3 = &temp3;
56390 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
56391 }
56392 {
56393 PyThreadState* __tstate = wxPyBeginAllowThreads();
56394 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
56395 wxPyEndAllowThreads(__tstate);
56396 if (PyErr_Occurred()) SWIG_fail;
56397 }
56398 {
56399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56400 }
56401 return resultobj;
56402 fail:
56403 return NULL;
56404 }
56405
56406
56407 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
56408 int argc;
56409 PyObject *argv[4];
56410
56411 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
56412 --argc;
56413 if (argc == 3) {
56414 int _v = 0;
56415 {
56416 void *vptr = 0;
56417 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
56418 _v = SWIG_CheckState(res);
56419 }
56420 if (!_v) goto check_1;
56421 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
56422 }
56423 check_1:
56424
56425 if (argc == 3) {
56426 int _v = 0;
56427 {
56428 void *vptr = 0;
56429 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
56430 _v = SWIG_CheckState(res);
56431 }
56432 if (!_v) goto check_2;
56433 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
56434 }
56435 check_2:
56436
56437 if (argc == 3) {
56438 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
56439 }
56440
56441 fail:
56442 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
56443 return NULL;
56444 }
56445
56446
56447 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56448 PyObject *resultobj = 0;
56449 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56450 wxWindow *arg2 = (wxWindow *) 0 ;
56451 wxGBSpan result;
56452 void *argp1 = 0 ;
56453 int res1 = 0 ;
56454 void *argp2 = 0 ;
56455 int res2 = 0 ;
56456
56457 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56459 if (!SWIG_IsOK(res1)) {
56460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56461 }
56462 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56463 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56464 if (!SWIG_IsOK(res2)) {
56465 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
56466 }
56467 arg2 = reinterpret_cast< wxWindow * >(argp2);
56468 {
56469 PyThreadState* __tstate = wxPyBeginAllowThreads();
56470 result = (arg1)->GetItemSpan(arg2);
56471 wxPyEndAllowThreads(__tstate);
56472 if (PyErr_Occurred()) SWIG_fail;
56473 }
56474 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
56475 return resultobj;
56476 fail:
56477 return NULL;
56478 }
56479
56480
56481 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56482 PyObject *resultobj = 0;
56483 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56484 wxSizer *arg2 = (wxSizer *) 0 ;
56485 wxGBSpan result;
56486 void *argp1 = 0 ;
56487 int res1 = 0 ;
56488 void *argp2 = 0 ;
56489 int res2 = 0 ;
56490
56491 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56493 if (!SWIG_IsOK(res1)) {
56494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56495 }
56496 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56497 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
56498 if (!SWIG_IsOK(res2)) {
56499 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
56500 }
56501 arg2 = reinterpret_cast< wxSizer * >(argp2);
56502 {
56503 PyThreadState* __tstate = wxPyBeginAllowThreads();
56504 result = (arg1)->GetItemSpan(arg2);
56505 wxPyEndAllowThreads(__tstate);
56506 if (PyErr_Occurred()) SWIG_fail;
56507 }
56508 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
56509 return resultobj;
56510 fail:
56511 return NULL;
56512 }
56513
56514
56515 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56516 PyObject *resultobj = 0;
56517 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56518 size_t arg2 ;
56519 wxGBSpan result;
56520 void *argp1 = 0 ;
56521 int res1 = 0 ;
56522 size_t val2 ;
56523 int ecode2 = 0 ;
56524
56525 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56527 if (!SWIG_IsOK(res1)) {
56528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56529 }
56530 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56531 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
56532 if (!SWIG_IsOK(ecode2)) {
56533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
56534 }
56535 arg2 = static_cast< size_t >(val2);
56536 {
56537 PyThreadState* __tstate = wxPyBeginAllowThreads();
56538 result = (arg1)->GetItemSpan(arg2);
56539 wxPyEndAllowThreads(__tstate);
56540 if (PyErr_Occurred()) SWIG_fail;
56541 }
56542 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
56543 return resultobj;
56544 fail:
56545 return NULL;
56546 }
56547
56548
56549 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
56550 int argc;
56551 PyObject *argv[3];
56552
56553 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
56554 --argc;
56555 if (argc == 2) {
56556 int _v = 0;
56557 {
56558 void *vptr = 0;
56559 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
56560 _v = SWIG_CheckState(res);
56561 }
56562 if (!_v) goto check_1;
56563 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
56564 }
56565 check_1:
56566
56567 if (argc == 2) {
56568 int _v = 0;
56569 {
56570 void *vptr = 0;
56571 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
56572 _v = SWIG_CheckState(res);
56573 }
56574 if (!_v) goto check_2;
56575 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
56576 }
56577 check_2:
56578
56579 if (argc == 2) {
56580 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
56581 }
56582
56583 fail:
56584 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
56585 return NULL;
56586 }
56587
56588
56589 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56590 PyObject *resultobj = 0;
56591 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56592 wxWindow *arg2 = (wxWindow *) 0 ;
56593 wxGBSpan *arg3 = 0 ;
56594 bool result;
56595 void *argp1 = 0 ;
56596 int res1 = 0 ;
56597 void *argp2 = 0 ;
56598 int res2 = 0 ;
56599 wxGBSpan temp3 ;
56600
56601 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56603 if (!SWIG_IsOK(res1)) {
56604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56605 }
56606 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56607 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56608 if (!SWIG_IsOK(res2)) {
56609 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
56610 }
56611 arg2 = reinterpret_cast< wxWindow * >(argp2);
56612 {
56613 arg3 = &temp3;
56614 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
56615 }
56616 {
56617 PyThreadState* __tstate = wxPyBeginAllowThreads();
56618 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
56619 wxPyEndAllowThreads(__tstate);
56620 if (PyErr_Occurred()) SWIG_fail;
56621 }
56622 {
56623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56624 }
56625 return resultobj;
56626 fail:
56627 return NULL;
56628 }
56629
56630
56631 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56632 PyObject *resultobj = 0;
56633 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56634 wxSizer *arg2 = (wxSizer *) 0 ;
56635 wxGBSpan *arg3 = 0 ;
56636 bool result;
56637 void *argp1 = 0 ;
56638 int res1 = 0 ;
56639 void *argp2 = 0 ;
56640 int res2 = 0 ;
56641 wxGBSpan temp3 ;
56642
56643 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56645 if (!SWIG_IsOK(res1)) {
56646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56647 }
56648 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56649 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
56650 if (!SWIG_IsOK(res2)) {
56651 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
56652 }
56653 arg2 = reinterpret_cast< wxSizer * >(argp2);
56654 {
56655 arg3 = &temp3;
56656 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
56657 }
56658 {
56659 PyThreadState* __tstate = wxPyBeginAllowThreads();
56660 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
56661 wxPyEndAllowThreads(__tstate);
56662 if (PyErr_Occurred()) SWIG_fail;
56663 }
56664 {
56665 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56666 }
56667 return resultobj;
56668 fail:
56669 return NULL;
56670 }
56671
56672
56673 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56674 PyObject *resultobj = 0;
56675 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56676 size_t arg2 ;
56677 wxGBSpan *arg3 = 0 ;
56678 bool result;
56679 void *argp1 = 0 ;
56680 int res1 = 0 ;
56681 size_t val2 ;
56682 int ecode2 = 0 ;
56683 wxGBSpan temp3 ;
56684
56685 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56687 if (!SWIG_IsOK(res1)) {
56688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56689 }
56690 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56691 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
56692 if (!SWIG_IsOK(ecode2)) {
56693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
56694 }
56695 arg2 = static_cast< size_t >(val2);
56696 {
56697 arg3 = &temp3;
56698 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
56699 }
56700 {
56701 PyThreadState* __tstate = wxPyBeginAllowThreads();
56702 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
56703 wxPyEndAllowThreads(__tstate);
56704 if (PyErr_Occurred()) SWIG_fail;
56705 }
56706 {
56707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56708 }
56709 return resultobj;
56710 fail:
56711 return NULL;
56712 }
56713
56714
56715 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
56716 int argc;
56717 PyObject *argv[4];
56718
56719 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
56720 --argc;
56721 if (argc == 3) {
56722 int _v = 0;
56723 {
56724 void *vptr = 0;
56725 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
56726 _v = SWIG_CheckState(res);
56727 }
56728 if (!_v) goto check_1;
56729 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
56730 }
56731 check_1:
56732
56733 if (argc == 3) {
56734 int _v = 0;
56735 {
56736 void *vptr = 0;
56737 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
56738 _v = SWIG_CheckState(res);
56739 }
56740 if (!_v) goto check_2;
56741 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
56742 }
56743 check_2:
56744
56745 if (argc == 3) {
56746 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
56747 }
56748
56749 fail:
56750 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
56751 return NULL;
56752 }
56753
56754
56755 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56756 PyObject *resultobj = 0;
56757 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56758 wxWindow *arg2 = (wxWindow *) 0 ;
56759 wxGBSizerItem *result = 0 ;
56760 void *argp1 = 0 ;
56761 int res1 = 0 ;
56762 void *argp2 = 0 ;
56763 int res2 = 0 ;
56764
56765 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56767 if (!SWIG_IsOK(res1)) {
56768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56769 }
56770 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56771 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56772 if (!SWIG_IsOK(res2)) {
56773 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
56774 }
56775 arg2 = reinterpret_cast< wxWindow * >(argp2);
56776 {
56777 PyThreadState* __tstate = wxPyBeginAllowThreads();
56778 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
56779 wxPyEndAllowThreads(__tstate);
56780 if (PyErr_Occurred()) SWIG_fail;
56781 }
56782 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56783 return resultobj;
56784 fail:
56785 return NULL;
56786 }
56787
56788
56789 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56790 PyObject *resultobj = 0;
56791 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56792 wxSizer *arg2 = (wxSizer *) 0 ;
56793 wxGBSizerItem *result = 0 ;
56794 void *argp1 = 0 ;
56795 int res1 = 0 ;
56796 void *argp2 = 0 ;
56797 int res2 = 0 ;
56798
56799 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56801 if (!SWIG_IsOK(res1)) {
56802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56803 }
56804 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56805 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
56806 if (!SWIG_IsOK(res2)) {
56807 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
56808 }
56809 arg2 = reinterpret_cast< wxSizer * >(argp2);
56810 {
56811 PyThreadState* __tstate = wxPyBeginAllowThreads();
56812 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
56813 wxPyEndAllowThreads(__tstate);
56814 if (PyErr_Occurred()) SWIG_fail;
56815 }
56816 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56817 return resultobj;
56818 fail:
56819 return NULL;
56820 }
56821
56822
56823 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
56824 int argc;
56825 PyObject *argv[3];
56826
56827 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
56828 --argc;
56829 if (argc == 2) {
56830 int _v = 0;
56831 {
56832 void *vptr = 0;
56833 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
56834 _v = SWIG_CheckState(res);
56835 }
56836 if (!_v) goto check_1;
56837 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
56838 }
56839 check_1:
56840
56841 if (argc == 2) {
56842 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
56843 }
56844
56845 fail:
56846 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
56847 return NULL;
56848 }
56849
56850
56851 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56852 PyObject *resultobj = 0;
56853 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56854 wxGBPosition *arg2 = 0 ;
56855 wxGBSizerItem *result = 0 ;
56856 void *argp1 = 0 ;
56857 int res1 = 0 ;
56858 wxGBPosition temp2 ;
56859 PyObject * obj0 = 0 ;
56860 PyObject * obj1 = 0 ;
56861 char * kwnames[] = {
56862 (char *) "self",(char *) "pos", NULL
56863 };
56864
56865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
56866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56867 if (!SWIG_IsOK(res1)) {
56868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56869 }
56870 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56871 {
56872 arg2 = &temp2;
56873 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
56874 }
56875 {
56876 PyThreadState* __tstate = wxPyBeginAllowThreads();
56877 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
56878 wxPyEndAllowThreads(__tstate);
56879 if (PyErr_Occurred()) SWIG_fail;
56880 }
56881 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56882 return resultobj;
56883 fail:
56884 return NULL;
56885 }
56886
56887
56888 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56889 PyObject *resultobj = 0;
56890 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56891 wxPoint *arg2 = 0 ;
56892 wxGBSizerItem *result = 0 ;
56893 void *argp1 = 0 ;
56894 int res1 = 0 ;
56895 wxPoint temp2 ;
56896 PyObject * obj0 = 0 ;
56897 PyObject * obj1 = 0 ;
56898 char * kwnames[] = {
56899 (char *) "self",(char *) "pt", NULL
56900 };
56901
56902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
56903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56904 if (!SWIG_IsOK(res1)) {
56905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56906 }
56907 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56908 {
56909 arg2 = &temp2;
56910 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
56911 }
56912 {
56913 PyThreadState* __tstate = wxPyBeginAllowThreads();
56914 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
56915 wxPyEndAllowThreads(__tstate);
56916 if (PyErr_Occurred()) SWIG_fail;
56917 }
56918 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56919 return resultobj;
56920 fail:
56921 return NULL;
56922 }
56923
56924
56925 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56926 PyObject *resultobj = 0;
56927 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56928 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
56929 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
56930 bool result;
56931 void *argp1 = 0 ;
56932 int res1 = 0 ;
56933 void *argp2 = 0 ;
56934 int res2 = 0 ;
56935 void *argp3 = 0 ;
56936 int res3 = 0 ;
56937 PyObject * obj0 = 0 ;
56938 PyObject * obj1 = 0 ;
56939 PyObject * obj2 = 0 ;
56940 char * kwnames[] = {
56941 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
56942 };
56943
56944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56946 if (!SWIG_IsOK(res1)) {
56947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56948 }
56949 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56950 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56951 if (!SWIG_IsOK(res2)) {
56952 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
56953 }
56954 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
56955 if (obj2) {
56956 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56957 if (!SWIG_IsOK(res3)) {
56958 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
56959 }
56960 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
56961 }
56962 {
56963 PyThreadState* __tstate = wxPyBeginAllowThreads();
56964 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
56965 wxPyEndAllowThreads(__tstate);
56966 if (PyErr_Occurred()) SWIG_fail;
56967 }
56968 {
56969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56970 }
56971 return resultobj;
56972 fail:
56973 return NULL;
56974 }
56975
56976
56977 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56978 PyObject *resultobj = 0;
56979 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56980 wxGBPosition *arg2 = 0 ;
56981 wxGBSpan *arg3 = 0 ;
56982 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
56983 bool result;
56984 void *argp1 = 0 ;
56985 int res1 = 0 ;
56986 wxGBPosition temp2 ;
56987 wxGBSpan temp3 ;
56988 void *argp4 = 0 ;
56989 int res4 = 0 ;
56990 PyObject * obj0 = 0 ;
56991 PyObject * obj1 = 0 ;
56992 PyObject * obj2 = 0 ;
56993 PyObject * obj3 = 0 ;
56994 char * kwnames[] = {
56995 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
56996 };
56997
56998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
56999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
57000 if (!SWIG_IsOK(res1)) {
57001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
57002 }
57003 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
57004 {
57005 arg2 = &temp2;
57006 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
57007 }
57008 {
57009 arg3 = &temp3;
57010 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
57011 }
57012 if (obj3) {
57013 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
57014 if (!SWIG_IsOK(res4)) {
57015 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
57016 }
57017 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
57018 }
57019 {
57020 PyThreadState* __tstate = wxPyBeginAllowThreads();
57021 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
57022 wxPyEndAllowThreads(__tstate);
57023 if (PyErr_Occurred()) SWIG_fail;
57024 }
57025 {
57026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57027 }
57028 return resultobj;
57029 fail:
57030 return NULL;
57031 }
57032
57033
57034 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57035 PyObject *obj;
57036 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
57037 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
57038 return SWIG_Py_Void();
57039 }
57040
57041 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57042 return SWIG_Python_InitShadowInstance(args);
57043 }
57044
57045 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57046 PyObject *resultobj = 0;
57047 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57048 wxRelationship arg2 ;
57049 wxWindow *arg3 = (wxWindow *) 0 ;
57050 wxEdge arg4 ;
57051 int arg5 = (int) 0 ;
57052 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
57053 void *argp1 = 0 ;
57054 int res1 = 0 ;
57055 int val2 ;
57056 int ecode2 = 0 ;
57057 void *argp3 = 0 ;
57058 int res3 = 0 ;
57059 int val4 ;
57060 int ecode4 = 0 ;
57061 int val5 ;
57062 int ecode5 = 0 ;
57063 int val6 ;
57064 int ecode6 = 0 ;
57065 PyObject * obj0 = 0 ;
57066 PyObject * obj1 = 0 ;
57067 PyObject * obj2 = 0 ;
57068 PyObject * obj3 = 0 ;
57069 PyObject * obj4 = 0 ;
57070 PyObject * obj5 = 0 ;
57071 char * kwnames[] = {
57072 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
57073 };
57074
57075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
57076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57077 if (!SWIG_IsOK(res1)) {
57078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57079 }
57080 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57081 ecode2 = SWIG_AsVal_int(obj1, &val2);
57082 if (!SWIG_IsOK(ecode2)) {
57083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
57084 }
57085 arg2 = static_cast< wxRelationship >(val2);
57086 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
57087 if (!SWIG_IsOK(res3)) {
57088 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
57089 }
57090 arg3 = reinterpret_cast< wxWindow * >(argp3);
57091 ecode4 = SWIG_AsVal_int(obj3, &val4);
57092 if (!SWIG_IsOK(ecode4)) {
57093 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
57094 }
57095 arg4 = static_cast< wxEdge >(val4);
57096 if (obj4) {
57097 ecode5 = SWIG_AsVal_int(obj4, &val5);
57098 if (!SWIG_IsOK(ecode5)) {
57099 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
57100 }
57101 arg5 = static_cast< int >(val5);
57102 }
57103 if (obj5) {
57104 ecode6 = SWIG_AsVal_int(obj5, &val6);
57105 if (!SWIG_IsOK(ecode6)) {
57106 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
57107 }
57108 arg6 = static_cast< int >(val6);
57109 }
57110 {
57111 PyThreadState* __tstate = wxPyBeginAllowThreads();
57112 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
57113 wxPyEndAllowThreads(__tstate);
57114 if (PyErr_Occurred()) SWIG_fail;
57115 }
57116 resultobj = SWIG_Py_Void();
57117 return resultobj;
57118 fail:
57119 return NULL;
57120 }
57121
57122
57123 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57124 PyObject *resultobj = 0;
57125 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57126 wxWindow *arg2 = (wxWindow *) 0 ;
57127 int arg3 = (int) 0 ;
57128 void *argp1 = 0 ;
57129 int res1 = 0 ;
57130 void *argp2 = 0 ;
57131 int res2 = 0 ;
57132 int val3 ;
57133 int ecode3 = 0 ;
57134 PyObject * obj0 = 0 ;
57135 PyObject * obj1 = 0 ;
57136 PyObject * obj2 = 0 ;
57137 char * kwnames[] = {
57138 (char *) "self",(char *) "sibling",(char *) "marg", NULL
57139 };
57140
57141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
57142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57143 if (!SWIG_IsOK(res1)) {
57144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57145 }
57146 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57147 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57148 if (!SWIG_IsOK(res2)) {
57149 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
57150 }
57151 arg2 = reinterpret_cast< wxWindow * >(argp2);
57152 if (obj2) {
57153 ecode3 = SWIG_AsVal_int(obj2, &val3);
57154 if (!SWIG_IsOK(ecode3)) {
57155 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
57156 }
57157 arg3 = static_cast< int >(val3);
57158 }
57159 {
57160 PyThreadState* __tstate = wxPyBeginAllowThreads();
57161 (arg1)->LeftOf(arg2,arg3);
57162 wxPyEndAllowThreads(__tstate);
57163 if (PyErr_Occurred()) SWIG_fail;
57164 }
57165 resultobj = SWIG_Py_Void();
57166 return resultobj;
57167 fail:
57168 return NULL;
57169 }
57170
57171
57172 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57173 PyObject *resultobj = 0;
57174 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57175 wxWindow *arg2 = (wxWindow *) 0 ;
57176 int arg3 = (int) 0 ;
57177 void *argp1 = 0 ;
57178 int res1 = 0 ;
57179 void *argp2 = 0 ;
57180 int res2 = 0 ;
57181 int val3 ;
57182 int ecode3 = 0 ;
57183 PyObject * obj0 = 0 ;
57184 PyObject * obj1 = 0 ;
57185 PyObject * obj2 = 0 ;
57186 char * kwnames[] = {
57187 (char *) "self",(char *) "sibling",(char *) "marg", NULL
57188 };
57189
57190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
57191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57192 if (!SWIG_IsOK(res1)) {
57193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57194 }
57195 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57196 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57197 if (!SWIG_IsOK(res2)) {
57198 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
57199 }
57200 arg2 = reinterpret_cast< wxWindow * >(argp2);
57201 if (obj2) {
57202 ecode3 = SWIG_AsVal_int(obj2, &val3);
57203 if (!SWIG_IsOK(ecode3)) {
57204 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
57205 }
57206 arg3 = static_cast< int >(val3);
57207 }
57208 {
57209 PyThreadState* __tstate = wxPyBeginAllowThreads();
57210 (arg1)->RightOf(arg2,arg3);
57211 wxPyEndAllowThreads(__tstate);
57212 if (PyErr_Occurred()) SWIG_fail;
57213 }
57214 resultobj = SWIG_Py_Void();
57215 return resultobj;
57216 fail:
57217 return NULL;
57218 }
57219
57220
57221 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57222 PyObject *resultobj = 0;
57223 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57224 wxWindow *arg2 = (wxWindow *) 0 ;
57225 int arg3 = (int) 0 ;
57226 void *argp1 = 0 ;
57227 int res1 = 0 ;
57228 void *argp2 = 0 ;
57229 int res2 = 0 ;
57230 int val3 ;
57231 int ecode3 = 0 ;
57232 PyObject * obj0 = 0 ;
57233 PyObject * obj1 = 0 ;
57234 PyObject * obj2 = 0 ;
57235 char * kwnames[] = {
57236 (char *) "self",(char *) "sibling",(char *) "marg", NULL
57237 };
57238
57239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
57240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57241 if (!SWIG_IsOK(res1)) {
57242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57243 }
57244 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57245 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57246 if (!SWIG_IsOK(res2)) {
57247 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
57248 }
57249 arg2 = reinterpret_cast< wxWindow * >(argp2);
57250 if (obj2) {
57251 ecode3 = SWIG_AsVal_int(obj2, &val3);
57252 if (!SWIG_IsOK(ecode3)) {
57253 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
57254 }
57255 arg3 = static_cast< int >(val3);
57256 }
57257 {
57258 PyThreadState* __tstate = wxPyBeginAllowThreads();
57259 (arg1)->Above(arg2,arg3);
57260 wxPyEndAllowThreads(__tstate);
57261 if (PyErr_Occurred()) SWIG_fail;
57262 }
57263 resultobj = SWIG_Py_Void();
57264 return resultobj;
57265 fail:
57266 return NULL;
57267 }
57268
57269
57270 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57271 PyObject *resultobj = 0;
57272 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57273 wxWindow *arg2 = (wxWindow *) 0 ;
57274 int arg3 = (int) 0 ;
57275 void *argp1 = 0 ;
57276 int res1 = 0 ;
57277 void *argp2 = 0 ;
57278 int res2 = 0 ;
57279 int val3 ;
57280 int ecode3 = 0 ;
57281 PyObject * obj0 = 0 ;
57282 PyObject * obj1 = 0 ;
57283 PyObject * obj2 = 0 ;
57284 char * kwnames[] = {
57285 (char *) "self",(char *) "sibling",(char *) "marg", NULL
57286 };
57287
57288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
57289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57290 if (!SWIG_IsOK(res1)) {
57291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57292 }
57293 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57294 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57295 if (!SWIG_IsOK(res2)) {
57296 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
57297 }
57298 arg2 = reinterpret_cast< wxWindow * >(argp2);
57299 if (obj2) {
57300 ecode3 = SWIG_AsVal_int(obj2, &val3);
57301 if (!SWIG_IsOK(ecode3)) {
57302 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
57303 }
57304 arg3 = static_cast< int >(val3);
57305 }
57306 {
57307 PyThreadState* __tstate = wxPyBeginAllowThreads();
57308 (arg1)->Below(arg2,arg3);
57309 wxPyEndAllowThreads(__tstate);
57310 if (PyErr_Occurred()) SWIG_fail;
57311 }
57312 resultobj = SWIG_Py_Void();
57313 return resultobj;
57314 fail:
57315 return NULL;
57316 }
57317
57318
57319 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57320 PyObject *resultobj = 0;
57321 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57322 wxWindow *arg2 = (wxWindow *) 0 ;
57323 wxEdge arg3 ;
57324 int arg4 = (int) 0 ;
57325 void *argp1 = 0 ;
57326 int res1 = 0 ;
57327 void *argp2 = 0 ;
57328 int res2 = 0 ;
57329 int val3 ;
57330 int ecode3 = 0 ;
57331 int val4 ;
57332 int ecode4 = 0 ;
57333 PyObject * obj0 = 0 ;
57334 PyObject * obj1 = 0 ;
57335 PyObject * obj2 = 0 ;
57336 PyObject * obj3 = 0 ;
57337 char * kwnames[] = {
57338 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
57339 };
57340
57341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
57342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57343 if (!SWIG_IsOK(res1)) {
57344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57345 }
57346 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57347 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57348 if (!SWIG_IsOK(res2)) {
57349 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
57350 }
57351 arg2 = reinterpret_cast< wxWindow * >(argp2);
57352 ecode3 = SWIG_AsVal_int(obj2, &val3);
57353 if (!SWIG_IsOK(ecode3)) {
57354 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
57355 }
57356 arg3 = static_cast< wxEdge >(val3);
57357 if (obj3) {
57358 ecode4 = SWIG_AsVal_int(obj3, &val4);
57359 if (!SWIG_IsOK(ecode4)) {
57360 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
57361 }
57362 arg4 = static_cast< int >(val4);
57363 }
57364 {
57365 PyThreadState* __tstate = wxPyBeginAllowThreads();
57366 (arg1)->SameAs(arg2,arg3,arg4);
57367 wxPyEndAllowThreads(__tstate);
57368 if (PyErr_Occurred()) SWIG_fail;
57369 }
57370 resultobj = SWIG_Py_Void();
57371 return resultobj;
57372 fail:
57373 return NULL;
57374 }
57375
57376
57377 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57378 PyObject *resultobj = 0;
57379 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57380 wxWindow *arg2 = (wxWindow *) 0 ;
57381 wxEdge arg3 ;
57382 int arg4 ;
57383 void *argp1 = 0 ;
57384 int res1 = 0 ;
57385 void *argp2 = 0 ;
57386 int res2 = 0 ;
57387 int val3 ;
57388 int ecode3 = 0 ;
57389 int val4 ;
57390 int ecode4 = 0 ;
57391 PyObject * obj0 = 0 ;
57392 PyObject * obj1 = 0 ;
57393 PyObject * obj2 = 0 ;
57394 PyObject * obj3 = 0 ;
57395 char * kwnames[] = {
57396 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
57397 };
57398
57399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
57400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57401 if (!SWIG_IsOK(res1)) {
57402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57403 }
57404 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57405 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57406 if (!SWIG_IsOK(res2)) {
57407 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
57408 }
57409 arg2 = reinterpret_cast< wxWindow * >(argp2);
57410 ecode3 = SWIG_AsVal_int(obj2, &val3);
57411 if (!SWIG_IsOK(ecode3)) {
57412 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
57413 }
57414 arg3 = static_cast< wxEdge >(val3);
57415 ecode4 = SWIG_AsVal_int(obj3, &val4);
57416 if (!SWIG_IsOK(ecode4)) {
57417 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
57418 }
57419 arg4 = static_cast< int >(val4);
57420 {
57421 PyThreadState* __tstate = wxPyBeginAllowThreads();
57422 (arg1)->PercentOf(arg2,arg3,arg4);
57423 wxPyEndAllowThreads(__tstate);
57424 if (PyErr_Occurred()) SWIG_fail;
57425 }
57426 resultobj = SWIG_Py_Void();
57427 return resultobj;
57428 fail:
57429 return NULL;
57430 }
57431
57432
57433 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57434 PyObject *resultobj = 0;
57435 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57436 int arg2 ;
57437 void *argp1 = 0 ;
57438 int res1 = 0 ;
57439 int val2 ;
57440 int ecode2 = 0 ;
57441 PyObject * obj0 = 0 ;
57442 PyObject * obj1 = 0 ;
57443 char * kwnames[] = {
57444 (char *) "self",(char *) "val", NULL
57445 };
57446
57447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
57448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57449 if (!SWIG_IsOK(res1)) {
57450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57451 }
57452 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57453 ecode2 = SWIG_AsVal_int(obj1, &val2);
57454 if (!SWIG_IsOK(ecode2)) {
57455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
57456 }
57457 arg2 = static_cast< int >(val2);
57458 {
57459 PyThreadState* __tstate = wxPyBeginAllowThreads();
57460 (arg1)->Absolute(arg2);
57461 wxPyEndAllowThreads(__tstate);
57462 if (PyErr_Occurred()) SWIG_fail;
57463 }
57464 resultobj = SWIG_Py_Void();
57465 return resultobj;
57466 fail:
57467 return NULL;
57468 }
57469
57470
57471 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57472 PyObject *resultobj = 0;
57473 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57474 void *argp1 = 0 ;
57475 int res1 = 0 ;
57476 PyObject *swig_obj[1] ;
57477
57478 if (!args) SWIG_fail;
57479 swig_obj[0] = args;
57480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57481 if (!SWIG_IsOK(res1)) {
57482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57483 }
57484 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57485 {
57486 PyThreadState* __tstate = wxPyBeginAllowThreads();
57487 (arg1)->Unconstrained();
57488 wxPyEndAllowThreads(__tstate);
57489 if (PyErr_Occurred()) SWIG_fail;
57490 }
57491 resultobj = SWIG_Py_Void();
57492 return resultobj;
57493 fail:
57494 return NULL;
57495 }
57496
57497
57498 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57499 PyObject *resultobj = 0;
57500 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57501 void *argp1 = 0 ;
57502 int res1 = 0 ;
57503 PyObject *swig_obj[1] ;
57504
57505 if (!args) SWIG_fail;
57506 swig_obj[0] = args;
57507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57508 if (!SWIG_IsOK(res1)) {
57509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57510 }
57511 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57512 {
57513 PyThreadState* __tstate = wxPyBeginAllowThreads();
57514 (arg1)->AsIs();
57515 wxPyEndAllowThreads(__tstate);
57516 if (PyErr_Occurred()) SWIG_fail;
57517 }
57518 resultobj = SWIG_Py_Void();
57519 return resultobj;
57520 fail:
57521 return NULL;
57522 }
57523
57524
57525 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57526 PyObject *resultobj = 0;
57527 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57528 wxWindow *result = 0 ;
57529 void *argp1 = 0 ;
57530 int res1 = 0 ;
57531 PyObject *swig_obj[1] ;
57532
57533 if (!args) SWIG_fail;
57534 swig_obj[0] = args;
57535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57536 if (!SWIG_IsOK(res1)) {
57537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57538 }
57539 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57540 {
57541 PyThreadState* __tstate = wxPyBeginAllowThreads();
57542 result = (wxWindow *)(arg1)->GetOtherWindow();
57543 wxPyEndAllowThreads(__tstate);
57544 if (PyErr_Occurred()) SWIG_fail;
57545 }
57546 {
57547 resultobj = wxPyMake_wxObject(result, 0);
57548 }
57549 return resultobj;
57550 fail:
57551 return NULL;
57552 }
57553
57554
57555 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57556 PyObject *resultobj = 0;
57557 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57558 wxEdge result;
57559 void *argp1 = 0 ;
57560 int res1 = 0 ;
57561 PyObject *swig_obj[1] ;
57562
57563 if (!args) SWIG_fail;
57564 swig_obj[0] = args;
57565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57566 if (!SWIG_IsOK(res1)) {
57567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57568 }
57569 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57570 {
57571 PyThreadState* __tstate = wxPyBeginAllowThreads();
57572 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
57573 wxPyEndAllowThreads(__tstate);
57574 if (PyErr_Occurred()) SWIG_fail;
57575 }
57576 resultobj = SWIG_From_int(static_cast< int >(result));
57577 return resultobj;
57578 fail:
57579 return NULL;
57580 }
57581
57582
57583 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57584 PyObject *resultobj = 0;
57585 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57586 wxEdge arg2 ;
57587 void *argp1 = 0 ;
57588 int res1 = 0 ;
57589 int val2 ;
57590 int ecode2 = 0 ;
57591 PyObject * obj0 = 0 ;
57592 PyObject * obj1 = 0 ;
57593 char * kwnames[] = {
57594 (char *) "self",(char *) "which", NULL
57595 };
57596
57597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
57598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57599 if (!SWIG_IsOK(res1)) {
57600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57601 }
57602 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57603 ecode2 = SWIG_AsVal_int(obj1, &val2);
57604 if (!SWIG_IsOK(ecode2)) {
57605 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
57606 }
57607 arg2 = static_cast< wxEdge >(val2);
57608 {
57609 PyThreadState* __tstate = wxPyBeginAllowThreads();
57610 (arg1)->SetEdge(arg2);
57611 wxPyEndAllowThreads(__tstate);
57612 if (PyErr_Occurred()) SWIG_fail;
57613 }
57614 resultobj = SWIG_Py_Void();
57615 return resultobj;
57616 fail:
57617 return NULL;
57618 }
57619
57620
57621 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57622 PyObject *resultobj = 0;
57623 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57624 int arg2 ;
57625 void *argp1 = 0 ;
57626 int res1 = 0 ;
57627 int val2 ;
57628 int ecode2 = 0 ;
57629 PyObject * obj0 = 0 ;
57630 PyObject * obj1 = 0 ;
57631 char * kwnames[] = {
57632 (char *) "self",(char *) "v", NULL
57633 };
57634
57635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
57636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57637 if (!SWIG_IsOK(res1)) {
57638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57639 }
57640 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57641 ecode2 = SWIG_AsVal_int(obj1, &val2);
57642 if (!SWIG_IsOK(ecode2)) {
57643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
57644 }
57645 arg2 = static_cast< int >(val2);
57646 {
57647 PyThreadState* __tstate = wxPyBeginAllowThreads();
57648 (arg1)->SetValue(arg2);
57649 wxPyEndAllowThreads(__tstate);
57650 if (PyErr_Occurred()) SWIG_fail;
57651 }
57652 resultobj = SWIG_Py_Void();
57653 return resultobj;
57654 fail:
57655 return NULL;
57656 }
57657
57658
57659 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57660 PyObject *resultobj = 0;
57661 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57662 int result;
57663 void *argp1 = 0 ;
57664 int res1 = 0 ;
57665 PyObject *swig_obj[1] ;
57666
57667 if (!args) SWIG_fail;
57668 swig_obj[0] = args;
57669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57670 if (!SWIG_IsOK(res1)) {
57671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57672 }
57673 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57674 {
57675 PyThreadState* __tstate = wxPyBeginAllowThreads();
57676 result = (int)(arg1)->GetMargin();
57677 wxPyEndAllowThreads(__tstate);
57678 if (PyErr_Occurred()) SWIG_fail;
57679 }
57680 resultobj = SWIG_From_int(static_cast< int >(result));
57681 return resultobj;
57682 fail:
57683 return NULL;
57684 }
57685
57686
57687 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57688 PyObject *resultobj = 0;
57689 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57690 int arg2 ;
57691 void *argp1 = 0 ;
57692 int res1 = 0 ;
57693 int val2 ;
57694 int ecode2 = 0 ;
57695 PyObject * obj0 = 0 ;
57696 PyObject * obj1 = 0 ;
57697 char * kwnames[] = {
57698 (char *) "self",(char *) "m", NULL
57699 };
57700
57701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
57702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57703 if (!SWIG_IsOK(res1)) {
57704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57705 }
57706 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57707 ecode2 = SWIG_AsVal_int(obj1, &val2);
57708 if (!SWIG_IsOK(ecode2)) {
57709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
57710 }
57711 arg2 = static_cast< int >(val2);
57712 {
57713 PyThreadState* __tstate = wxPyBeginAllowThreads();
57714 (arg1)->SetMargin(arg2);
57715 wxPyEndAllowThreads(__tstate);
57716 if (PyErr_Occurred()) SWIG_fail;
57717 }
57718 resultobj = SWIG_Py_Void();
57719 return resultobj;
57720 fail:
57721 return NULL;
57722 }
57723
57724
57725 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57726 PyObject *resultobj = 0;
57727 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57728 int result;
57729 void *argp1 = 0 ;
57730 int res1 = 0 ;
57731 PyObject *swig_obj[1] ;
57732
57733 if (!args) SWIG_fail;
57734 swig_obj[0] = args;
57735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57736 if (!SWIG_IsOK(res1)) {
57737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57738 }
57739 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57740 {
57741 PyThreadState* __tstate = wxPyBeginAllowThreads();
57742 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
57743 wxPyEndAllowThreads(__tstate);
57744 if (PyErr_Occurred()) SWIG_fail;
57745 }
57746 resultobj = SWIG_From_int(static_cast< int >(result));
57747 return resultobj;
57748 fail:
57749 return NULL;
57750 }
57751
57752
57753 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57754 PyObject *resultobj = 0;
57755 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57756 int result;
57757 void *argp1 = 0 ;
57758 int res1 = 0 ;
57759 PyObject *swig_obj[1] ;
57760
57761 if (!args) SWIG_fail;
57762 swig_obj[0] = args;
57763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57764 if (!SWIG_IsOK(res1)) {
57765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57766 }
57767 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57768 {
57769 PyThreadState* __tstate = wxPyBeginAllowThreads();
57770 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
57771 wxPyEndAllowThreads(__tstate);
57772 if (PyErr_Occurred()) SWIG_fail;
57773 }
57774 resultobj = SWIG_From_int(static_cast< int >(result));
57775 return resultobj;
57776 fail:
57777 return NULL;
57778 }
57779
57780
57781 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57782 PyObject *resultobj = 0;
57783 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57784 int result;
57785 void *argp1 = 0 ;
57786 int res1 = 0 ;
57787 PyObject *swig_obj[1] ;
57788
57789 if (!args) SWIG_fail;
57790 swig_obj[0] = args;
57791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57792 if (!SWIG_IsOK(res1)) {
57793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57794 }
57795 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57796 {
57797 PyThreadState* __tstate = wxPyBeginAllowThreads();
57798 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
57799 wxPyEndAllowThreads(__tstate);
57800 if (PyErr_Occurred()) SWIG_fail;
57801 }
57802 resultobj = SWIG_From_int(static_cast< int >(result));
57803 return resultobj;
57804 fail:
57805 return NULL;
57806 }
57807
57808
57809 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57810 PyObject *resultobj = 0;
57811 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57812 bool result;
57813 void *argp1 = 0 ;
57814 int res1 = 0 ;
57815 PyObject *swig_obj[1] ;
57816
57817 if (!args) SWIG_fail;
57818 swig_obj[0] = args;
57819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57820 if (!SWIG_IsOK(res1)) {
57821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57822 }
57823 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57824 {
57825 PyThreadState* __tstate = wxPyBeginAllowThreads();
57826 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
57827 wxPyEndAllowThreads(__tstate);
57828 if (PyErr_Occurred()) SWIG_fail;
57829 }
57830 {
57831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57832 }
57833 return resultobj;
57834 fail:
57835 return NULL;
57836 }
57837
57838
57839 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57840 PyObject *resultobj = 0;
57841 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57842 bool arg2 ;
57843 void *argp1 = 0 ;
57844 int res1 = 0 ;
57845 bool val2 ;
57846 int ecode2 = 0 ;
57847 PyObject * obj0 = 0 ;
57848 PyObject * obj1 = 0 ;
57849 char * kwnames[] = {
57850 (char *) "self",(char *) "d", NULL
57851 };
57852
57853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
57854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57855 if (!SWIG_IsOK(res1)) {
57856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57857 }
57858 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57859 ecode2 = SWIG_AsVal_bool(obj1, &val2);
57860 if (!SWIG_IsOK(ecode2)) {
57861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
57862 }
57863 arg2 = static_cast< bool >(val2);
57864 {
57865 PyThreadState* __tstate = wxPyBeginAllowThreads();
57866 (arg1)->SetDone(arg2);
57867 wxPyEndAllowThreads(__tstate);
57868 if (PyErr_Occurred()) SWIG_fail;
57869 }
57870 resultobj = SWIG_Py_Void();
57871 return resultobj;
57872 fail:
57873 return NULL;
57874 }
57875
57876
57877 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57878 PyObject *resultobj = 0;
57879 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57880 wxRelationship result;
57881 void *argp1 = 0 ;
57882 int res1 = 0 ;
57883 PyObject *swig_obj[1] ;
57884
57885 if (!args) SWIG_fail;
57886 swig_obj[0] = args;
57887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57888 if (!SWIG_IsOK(res1)) {
57889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57890 }
57891 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57892 {
57893 PyThreadState* __tstate = wxPyBeginAllowThreads();
57894 result = (wxRelationship)(arg1)->GetRelationship();
57895 wxPyEndAllowThreads(__tstate);
57896 if (PyErr_Occurred()) SWIG_fail;
57897 }
57898 resultobj = SWIG_From_int(static_cast< int >(result));
57899 return resultobj;
57900 fail:
57901 return NULL;
57902 }
57903
57904
57905 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57906 PyObject *resultobj = 0;
57907 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57908 wxRelationship arg2 ;
57909 void *argp1 = 0 ;
57910 int res1 = 0 ;
57911 int val2 ;
57912 int ecode2 = 0 ;
57913 PyObject * obj0 = 0 ;
57914 PyObject * obj1 = 0 ;
57915 char * kwnames[] = {
57916 (char *) "self",(char *) "r", NULL
57917 };
57918
57919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
57920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57921 if (!SWIG_IsOK(res1)) {
57922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57923 }
57924 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57925 ecode2 = SWIG_AsVal_int(obj1, &val2);
57926 if (!SWIG_IsOK(ecode2)) {
57927 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
57928 }
57929 arg2 = static_cast< wxRelationship >(val2);
57930 {
57931 PyThreadState* __tstate = wxPyBeginAllowThreads();
57932 (arg1)->SetRelationship(arg2);
57933 wxPyEndAllowThreads(__tstate);
57934 if (PyErr_Occurred()) SWIG_fail;
57935 }
57936 resultobj = SWIG_Py_Void();
57937 return resultobj;
57938 fail:
57939 return NULL;
57940 }
57941
57942
57943 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57944 PyObject *resultobj = 0;
57945 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57946 wxWindow *arg2 = (wxWindow *) 0 ;
57947 bool result;
57948 void *argp1 = 0 ;
57949 int res1 = 0 ;
57950 void *argp2 = 0 ;
57951 int res2 = 0 ;
57952 PyObject * obj0 = 0 ;
57953 PyObject * obj1 = 0 ;
57954 char * kwnames[] = {
57955 (char *) "self",(char *) "otherW", NULL
57956 };
57957
57958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
57959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57960 if (!SWIG_IsOK(res1)) {
57961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57962 }
57963 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57964 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57965 if (!SWIG_IsOK(res2)) {
57966 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
57967 }
57968 arg2 = reinterpret_cast< wxWindow * >(argp2);
57969 {
57970 PyThreadState* __tstate = wxPyBeginAllowThreads();
57971 result = (bool)(arg1)->ResetIfWin(arg2);
57972 wxPyEndAllowThreads(__tstate);
57973 if (PyErr_Occurred()) SWIG_fail;
57974 }
57975 {
57976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57977 }
57978 return resultobj;
57979 fail:
57980 return NULL;
57981 }
57982
57983
57984 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57985 PyObject *resultobj = 0;
57986 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57987 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
57988 wxWindow *arg3 = (wxWindow *) 0 ;
57989 bool result;
57990 void *argp1 = 0 ;
57991 int res1 = 0 ;
57992 void *argp2 = 0 ;
57993 int res2 = 0 ;
57994 void *argp3 = 0 ;
57995 int res3 = 0 ;
57996 PyObject * obj0 = 0 ;
57997 PyObject * obj1 = 0 ;
57998 PyObject * obj2 = 0 ;
57999 char * kwnames[] = {
58000 (char *) "self",(char *) "constraints",(char *) "win", NULL
58001 };
58002
58003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
58004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58005 if (!SWIG_IsOK(res1)) {
58006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
58007 }
58008 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
58009 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58010 if (!SWIG_IsOK(res2)) {
58011 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
58012 }
58013 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
58014 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
58015 if (!SWIG_IsOK(res3)) {
58016 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
58017 }
58018 arg3 = reinterpret_cast< wxWindow * >(argp3);
58019 {
58020 PyThreadState* __tstate = wxPyBeginAllowThreads();
58021 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
58022 wxPyEndAllowThreads(__tstate);
58023 if (PyErr_Occurred()) SWIG_fail;
58024 }
58025 {
58026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
58027 }
58028 return resultobj;
58029 fail:
58030 return NULL;
58031 }
58032
58033
58034 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
58035 PyObject *resultobj = 0;
58036 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
58037 wxEdge arg2 ;
58038 wxWindow *arg3 = (wxWindow *) 0 ;
58039 wxWindow *arg4 = (wxWindow *) 0 ;
58040 int result;
58041 void *argp1 = 0 ;
58042 int res1 = 0 ;
58043 int val2 ;
58044 int ecode2 = 0 ;
58045 void *argp3 = 0 ;
58046 int res3 = 0 ;
58047 void *argp4 = 0 ;
58048 int res4 = 0 ;
58049 PyObject * obj0 = 0 ;
58050 PyObject * obj1 = 0 ;
58051 PyObject * obj2 = 0 ;
58052 PyObject * obj3 = 0 ;
58053 char * kwnames[] = {
58054 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
58055 };
58056
58057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
58058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58059 if (!SWIG_IsOK(res1)) {
58060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
58061 }
58062 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
58063 ecode2 = SWIG_AsVal_int(obj1, &val2);
58064 if (!SWIG_IsOK(ecode2)) {
58065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
58066 }
58067 arg2 = static_cast< wxEdge >(val2);
58068 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
58069 if (!SWIG_IsOK(res3)) {
58070 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
58071 }
58072 arg3 = reinterpret_cast< wxWindow * >(argp3);
58073 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
58074 if (!SWIG_IsOK(res4)) {
58075 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
58076 }
58077 arg4 = reinterpret_cast< wxWindow * >(argp4);
58078 {
58079 PyThreadState* __tstate = wxPyBeginAllowThreads();
58080 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
58081 wxPyEndAllowThreads(__tstate);
58082 if (PyErr_Occurred()) SWIG_fail;
58083 }
58084 resultobj = SWIG_From_int(static_cast< int >(result));
58085 return resultobj;
58086 fail:
58087 return NULL;
58088 }
58089
58090
58091 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58092 PyObject *obj;
58093 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
58094 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
58095 return SWIG_Py_Void();
58096 }
58097
58098 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58099 PyObject *resultobj = 0;
58100 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58101 wxIndividualLayoutConstraint *result = 0 ;
58102 void *argp1 = 0 ;
58103 int res1 = 0 ;
58104 PyObject *swig_obj[1] ;
58105
58106 if (!args) SWIG_fail;
58107 swig_obj[0] = args;
58108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58109 if (!SWIG_IsOK(res1)) {
58110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58111 }
58112 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58113 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
58114 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58115 return resultobj;
58116 fail:
58117 return NULL;
58118 }
58119
58120
58121 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58122 PyObject *resultobj = 0;
58123 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58124 wxIndividualLayoutConstraint *result = 0 ;
58125 void *argp1 = 0 ;
58126 int res1 = 0 ;
58127 PyObject *swig_obj[1] ;
58128
58129 if (!args) SWIG_fail;
58130 swig_obj[0] = args;
58131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58132 if (!SWIG_IsOK(res1)) {
58133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58134 }
58135 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58136 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
58137 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58138 return resultobj;
58139 fail:
58140 return NULL;
58141 }
58142
58143
58144 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58145 PyObject *resultobj = 0;
58146 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58147 wxIndividualLayoutConstraint *result = 0 ;
58148 void *argp1 = 0 ;
58149 int res1 = 0 ;
58150 PyObject *swig_obj[1] ;
58151
58152 if (!args) SWIG_fail;
58153 swig_obj[0] = args;
58154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58155 if (!SWIG_IsOK(res1)) {
58156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58157 }
58158 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58159 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
58160 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58161 return resultobj;
58162 fail:
58163 return NULL;
58164 }
58165
58166
58167 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58168 PyObject *resultobj = 0;
58169 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58170 wxIndividualLayoutConstraint *result = 0 ;
58171 void *argp1 = 0 ;
58172 int res1 = 0 ;
58173 PyObject *swig_obj[1] ;
58174
58175 if (!args) SWIG_fail;
58176 swig_obj[0] = args;
58177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58178 if (!SWIG_IsOK(res1)) {
58179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58180 }
58181 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58182 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
58183 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58184 return resultobj;
58185 fail:
58186 return NULL;
58187 }
58188
58189
58190 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58191 PyObject *resultobj = 0;
58192 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58193 wxIndividualLayoutConstraint *result = 0 ;
58194 void *argp1 = 0 ;
58195 int res1 = 0 ;
58196 PyObject *swig_obj[1] ;
58197
58198 if (!args) SWIG_fail;
58199 swig_obj[0] = args;
58200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58201 if (!SWIG_IsOK(res1)) {
58202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58203 }
58204 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58205 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
58206 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58207 return resultobj;
58208 fail:
58209 return NULL;
58210 }
58211
58212
58213 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58214 PyObject *resultobj = 0;
58215 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58216 wxIndividualLayoutConstraint *result = 0 ;
58217 void *argp1 = 0 ;
58218 int res1 = 0 ;
58219 PyObject *swig_obj[1] ;
58220
58221 if (!args) SWIG_fail;
58222 swig_obj[0] = args;
58223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58224 if (!SWIG_IsOK(res1)) {
58225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58226 }
58227 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58228 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
58229 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58230 return resultobj;
58231 fail:
58232 return NULL;
58233 }
58234
58235
58236 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58237 PyObject *resultobj = 0;
58238 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58239 wxIndividualLayoutConstraint *result = 0 ;
58240 void *argp1 = 0 ;
58241 int res1 = 0 ;
58242 PyObject *swig_obj[1] ;
58243
58244 if (!args) SWIG_fail;
58245 swig_obj[0] = args;
58246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58247 if (!SWIG_IsOK(res1)) {
58248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58249 }
58250 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58251 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
58252 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58253 return resultobj;
58254 fail:
58255 return NULL;
58256 }
58257
58258
58259 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58260 PyObject *resultobj = 0;
58261 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58262 wxIndividualLayoutConstraint *result = 0 ;
58263 void *argp1 = 0 ;
58264 int res1 = 0 ;
58265 PyObject *swig_obj[1] ;
58266
58267 if (!args) SWIG_fail;
58268 swig_obj[0] = args;
58269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58270 if (!SWIG_IsOK(res1)) {
58271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58272 }
58273 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58274 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
58275 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58276 return resultobj;
58277 fail:
58278 return NULL;
58279 }
58280
58281
58282 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58283 PyObject *resultobj = 0;
58284 wxLayoutConstraints *result = 0 ;
58285
58286 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
58287 {
58288 PyThreadState* __tstate = wxPyBeginAllowThreads();
58289 result = (wxLayoutConstraints *)new wxLayoutConstraints();
58290 wxPyEndAllowThreads(__tstate);
58291 if (PyErr_Occurred()) SWIG_fail;
58292 }
58293 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
58294 return resultobj;
58295 fail:
58296 return NULL;
58297 }
58298
58299
58300 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58301 PyObject *resultobj = 0;
58302 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58303 void *argp1 = 0 ;
58304 int res1 = 0 ;
58305 PyObject *swig_obj[1] ;
58306
58307 if (!args) SWIG_fail;
58308 swig_obj[0] = args;
58309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
58310 if (!SWIG_IsOK(res1)) {
58311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58312 }
58313 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58314 {
58315 PyThreadState* __tstate = wxPyBeginAllowThreads();
58316 delete arg1;
58317
58318 wxPyEndAllowThreads(__tstate);
58319 if (PyErr_Occurred()) SWIG_fail;
58320 }
58321 resultobj = SWIG_Py_Void();
58322 return resultobj;
58323 fail:
58324 return NULL;
58325 }
58326
58327
58328 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
58329 PyObject *resultobj = 0;
58330 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58331 wxWindow *arg2 = (wxWindow *) 0 ;
58332 int *arg3 = (int *) 0 ;
58333 bool result;
58334 void *argp1 = 0 ;
58335 int res1 = 0 ;
58336 void *argp2 = 0 ;
58337 int res2 = 0 ;
58338 int temp3 ;
58339 int res3 = SWIG_TMPOBJ ;
58340 PyObject * obj0 = 0 ;
58341 PyObject * obj1 = 0 ;
58342 char * kwnames[] = {
58343 (char *) "self",(char *) "win", NULL
58344 };
58345
58346 arg3 = &temp3;
58347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
58348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58349 if (!SWIG_IsOK(res1)) {
58350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58351 }
58352 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58353 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
58354 if (!SWIG_IsOK(res2)) {
58355 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
58356 }
58357 arg2 = reinterpret_cast< wxWindow * >(argp2);
58358 {
58359 PyThreadState* __tstate = wxPyBeginAllowThreads();
58360 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
58361 wxPyEndAllowThreads(__tstate);
58362 if (PyErr_Occurred()) SWIG_fail;
58363 }
58364 {
58365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
58366 }
58367 if (SWIG_IsTmpObj(res3)) {
58368 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
58369 } else {
58370 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
58371 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
58372 }
58373 return resultobj;
58374 fail:
58375 return NULL;
58376 }
58377
58378
58379 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58380 PyObject *resultobj = 0;
58381 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58382 bool result;
58383 void *argp1 = 0 ;
58384 int res1 = 0 ;
58385 PyObject *swig_obj[1] ;
58386
58387 if (!args) SWIG_fail;
58388 swig_obj[0] = args;
58389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58390 if (!SWIG_IsOK(res1)) {
58391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
58392 }
58393 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58394 {
58395 PyThreadState* __tstate = wxPyBeginAllowThreads();
58396 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
58397 wxPyEndAllowThreads(__tstate);
58398 if (PyErr_Occurred()) SWIG_fail;
58399 }
58400 {
58401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
58402 }
58403 return resultobj;
58404 fail:
58405 return NULL;
58406 }
58407
58408
58409 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58410 PyObject *obj;
58411 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
58412 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
58413 return SWIG_Py_Void();
58414 }
58415
58416 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58417 return SWIG_Python_InitShadowInstance(args);
58418 }
58419
58420 static PyMethodDef SwigMethods[] = {
58421 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
58422 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
58423 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
58424 { (char *)"Object_IsSameAs", (PyCFunction) _wrap_Object_IsSameAs, METH_VARARGS | METH_KEYWORDS, NULL},
58425 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
58426 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
58427 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
58428 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
58429 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
58430 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
58431 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
58432 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58433 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58434 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
58435 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
58436 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
58437 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
58438 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
58439 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
58440 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
58441 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58442 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
58443 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
58444 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
58445 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
58446 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
58447 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
58448 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
58449 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
58450 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
58451 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
58452 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
58453 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
58454 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
58455 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
58456 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
58457 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58458 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58459 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
58460 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
58461 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58462 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
58463 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
58464 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
58465 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
58466 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
58467 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
58468 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
58469 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
58470 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
58471 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58472 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58473 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
58474 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
58475 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
58476 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
58477 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58478 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
58479 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
58480 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
58481 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
58482 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
58483 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
58484 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
58485 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
58486 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
58487 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
58488 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
58489 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
58490 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
58491 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
58492 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
58493 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
58494 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
58495 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58496 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
58497 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
58498 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
58499 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
58500 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
58501 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
58502 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
58503 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
58504 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
58505 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
58506 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
58507 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
58508 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
58509 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
58510 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
58511 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
58512 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
58513 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
58514 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
58515 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
58516 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
58517 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
58518 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
58519 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
58520 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
58521 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
58522 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
58523 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58524 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58525 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
58526 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
58527 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
58528 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
58529 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
58530 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
58531 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
58532 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
58533 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
58534 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
58535 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
58536 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
58537 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
58538 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58539 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
58540 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
58541 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
58542 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
58543 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
58544 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
58545 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
58546 { (char *)"delete_Point2D", (PyCFunction)_wrap_delete_Point2D, METH_O, NULL},
58547 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
58548 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
58549 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
58550 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
58551 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
58552 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
58553 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
58554 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
58555 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
58556 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
58557 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
58558 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
58559 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
58560 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
58561 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
58562 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58563 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58564 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
58565 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
58566 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
58567 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
58568 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58569 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
58570 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
58571 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
58572 { (char *)"new_Rect2D", (PyCFunction) _wrap_new_Rect2D, METH_VARARGS | METH_KEYWORDS, NULL},
58573 { (char *)"delete_Rect2D", (PyCFunction)_wrap_delete_Rect2D, METH_O, NULL},
58574 { (char *)"Rect2D_GetPosition", (PyCFunction)_wrap_Rect2D_GetPosition, METH_O, NULL},
58575 { (char *)"Rect2D_GetSize", (PyCFunction)_wrap_Rect2D_GetSize, METH_O, NULL},
58576 { (char *)"Rect2D_GetLeft", (PyCFunction)_wrap_Rect2D_GetLeft, METH_O, NULL},
58577 { (char *)"Rect2D_SetLeft", (PyCFunction) _wrap_Rect2D_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
58578 { (char *)"Rect2D_MoveLeftTo", (PyCFunction) _wrap_Rect2D_MoveLeftTo, METH_VARARGS | METH_KEYWORDS, NULL},
58579 { (char *)"Rect2D_GetTop", (PyCFunction)_wrap_Rect2D_GetTop, METH_O, NULL},
58580 { (char *)"Rect2D_SetTop", (PyCFunction) _wrap_Rect2D_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
58581 { (char *)"Rect2D_MoveTopTo", (PyCFunction) _wrap_Rect2D_MoveTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
58582 { (char *)"Rect2D_GetBottom", (PyCFunction)_wrap_Rect2D_GetBottom, METH_O, NULL},
58583 { (char *)"Rect2D_SetBottom", (PyCFunction) _wrap_Rect2D_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
58584 { (char *)"Rect2D_MoveBottomTo", (PyCFunction) _wrap_Rect2D_MoveBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
58585 { (char *)"Rect2D_GetRight", (PyCFunction)_wrap_Rect2D_GetRight, METH_O, NULL},
58586 { (char *)"Rect2D_SetRight", (PyCFunction) _wrap_Rect2D_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
58587 { (char *)"Rect2D_MoveRightTo", (PyCFunction) _wrap_Rect2D_MoveRightTo, METH_VARARGS | METH_KEYWORDS, NULL},
58588 { (char *)"Rect2D_GetLeftTop", (PyCFunction)_wrap_Rect2D_GetLeftTop, METH_O, NULL},
58589 { (char *)"Rect2D_SetLeftTop", (PyCFunction) _wrap_Rect2D_SetLeftTop, METH_VARARGS | METH_KEYWORDS, NULL},
58590 { (char *)"Rect2D_MoveLeftTopTo", (PyCFunction) _wrap_Rect2D_MoveLeftTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
58591 { (char *)"Rect2D_GetLeftBottom", (PyCFunction)_wrap_Rect2D_GetLeftBottom, METH_O, NULL},
58592 { (char *)"Rect2D_SetLeftBottom", (PyCFunction) _wrap_Rect2D_SetLeftBottom, METH_VARARGS | METH_KEYWORDS, NULL},
58593 { (char *)"Rect2D_MoveLeftBottomTo", (PyCFunction) _wrap_Rect2D_MoveLeftBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
58594 { (char *)"Rect2D_GetRightTop", (PyCFunction)_wrap_Rect2D_GetRightTop, METH_O, NULL},
58595 { (char *)"Rect2D_SetRightTop", (PyCFunction) _wrap_Rect2D_SetRightTop, METH_VARARGS | METH_KEYWORDS, NULL},
58596 { (char *)"Rect2D_MoveRightTopTo", (PyCFunction) _wrap_Rect2D_MoveRightTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
58597 { (char *)"Rect2D_GetRightBottom", (PyCFunction)_wrap_Rect2D_GetRightBottom, METH_O, NULL},
58598 { (char *)"Rect2D_SetRightBottom", (PyCFunction) _wrap_Rect2D_SetRightBottom, METH_VARARGS | METH_KEYWORDS, NULL},
58599 { (char *)"Rect2D_MoveRightBottomTo", (PyCFunction) _wrap_Rect2D_MoveRightBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
58600 { (char *)"Rect2D_GetCentre", (PyCFunction)_wrap_Rect2D_GetCentre, METH_O, NULL},
58601 { (char *)"Rect2D_SetCentre", (PyCFunction) _wrap_Rect2D_SetCentre, METH_VARARGS | METH_KEYWORDS, NULL},
58602 { (char *)"Rect2D_MoveCentreTo", (PyCFunction) _wrap_Rect2D_MoveCentreTo, METH_VARARGS | METH_KEYWORDS, NULL},
58603 { (char *)"Rect2D_GetOutcode", (PyCFunction) _wrap_Rect2D_GetOutcode, METH_VARARGS | METH_KEYWORDS, NULL},
58604 { (char *)"Rect2D_Contains", (PyCFunction) _wrap_Rect2D_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
58605 { (char *)"Rect2D_ContainsRect", (PyCFunction) _wrap_Rect2D_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
58606 { (char *)"Rect2D_IsEmpty", (PyCFunction)_wrap_Rect2D_IsEmpty, METH_O, NULL},
58607 { (char *)"Rect2D_HaveEqualSize", (PyCFunction) _wrap_Rect2D_HaveEqualSize, METH_VARARGS | METH_KEYWORDS, NULL},
58608 { (char *)"Rect2D_Inset", _wrap_Rect2D_Inset, METH_VARARGS, NULL},
58609 { (char *)"Rect2D_Offset", (PyCFunction) _wrap_Rect2D_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
58610 { (char *)"Rect2D_ConstrainTo", (PyCFunction) _wrap_Rect2D_ConstrainTo, METH_VARARGS | METH_KEYWORDS, NULL},
58611 { (char *)"Rect2D_Interpolate", (PyCFunction) _wrap_Rect2D_Interpolate, METH_VARARGS | METH_KEYWORDS, NULL},
58612 { (char *)"Rect2D_Intersect", (PyCFunction) _wrap_Rect2D_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
58613 { (char *)"Rect2D_CreateIntersection", (PyCFunction) _wrap_Rect2D_CreateIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
58614 { (char *)"Rect2D_Intersects", (PyCFunction) _wrap_Rect2D_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
58615 { (char *)"Rect2D_Union", (PyCFunction) _wrap_Rect2D_Union, METH_VARARGS | METH_KEYWORDS, NULL},
58616 { (char *)"Rect2D_CreateUnion", (PyCFunction) _wrap_Rect2D_CreateUnion, METH_VARARGS | METH_KEYWORDS, NULL},
58617 { (char *)"Rect2D_Scale", _wrap_Rect2D_Scale, METH_VARARGS, NULL},
58618 { (char *)"Rect2D___eq__", (PyCFunction) _wrap_Rect2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58619 { (char *)"Rect2D___ne__", (PyCFunction) _wrap_Rect2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58620 { (char *)"Rect2D_x_set", _wrap_Rect2D_x_set, METH_VARARGS, NULL},
58621 { (char *)"Rect2D_x_get", (PyCFunction)_wrap_Rect2D_x_get, METH_O, NULL},
58622 { (char *)"Rect2D_y_set", _wrap_Rect2D_y_set, METH_VARARGS, NULL},
58623 { (char *)"Rect2D_y_get", (PyCFunction)_wrap_Rect2D_y_get, METH_O, NULL},
58624 { (char *)"Rect2D_width_set", _wrap_Rect2D_width_set, METH_VARARGS, NULL},
58625 { (char *)"Rect2D_width_get", (PyCFunction)_wrap_Rect2D_width_get, METH_O, NULL},
58626 { (char *)"Rect2D_height_set", _wrap_Rect2D_height_set, METH_VARARGS, NULL},
58627 { (char *)"Rect2D_height_get", (PyCFunction)_wrap_Rect2D_height_get, METH_O, NULL},
58628 { (char *)"Rect2D_Set", (PyCFunction) _wrap_Rect2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58629 { (char *)"Rect2D_Get", (PyCFunction)_wrap_Rect2D_Get, METH_O, NULL},
58630 { (char *)"Rect2D_swigregister", Rect2D_swigregister, METH_VARARGS, NULL},
58631 { (char *)"Rect2D_swiginit", Rect2D_swiginit, METH_VARARGS, NULL},
58632 { (char *)"new_Position", (PyCFunction) _wrap_new_Position, METH_VARARGS | METH_KEYWORDS, NULL},
58633 { (char *)"delete_Position", (PyCFunction)_wrap_delete_Position, METH_O, NULL},
58634 { (char *)"Position_GetRow", (PyCFunction)_wrap_Position_GetRow, METH_O, NULL},
58635 { (char *)"Position_GetColumn", (PyCFunction)_wrap_Position_GetColumn, METH_O, NULL},
58636 { (char *)"Position_GetCol", (PyCFunction)_wrap_Position_GetCol, METH_O, NULL},
58637 { (char *)"Position_SetRow", (PyCFunction) _wrap_Position_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
58638 { (char *)"Position_SetColumn", (PyCFunction) _wrap_Position_SetColumn, METH_VARARGS | METH_KEYWORDS, NULL},
58639 { (char *)"Position_SetCol", (PyCFunction) _wrap_Position_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
58640 { (char *)"Position___eq__", (PyCFunction) _wrap_Position___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58641 { (char *)"Position___ne__", (PyCFunction) _wrap_Position___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58642 { (char *)"Position___add__", _wrap_Position___add__, METH_VARARGS, NULL},
58643 { (char *)"Position___sub__", _wrap_Position___sub__, METH_VARARGS, NULL},
58644 { (char *)"Position_swigregister", Position_swigregister, METH_VARARGS, NULL},
58645 { (char *)"Position_swiginit", Position_swiginit, METH_VARARGS, NULL},
58646 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
58647 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
58648 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
58649 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
58650 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
58651 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
58652 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
58653 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
58654 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
58655 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
58656 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
58657 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
58658 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
58659 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
58660 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
58661 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
58662 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
58663 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
58664 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
58665 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
58666 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
58667 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
58668 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
58669 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
58670 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
58671 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
58672 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
58673 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
58674 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
58675 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
58676 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
58677 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
58678 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
58679 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
58680 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
58681 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
58682 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
58683 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
58684 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58685 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
58686 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
58687 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
58688 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
58689 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
58690 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
58691 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
58692 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
58693 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
58694 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
58695 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
58696 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
58697 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
58698 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58699 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
58700 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
58701 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58702 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58703 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
58704 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
58705 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
58706 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
58707 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
58708 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
58709 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
58710 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58711 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
58712 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
58713 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
58714 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
58715 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58716 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
58717 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
58718 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
58719 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
58720 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
58721 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58722 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
58723 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
58724 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
58725 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
58726 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58727 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
58728 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
58729 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
58730 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
58731 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
58732 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
58733 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
58734 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
58735 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
58736 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
58737 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
58738 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
58739 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
58740 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
58741 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
58742 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
58743 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
58744 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
58745 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
58746 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
58747 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
58748 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
58749 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
58750 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
58751 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
58752 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
58753 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
58754 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
58755 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
58756 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
58757 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
58758 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
58759 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
58760 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
58761 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
58762 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
58763 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
58764 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
58765 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
58766 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
58767 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
58768 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
58769 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
58770 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
58771 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
58772 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
58773 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
58774 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
58775 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
58776 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
58777 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
58778 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58779 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
58780 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58781 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
58782 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
58783 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
58784 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
58785 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
58786 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
58787 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
58788 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
58789 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
58790 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
58791 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
58792 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
58793 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
58794 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
58795 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
58796 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
58797 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58798 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58799 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
58800 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
58801 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
58802 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
58803 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
58804 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58805 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
58806 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
58807 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
58808 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
58809 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
58810 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
58811 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
58812 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
58813 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
58814 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
58815 { (char *)"Image_IsOk", (PyCFunction)_wrap_Image_IsOk, METH_O, NULL},
58816 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
58817 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
58818 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
58819 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
58820 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
58821 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
58822 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
58823 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
58824 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
58825 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
58826 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
58827 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
58828 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
58829 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
58830 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
58831 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
58832 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
58833 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
58834 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
58835 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
58836 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
58837 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
58838 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
58839 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
58840 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
58841 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
58842 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
58843 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
58844 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
58845 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
58846 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
58847 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
58848 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
58849 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
58850 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
58851 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58852 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58853 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58854 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
58855 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
58856 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58857 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58858 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
58859 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
58860 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
58861 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
58862 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
58863 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
58864 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
58865 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
58866 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
58867 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
58868 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
58869 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
58870 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
58871 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
58872 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
58873 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
58874 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
58875 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
58876 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
58877 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
58878 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
58879 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
58880 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
58881 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
58882 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
58883 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
58884 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
58885 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
58886 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
58887 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
58888 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
58889 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
58890 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
58891 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
58892 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
58893 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
58894 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
58895 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
58896 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
58897 { (char *)"new_TGAHandler", (PyCFunction)_wrap_new_TGAHandler, METH_NOARGS, NULL},
58898 { (char *)"TGAHandler_swigregister", TGAHandler_swigregister, METH_VARARGS, NULL},
58899 { (char *)"TGAHandler_swiginit", TGAHandler_swiginit, METH_VARARGS, NULL},
58900 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
58901 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
58902 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
58903 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
58904 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
58905 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58906 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58907 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
58908 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
58909 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58910 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58911 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
58912 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
58913 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
58914 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
58915 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
58916 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
58917 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
58918 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
58919 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
58920 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
58921 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
58922 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
58923 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
58924 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
58925 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
58926 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
58927 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
58928 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
58929 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
58930 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
58931 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
58932 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
58933 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
58934 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
58935 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
58936 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
58937 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
58938 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
58939 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
58940 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
58941 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
58942 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
58943 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58944 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
58945 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
58946 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
58947 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
58948 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
58949 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
58950 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
58951 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
58952 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
58953 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
58954 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
58955 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
58956 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
58957 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
58958 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58959 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
58960 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
58961 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
58962 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
58963 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
58964 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58965 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
58966 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
58967 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
58968 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58969 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
58970 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
58971 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58972 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
58973 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
58974 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
58975 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58976 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
58977 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
58978 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58979 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
58980 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
58981 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
58982 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
58983 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
58984 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
58985 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
58986 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
58987 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
58988 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
58989 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
58990 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
58991 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
58992 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
58993 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
58994 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
58995 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
58996 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
58997 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
58998 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
58999 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
59000 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
59001 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
59002 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
59003 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
59004 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
59005 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
59006 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
59007 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
59008 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
59009 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59010 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
59011 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
59012 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
59013 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
59014 { (char *)"MouseEvent_GetWheelAxis", (PyCFunction)_wrap_MouseEvent_GetWheelAxis, METH_O, NULL},
59015 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
59016 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
59017 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
59018 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
59019 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
59020 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
59021 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
59022 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
59023 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
59024 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
59025 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
59026 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
59027 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
59028 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
59029 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
59030 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
59031 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
59032 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
59033 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
59034 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
59035 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
59036 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
59037 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
59038 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
59039 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
59040 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
59041 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
59042 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
59043 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59044 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
59045 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
59046 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
59047 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
59048 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
59049 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
59050 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
59051 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59052 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
59053 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
59054 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
59055 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
59056 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
59057 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
59058 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
59059 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
59060 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
59061 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
59062 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
59063 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
59064 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
59065 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
59066 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
59067 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
59068 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
59069 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
59070 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
59071 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
59072 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
59073 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
59074 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
59075 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
59076 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
59077 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
59078 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
59079 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
59080 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
59081 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
59082 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
59083 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
59084 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
59085 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
59086 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
59087 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
59088 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
59089 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
59090 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59091 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
59092 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
59093 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
59094 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
59095 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
59096 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
59097 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
59098 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
59099 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
59100 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
59101 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59102 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
59103 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
59104 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
59105 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59106 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
59107 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
59108 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59109 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
59110 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
59111 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59112 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
59113 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
59114 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59115 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
59116 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
59117 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
59118 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59119 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
59120 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59121 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
59122 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
59123 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59124 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
59125 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
59126 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
59127 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59128 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
59129 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
59130 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
59131 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59132 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
59133 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
59134 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59135 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
59136 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
59137 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
59138 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
59139 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
59140 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59141 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
59142 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
59143 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
59144 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
59145 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
59146 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
59147 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
59148 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
59149 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59150 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
59151 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
59152 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
59153 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
59154 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59155 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
59156 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
59157 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
59158 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59159 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
59160 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
59161 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
59162 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
59163 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
59164 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
59165 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59166 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
59167 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
59168 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
59169 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
59170 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
59171 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
59172 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
59173 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
59174 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
59175 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
59176 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
59177 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
59178 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
59179 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
59180 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
59181 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
59182 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
59183 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
59184 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
59185 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
59186 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
59187 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
59188 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
59189 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59190 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
59191 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
59192 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
59193 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59194 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
59195 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
59196 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
59197 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
59198 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
59199 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59200 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59201 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
59202 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
59203 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
59204 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59205 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
59206 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
59207 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
59208 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
59209 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
59210 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
59211 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
59212 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
59213 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
59214 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
59215 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
59216 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
59217 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
59218 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
59219 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
59220 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
59221 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59222 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
59223 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
59224 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
59225 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59226 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
59227 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
59228 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
59229 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59230 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
59231 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59232 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
59233 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
59234 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
59235 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
59236 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
59237 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
59238 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
59239 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
59240 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
59241 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
59242 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59243 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
59244 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
59245 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59246 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
59247 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
59248 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
59249 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
59250 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
59251 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59252 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
59253 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
59254 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
59255 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
59256 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
59257 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59258 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
59259 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
59260 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
59261 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
59262 { (char *)"new_EventBlocker", (PyCFunction) _wrap_new_EventBlocker, METH_VARARGS | METH_KEYWORDS, NULL},
59263 { (char *)"delete_EventBlocker", (PyCFunction)_wrap_delete_EventBlocker, METH_O, NULL},
59264 { (char *)"EventBlocker_Block", (PyCFunction) _wrap_EventBlocker_Block, METH_VARARGS | METH_KEYWORDS, NULL},
59265 { (char *)"EventBlocker_swigregister", EventBlocker_swigregister, METH_VARARGS, NULL},
59266 { (char *)"EventBlocker_swiginit", EventBlocker_swiginit, METH_VARARGS, NULL},
59267 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
59268 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
59269 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
59270 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
59271 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
59272 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
59273 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
59274 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
59275 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
59276 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
59277 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
59278 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
59279 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
59280 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
59281 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
59282 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
59283 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
59284 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
59285 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
59286 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
59287 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
59288 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
59289 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
59290 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59291 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
59292 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
59293 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
59294 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
59295 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
59296 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
59297 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
59298 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
59299 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
59300 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
59301 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
59302 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
59303 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
59304 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
59305 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
59306 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
59307 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
59308 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
59309 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
59310 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
59311 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
59312 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
59313 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
59314 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
59315 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
59316 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
59317 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
59318 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
59319 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
59320 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59321 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
59322 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
59323 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
59324 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
59325 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
59326 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
59327 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
59328 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
59329 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
59330 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
59331 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
59332 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
59333 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
59334 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
59335 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
59336 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
59337 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
59338 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
59339 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
59340 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
59341 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
59342 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
59343 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
59344 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
59345 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
59346 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
59347 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
59348 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
59349 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
59350 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
59351 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
59352 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
59353 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
59354 { (char *)"AcceleratorTable_IsOk", (PyCFunction)_wrap_AcceleratorTable_IsOk, METH_O, NULL},
59355 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
59356 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
59357 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
59358 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
59359 { (char *)"VisualAttributes__get_font", (PyCFunction)_wrap_VisualAttributes__get_font, METH_O, NULL},
59360 { (char *)"VisualAttributes__get_colFg", (PyCFunction)_wrap_VisualAttributes__get_colFg, METH_O, NULL},
59361 { (char *)"VisualAttributes__get_colBg", (PyCFunction)_wrap_VisualAttributes__get_colBg, METH_O, NULL},
59362 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
59363 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
59364 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
59365 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
59366 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
59367 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
59368 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
59369 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
59370 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
59371 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59372 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
59373 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
59374 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
59375 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
59376 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
59377 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
59378 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
59379 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
59380 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
59381 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
59382 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
59383 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
59384 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
59385 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
59386 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
59387 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
59388 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
59389 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
59390 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
59391 { (char *)"Window_SetInitialSize", (PyCFunction) _wrap_Window_SetInitialSize, METH_VARARGS | METH_KEYWORDS, NULL},
59392 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
59393 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
59394 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
59395 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
59396 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
59397 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
59398 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
59399 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
59400 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
59401 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
59402 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
59403 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
59404 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
59405 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
59406 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
59407 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
59408 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
59409 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
59410 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
59411 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
59412 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
59413 { (char *)"Window_GetEffectiveMinSize", (PyCFunction)_wrap_Window_GetEffectiveMinSize, METH_O, NULL},
59414 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
59415 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
59416 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
59417 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
59418 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
59419 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
59420 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
59421 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
59422 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
59423 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
59424 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
59425 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
59426 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
59427 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
59428 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
59429 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
59430 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
59431 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
59432 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
59433 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
59434 { (char *)"Window_GetWindowBorderSize", (PyCFunction)_wrap_Window_GetWindowBorderSize, METH_O, NULL},
59435 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
59436 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
59437 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
59438 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
59439 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
59440 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
59441 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
59442 { (char *)"Window_IsThisEnabled", (PyCFunction)_wrap_Window_IsThisEnabled, METH_O, NULL},
59443 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
59444 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
59445 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
59446 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
59447 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
59448 { (char *)"Window_ToggleWindowStyle", (PyCFunction) _wrap_Window_ToggleWindowStyle, METH_VARARGS | METH_KEYWORDS, NULL},
59449 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
59450 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
59451 { (char *)"Window_HasExtraStyle", (PyCFunction) _wrap_Window_HasExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
59452 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
59453 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
59454 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
59455 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
59456 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
59457 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
59458 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
59459 { (char *)"Window_CanAcceptFocus", (PyCFunction)_wrap_Window_CanAcceptFocus, METH_O, NULL},
59460 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
59461 { (char *)"Window_CanAcceptFocusFromKeyboard", (PyCFunction)_wrap_Window_CanAcceptFocusFromKeyboard, METH_O, NULL},
59462 { (char *)"Window_SetCanFocus", (PyCFunction) _wrap_Window_SetCanFocus, METH_VARARGS | METH_KEYWORDS, NULL},
59463 { (char *)"Window_NavigateIn", (PyCFunction) _wrap_Window_NavigateIn, METH_VARARGS | METH_KEYWORDS, NULL},
59464 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
59465 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
59466 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
59467 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
59468 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
59469 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
59470 { (char *)"Window_GetTopLevelParent", (PyCFunction)_wrap_Window_GetTopLevelParent, METH_O, NULL},
59471 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
59472 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
59473 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
59474 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
59475 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
59476 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
59477 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
59478 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
59479 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
59480 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
59481 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
59482 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
59483 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
59484 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
59485 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
59486 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
59487 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
59488 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
59489 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
59490 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
59491 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
59492 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
59493 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
59494 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
59495 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
59496 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
59497 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
59498 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
59499 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
59500 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
59501 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
59502 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
59503 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
59504 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
59505 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
59506 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
59507 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
59508 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
59509 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
59510 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
59511 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
59512 { (char *)"Window_IsDoubleBuffered", (PyCFunction)_wrap_Window_IsDoubleBuffered, METH_O, NULL},
59513 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
59514 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
59515 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
59516 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
59517 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
59518 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
59519 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
59520 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
59521 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
59522 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
59523 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
59524 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
59525 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
59526 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
59527 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
59528 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
59529 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
59530 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
59531 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
59532 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
59533 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
59534 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
59535 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
59536 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
59537 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
59538 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
59539 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
59540 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
59541 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
59542 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
59543 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
59544 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
59545 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
59546 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
59547 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
59548 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
59549 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
59550 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
59551 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59552 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
59553 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
59554 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
59555 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
59556 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
59557 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
59558 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
59559 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
59560 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
59561 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
59562 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59563 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
59564 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
59565 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
59566 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
59567 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
59568 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
59569 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
59570 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
59571 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
59572 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
59573 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
59574 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
59575 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
59576 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
59577 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
59578 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
59579 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
59580 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
59581 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
59582 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
59583 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
59584 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59585 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
59586 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
59587 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59588 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
59589 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
59590 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
59591 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
59592 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
59593 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
59594 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
59595 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
59596 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
59597 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59598 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
59599 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
59600 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
59601 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
59602 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
59603 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
59604 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
59605 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
59606 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59607 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
59608 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
59609 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
59610 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
59611 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
59612 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
59613 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
59614 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
59615 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
59616 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
59617 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
59618 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
59619 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
59620 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59621 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59622 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
59623 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
59624 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
59625 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
59626 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
59627 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
59628 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
59629 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
59630 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59631 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
59632 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
59633 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
59634 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
59635 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59636 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
59637 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
59638 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
59639 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
59640 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
59641 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
59642 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
59643 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
59644 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
59645 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
59646 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
59647 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59648 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
59649 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
59650 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
59651 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
59652 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59653 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59654 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
59655 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
59656 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
59657 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
59658 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
59659 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
59660 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59661 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
59662 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
59663 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
59664 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
59665 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
59666 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
59667 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
59668 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
59669 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
59670 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
59671 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
59672 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
59673 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
59674 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
59675 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
59676 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59677 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
59678 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
59679 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
59680 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
59681 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
59682 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
59683 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
59684 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
59685 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59686 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
59687 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
59688 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
59689 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
59690 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59691 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59692 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
59693 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
59694 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
59695 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
59696 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
59697 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
59698 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
59699 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59700 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
59701 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
59702 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
59703 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
59704 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
59705 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
59706 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59707 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
59708 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
59709 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
59710 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
59711 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
59712 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
59713 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
59714 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
59715 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
59716 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
59717 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
59718 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
59719 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59720 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
59721 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
59722 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
59723 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
59724 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
59725 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
59726 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
59727 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
59728 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
59729 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
59730 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
59731 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
59732 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
59733 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
59734 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
59735 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
59736 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
59737 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
59738 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
59739 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
59740 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
59741 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
59742 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
59743 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
59744 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
59745 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
59746 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
59747 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
59748 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
59749 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
59750 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
59751 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
59752 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
59753 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
59754 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
59755 { (char *)"Control_RemoveMnemonics", (PyCFunction) _wrap_Control_RemoveMnemonics, METH_VARARGS | METH_KEYWORDS, NULL},
59756 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
59757 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
59758 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
59759 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
59760 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
59761 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
59762 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
59763 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
59764 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
59765 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
59766 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
59767 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
59768 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
59769 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
59770 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
59771 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
59772 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
59773 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
59774 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
59775 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
59776 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
59777 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
59778 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
59779 { (char *)"new_SizerFlags", (PyCFunction) _wrap_new_SizerFlags, METH_VARARGS | METH_KEYWORDS, NULL},
59780 { (char *)"delete_SizerFlags", (PyCFunction)_wrap_delete_SizerFlags, METH_O, NULL},
59781 { (char *)"SizerFlags_Proportion", (PyCFunction) _wrap_SizerFlags_Proportion, METH_VARARGS | METH_KEYWORDS, NULL},
59782 { (char *)"SizerFlags_Align", (PyCFunction) _wrap_SizerFlags_Align, METH_VARARGS | METH_KEYWORDS, NULL},
59783 { (char *)"SizerFlags_Expand", (PyCFunction)_wrap_SizerFlags_Expand, METH_O, NULL},
59784 { (char *)"SizerFlags_Centre", (PyCFunction)_wrap_SizerFlags_Centre, METH_O, NULL},
59785 { (char *)"SizerFlags_Center", (PyCFunction)_wrap_SizerFlags_Center, METH_O, NULL},
59786 { (char *)"SizerFlags_Left", (PyCFunction)_wrap_SizerFlags_Left, METH_O, NULL},
59787 { (char *)"SizerFlags_Right", (PyCFunction)_wrap_SizerFlags_Right, METH_O, NULL},
59788 { (char *)"SizerFlags_Top", (PyCFunction)_wrap_SizerFlags_Top, METH_O, NULL},
59789 { (char *)"SizerFlags_Bottom", (PyCFunction)_wrap_SizerFlags_Bottom, METH_O, NULL},
59790 { (char *)"SizerFlags_Shaped", (PyCFunction)_wrap_SizerFlags_Shaped, METH_O, NULL},
59791 { (char *)"SizerFlags_FixedMinSize", (PyCFunction)_wrap_SizerFlags_FixedMinSize, METH_O, NULL},
59792 { (char *)"SizerFlags_Border", (PyCFunction) _wrap_SizerFlags_Border, METH_VARARGS | METH_KEYWORDS, NULL},
59793 { (char *)"SizerFlags_DoubleBorder", (PyCFunction) _wrap_SizerFlags_DoubleBorder, METH_VARARGS | METH_KEYWORDS, NULL},
59794 { (char *)"SizerFlags_TripleBorder", (PyCFunction) _wrap_SizerFlags_TripleBorder, METH_VARARGS | METH_KEYWORDS, NULL},
59795 { (char *)"SizerFlags_HorzBorder", (PyCFunction)_wrap_SizerFlags_HorzBorder, METH_O, NULL},
59796 { (char *)"SizerFlags_DoubleHorzBorder", (PyCFunction)_wrap_SizerFlags_DoubleHorzBorder, METH_O, NULL},
59797 { (char *)"SizerFlags_GetDefaultBorder", (PyCFunction)_wrap_SizerFlags_GetDefaultBorder, METH_NOARGS, NULL},
59798 { (char *)"SizerFlags_GetProportion", (PyCFunction)_wrap_SizerFlags_GetProportion, METH_O, NULL},
59799 { (char *)"SizerFlags_GetFlags", (PyCFunction)_wrap_SizerFlags_GetFlags, METH_O, NULL},
59800 { (char *)"SizerFlags_GetBorderInPixels", (PyCFunction)_wrap_SizerFlags_GetBorderInPixels, METH_O, NULL},
59801 { (char *)"SizerFlags_swigregister", SizerFlags_swigregister, METH_VARARGS, NULL},
59802 { (char *)"SizerFlags_swiginit", SizerFlags_swiginit, METH_VARARGS, NULL},
59803 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
59804 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
59805 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59806 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59807 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59808 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
59809 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
59810 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
59811 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
59812 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
59813 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
59814 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
59815 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
59816 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
59817 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
59818 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
59819 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
59820 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
59821 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
59822 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
59823 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
59824 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
59825 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
59826 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
59827 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
59828 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
59829 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
59830 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
59831 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
59832 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
59833 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59834 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59835 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59836 { (char *)"SizerItem_AssignWindow", (PyCFunction) _wrap_SizerItem_AssignWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59837 { (char *)"SizerItem_AssignSizer", (PyCFunction) _wrap_SizerItem_AssignSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59838 { (char *)"SizerItem_AssignSpacer", (PyCFunction) _wrap_SizerItem_AssignSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59839 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
59840 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
59841 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
59842 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
59843 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
59844 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
59845 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
59846 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
59847 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
59848 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
59849 { (char *)"Sizer_AddF", (PyCFunction) _wrap_Sizer_AddF, METH_VARARGS | METH_KEYWORDS, NULL},
59850 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
59851 { (char *)"Sizer_InsertF", (PyCFunction) _wrap_Sizer_InsertF, METH_VARARGS | METH_KEYWORDS, NULL},
59852 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
59853 { (char *)"Sizer_PrependF", (PyCFunction) _wrap_Sizer_PrependF, METH_VARARGS | METH_KEYWORDS, NULL},
59854 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
59855 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
59856 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
59857 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
59858 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
59859 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59860 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
59861 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59862 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
59863 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
59864 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
59865 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
59866 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
59867 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
59868 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
59869 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
59870 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
59871 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
59872 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
59873 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
59874 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
59875 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
59876 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
59877 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
59878 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
59879 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
59880 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
59881 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
59882 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
59883 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
59884 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
59885 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
59886 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
59887 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
59888 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
59889 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59890 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
59891 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
59892 { (char *)"BoxSizer_IsVertical", (PyCFunction)_wrap_BoxSizer_IsVertical, METH_O, NULL},
59893 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
59894 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
59895 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59896 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
59897 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
59898 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
59899 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59900 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
59901 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
59902 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
59903 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
59904 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
59905 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
59906 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
59907 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
59908 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
59909 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
59910 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59911 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
59912 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
59913 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
59914 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
59915 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
59916 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
59917 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
59918 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
59919 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
59920 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
59921 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
59922 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
59923 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
59924 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
59925 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
59926 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
59927 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
59928 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
59929 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
59930 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
59931 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
59932 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
59933 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
59934 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
59935 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
59936 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59937 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
59938 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
59939 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
59940 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
59941 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
59942 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
59943 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
59944 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
59945 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
59946 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
59947 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
59948 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
59949 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
59950 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
59951 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
59952 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
59953 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
59954 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
59955 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
59956 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
59957 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
59958 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
59959 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
59960 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
59961 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
59962 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59963 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59964 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59965 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
59966 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
59967 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
59968 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
59969 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
59970 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
59971 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
59972 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
59973 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59974 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
59975 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
59976 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59977 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
59978 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
59979 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
59980 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
59981 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
59982 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
59983 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
59984 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
59985 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
59986 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
59987 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59988 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
59989 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
59990 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
59991 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
59992 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
59993 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
59994 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
59995 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
59996 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
59997 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
59998 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
59999 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
60000 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
60001 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
60002 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
60003 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
60004 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
60005 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
60006 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
60007 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
60008 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
60009 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
60010 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
60011 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
60012 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
60013 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
60014 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
60015 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
60016 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
60017 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
60018 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
60019 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
60020 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
60021 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
60022 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
60023 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
60024 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
60025 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
60026 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
60027 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
60028 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
60029 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
60030 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
60031 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
60032 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
60033 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
60034 { NULL, NULL, 0, NULL }
60035 };
60036
60037
60038 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
60039
60040 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
60041 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
60042 }
60043 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
60044 return (void *)((wxEvent *) ((wxMenuEvent *) x));
60045 }
60046 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
60047 return (void *)((wxEvent *) ((wxCloseEvent *) x));
60048 }
60049 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
60050 return (void *)((wxEvent *) ((wxMouseEvent *) x));
60051 }
60052 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
60053 return (void *)((wxEvent *) ((wxEraseEvent *) x));
60054 }
60055 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
60056 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
60057 }
60058 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
60059 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
60060 }
60061 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
60062 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
60063 }
60064 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
60065 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
60066 }
60067 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
60068 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
60069 }
60070 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
60071 return (void *)((wxEvent *) ((wxPyEvent *) x));
60072 }
60073 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
60074 return (void *)((wxEvent *) ((wxIdleEvent *) x));
60075 }
60076 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
60077 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
60078 }
60079 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
60080 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
60081 }
60082 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
60083 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
60084 }
60085 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
60086 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
60087 }
60088 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
60089 return (void *)((wxEvent *) ((wxActivateEvent *) x));
60090 }
60091 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
60092 return (void *)((wxEvent *) ((wxSizeEvent *) x));
60093 }
60094 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
60095 return (void *)((wxEvent *) ((wxMoveEvent *) x));
60096 }
60097 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
60098 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
60099 }
60100 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
60101 return (void *)((wxEvent *) ((wxPaintEvent *) x));
60102 }
60103 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
60104 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
60105 }
60106 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
60107 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
60108 }
60109 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
60110 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
60111 }
60112 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
60113 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
60114 }
60115 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
60116 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
60117 }
60118 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
60119 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
60120 }
60121 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
60122 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
60123 }
60124 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
60125 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
60126 }
60127 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
60128 return (void *)((wxEvent *) ((wxFocusEvent *) x));
60129 }
60130 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
60131 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
60132 }
60133 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
60134 return (void *)((wxEvent *) ((wxShowEvent *) x));
60135 }
60136 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
60137 return (void *)((wxEvent *) ((wxCommandEvent *) x));
60138 }
60139 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
60140 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
60141 }
60142 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
60143 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
60144 }
60145 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
60146 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
60147 }
60148 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
60149 return (void *)((wxEvent *) ((wxKeyEvent *) x));
60150 }
60151 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
60152 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
60153 }
60154 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
60155 return (void *)((wxValidator *) ((wxPyValidator *) x));
60156 }
60157 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
60158 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
60159 }
60160 static void *_p_wxEventBlockerTo_p_wxObject(void *x) {
60161 return (void *)((wxObject *) (wxEvtHandler *) ((wxEventBlocker *) x));
60162 }
60163 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
60164 return (void *)((wxObject *) ((wxSizerItem *) x));
60165 }
60166 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
60167 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
60168 }
60169 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
60170 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
60171 }
60172 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
60173 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
60174 }
60175 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
60176 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
60177 }
60178 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
60179 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
60180 }
60181 static void *_p_wxSizerTo_p_wxObject(void *x) {
60182 return (void *)((wxObject *) ((wxSizer *) x));
60183 }
60184 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
60185 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
60186 }
60187 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
60188 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
60189 }
60190 static void *_p_wxEventTo_p_wxObject(void *x) {
60191 return (void *)((wxObject *) ((wxEvent *) x));
60192 }
60193 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
60194 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
60195 }
60196 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
60197 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
60198 }
60199 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
60200 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
60201 }
60202 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
60203 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
60204 }
60205 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
60206 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
60207 }
60208 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
60209 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
60210 }
60211 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
60212 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
60213 }
60214 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
60215 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
60216 }
60217 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
60218 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
60219 }
60220 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
60221 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
60222 }
60223 static void *_p_wxControlTo_p_wxObject(void *x) {
60224 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
60225 }
60226 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
60227 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
60228 }
60229 static void *_p_wxFSFileTo_p_wxObject(void *x) {
60230 return (void *)((wxObject *) ((wxFSFile *) x));
60231 }
60232 static void *_p_wxPySizerTo_p_wxObject(void *x) {
60233 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
60234 }
60235 static void *_p_wxPyEventTo_p_wxObject(void *x) {
60236 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
60237 }
60238 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
60239 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
60240 }
60241 static void *_p_wxShowEventTo_p_wxObject(void *x) {
60242 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
60243 }
60244 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
60245 return (void *)((wxObject *) ((wxMenuItem *) x));
60246 }
60247 static void *_p_wxDateEventTo_p_wxObject(void *x) {
60248 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
60249 }
60250 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
60251 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
60252 }
60253 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
60254 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
60255 }
60256 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
60257 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
60258 }
60259 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
60260 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
60261 }
60262 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
60263 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
60264 }
60265 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
60266 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
60267 }
60268 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
60269 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
60270 }
60271 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
60272 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
60273 }
60274 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
60275 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
60276 }
60277 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
60278 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
60279 }
60280 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
60281 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
60282 }
60283 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
60284 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
60285 }
60286 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
60287 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
60288 }
60289 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
60290 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
60291 }
60292 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
60293 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
60294 }
60295 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
60296 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
60297 }
60298 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
60299 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
60300 }
60301 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
60302 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
60303 }
60304 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
60305 return (void *)((wxObject *) ((wxImageHandler *) x));
60306 }
60307 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
60308 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
60309 }
60310 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
60311 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
60312 }
60313 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
60314 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
60315 }
60316 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
60317 return (void *)((wxObject *) ((wxEvtHandler *) x));
60318 }
60319 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
60320 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
60321 }
60322 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
60323 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
60324 }
60325 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
60326 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
60327 }
60328 static void *_p_wxImageTo_p_wxObject(void *x) {
60329 return (void *)((wxObject *) ((wxImage *) x));
60330 }
60331 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
60332 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
60333 }
60334 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
60335 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
60336 }
60337 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
60338 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
60339 }
60340 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
60341 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
60342 }
60343 static void *_p_wxWindowTo_p_wxObject(void *x) {
60344 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
60345 }
60346 static void *_p_wxMenuTo_p_wxObject(void *x) {
60347 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
60348 }
60349 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
60350 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
60351 }
60352 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
60353 return (void *)((wxObject *) ((wxFileSystem *) x));
60354 }
60355 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
60356 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
60357 }
60358 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
60359 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
60360 }
60361 static void *_p_wxPyAppTo_p_wxObject(void *x) {
60362 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
60363 }
60364 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
60365 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
60366 }
60367 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
60368 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
60369 }
60370 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
60371 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
60372 }
60373 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
60374 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
60375 }
60376 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
60377 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
60378 }
60379 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
60380 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
60381 }
60382 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
60383 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
60384 }
60385 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
60386 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
60387 }
60388 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
60389 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
60390 }
60391 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
60392 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
60393 }
60394 static void *_p_wxValidatorTo_p_wxObject(void *x) {
60395 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
60396 }
60397 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
60398 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
60399 }
60400 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
60401 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
60402 }
60403 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
60404 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
60405 }
60406 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
60407 return (void *)((wxControl *) ((wxControlWithItems *) x));
60408 }
60409 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
60410 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
60411 }
60412 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
60413 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
60414 }
60415 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
60416 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
60417 }
60418 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
60419 return (void *)((wxSizer *) ((wxBoxSizer *) x));
60420 }
60421 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
60422 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
60423 }
60424 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
60425 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
60426 }
60427 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
60428 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
60429 }
60430 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
60431 return (void *)((wxSizer *) ((wxGridSizer *) x));
60432 }
60433 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
60434 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
60435 }
60436 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
60437 return (void *)((wxSizer *) ((wxPySizer *) x));
60438 }
60439 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
60440 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
60441 }
60442 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
60443 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
60444 }
60445 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
60446 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
60447 }
60448 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
60449 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
60450 }
60451 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
60452 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
60453 }
60454 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
60455 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
60456 }
60457 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
60458 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
60459 }
60460 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
60461 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
60462 }
60463 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
60464 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
60465 }
60466 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
60467 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
60468 }
60469 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
60470 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
60471 }
60472 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
60473 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
60474 }
60475 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
60476 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
60477 }
60478 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
60479 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
60480 }
60481 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
60482 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
60483 }
60484 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
60485 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
60486 }
60487 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
60488 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
60489 }
60490 static void *_p_wxTGAHandlerTo_p_wxImageHandler(void *x) {
60491 return (void *)((wxImageHandler *) ((wxTGAHandler *) x));
60492 }
60493 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
60494 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
60495 }
60496 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
60497 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
60498 }
60499 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
60500 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
60501 }
60502 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
60503 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
60504 }
60505 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
60506 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
60507 }
60508 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
60509 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
60510 }
60511 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
60512 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
60513 }
60514 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
60515 return (void *)((wxEvtHandler *) ((wxWindow *) x));
60516 }
60517 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
60518 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
60519 }
60520 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
60521 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
60522 }
60523 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
60524 return (void *)((wxEvtHandler *) ((wxValidator *) x));
60525 }
60526 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
60527 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
60528 }
60529 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
60530 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
60531 }
60532 static void *_p_wxEventBlockerTo_p_wxEvtHandler(void *x) {
60533 return (void *)((wxEvtHandler *) ((wxEventBlocker *) x));
60534 }
60535 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
60536 return (void *)((wxEvtHandler *) ((wxMenu *) x));
60537 }
60538 static void *_p_wxControlTo_p_wxWindow(void *x) {
60539 return (void *)((wxWindow *) ((wxControl *) x));
60540 }
60541 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
60542 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
60543 }
60544 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
60545 return (void *)((wxWindow *) ((wxMenuBar *) x));
60546 }
60547 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
60548 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
60549 }
60550 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
60551 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
60552 }
60553 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
60554 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
60555 }
60556 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
60557 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
60558 }
60559 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
60560 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
60561 }
60562 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
60563 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
60564 }
60565 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
60566 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
60567 }
60568 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
60569 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
60570 }
60571 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
60572 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
60573 }
60574 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
60575 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
60576 }
60577 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
60578 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
60579 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};
60580 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
60581 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
60582 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
60583 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
60584 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
60585 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
60586 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
60587 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
60588 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
60589 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
60590 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
60591 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
60592 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
60593 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
60594 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
60595 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
60596 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
60597 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
60598 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
60599 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
60600 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
60601 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
60602 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
60603 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
60604 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
60605 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
60606 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
60607 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
60608 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
60609 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
60610 static swig_type_info _swigt__p_wxDouble = {"_p_wxDouble", "wxDouble *", 0, 0, (void*)0, 0};
60611 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
60612 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
60613 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
60614 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
60615 static swig_type_info _swigt__p_wxEventBlocker = {"_p_wxEventBlocker", "wxEventBlocker *", 0, 0, (void*)0, 0};
60616 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
60617 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
60618 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
60619 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
60620 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
60621 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
60622 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
60623 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
60624 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
60625 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
60626 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
60627 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
60628 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
60629 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
60630 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
60631 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
60632 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
60633 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
60634 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
60635 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
60636 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
60637 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
60638 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
60639 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
60640 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
60641 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
60642 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
60643 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
60644 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
60645 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
60646 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
60647 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
60648 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
60649 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
60650 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
60651 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
60652 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
60653 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
60654 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
60655 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
60656 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
60657 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
60658 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
60659 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
60660 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
60661 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
60662 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
60663 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
60664 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
60665 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
60666 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
60667 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
60668 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
60669 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
60670 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
60671 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
60672 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
60673 static swig_type_info _swigt__p_wxPosition = {"_p_wxPosition", "wxPosition *", 0, 0, (void*)0, 0};
60674 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
60675 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
60676 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
60677 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
60678 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
60679 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
60680 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
60681 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
60682 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
60683 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
60684 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
60685 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
60686 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
60687 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
60688 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
60689 static swig_type_info _swigt__p_wxRect2D = {"_p_wxRect2D", "wxRect2D *", 0, 0, (void*)0, 0};
60690 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
60691 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
60692 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
60693 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
60694 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
60695 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
60696 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
60697 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
60698 static swig_type_info _swigt__p_wxSizerFlags = {"_p_wxSizerFlags", "wxSizerFlags *", 0, 0, (void*)0, 0};
60699 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
60700 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
60701 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
60702 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
60703 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
60704 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", "wxTGAHandler *", 0, 0, (void*)0, 0};
60705 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
60706 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
60707 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
60708 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
60709 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
60710 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
60711 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
60712 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
60713 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
60714 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
60715
60716 static swig_type_info *swig_type_initial[] = {
60717 &_swigt__p_buffer,
60718 &_swigt__p_char,
60719 &_swigt__p_form_ops_t,
60720 &_swigt__p_int,
60721 &_swigt__p_long,
60722 &_swigt__p_unsigned_char,
60723 &_swigt__p_unsigned_int,
60724 &_swigt__p_unsigned_long,
60725 &_swigt__p_wxANIHandler,
60726 &_swigt__p_wxAcceleratorEntry,
60727 &_swigt__p_wxAcceleratorTable,
60728 &_swigt__p_wxActivateEvent,
60729 &_swigt__p_wxAppTraits,
60730 &_swigt__p_wxArrayString,
60731 &_swigt__p_wxBMPHandler,
60732 &_swigt__p_wxBitmap,
60733 &_swigt__p_wxBoxSizer,
60734 &_swigt__p_wxButton,
60735 &_swigt__p_wxCURHandler,
60736 &_swigt__p_wxCaret,
60737 &_swigt__p_wxChildFocusEvent,
60738 &_swigt__p_wxClipboardTextEvent,
60739 &_swigt__p_wxCloseEvent,
60740 &_swigt__p_wxColour,
60741 &_swigt__p_wxCommandEvent,
60742 &_swigt__p_wxContextMenuEvent,
60743 &_swigt__p_wxControl,
60744 &_swigt__p_wxControlWithItems,
60745 &_swigt__p_wxCursor,
60746 &_swigt__p_wxDC,
60747 &_swigt__p_wxDateEvent,
60748 &_swigt__p_wxDateTime,
60749 &_swigt__p_wxDisplayChangedEvent,
60750 &_swigt__p_wxDouble,
60751 &_swigt__p_wxDropFilesEvent,
60752 &_swigt__p_wxDuplexMode,
60753 &_swigt__p_wxEraseEvent,
60754 &_swigt__p_wxEvent,
60755 &_swigt__p_wxEventBlocker,
60756 &_swigt__p_wxEventLoop,
60757 &_swigt__p_wxEventLoopActivator,
60758 &_swigt__p_wxEvtHandler,
60759 &_swigt__p_wxFSFile,
60760 &_swigt__p_wxFileSystem,
60761 &_swigt__p_wxFileSystemHandler,
60762 &_swigt__p_wxFlexGridSizer,
60763 &_swigt__p_wxFocusEvent,
60764 &_swigt__p_wxFont,
60765 &_swigt__p_wxFrame,
60766 &_swigt__p_wxGBPosition,
60767 &_swigt__p_wxGBSizerItem,
60768 &_swigt__p_wxGBSpan,
60769 &_swigt__p_wxGIFHandler,
60770 &_swigt__p_wxGridBagSizer,
60771 &_swigt__p_wxGridSizer,
60772 &_swigt__p_wxHelpEvent__Origin,
60773 &_swigt__p_wxICOHandler,
60774 &_swigt__p_wxIconizeEvent,
60775 &_swigt__p_wxIdleEvent,
60776 &_swigt__p_wxImage,
60777 &_swigt__p_wxImageHandler,
60778 &_swigt__p_wxImageHistogram,
60779 &_swigt__p_wxImage_HSVValue,
60780 &_swigt__p_wxImage_RGBValue,
60781 &_swigt__p_wxIndividualLayoutConstraint,
60782 &_swigt__p_wxInitDialogEvent,
60783 &_swigt__p_wxInputStream,
60784 &_swigt__p_wxInternetFSHandler,
60785 &_swigt__p_wxItemContainer,
60786 &_swigt__p_wxJPEGHandler,
60787 &_swigt__p_wxKeyEvent,
60788 &_swigt__p_wxLayoutConstraints,
60789 &_swigt__p_wxMaximizeEvent,
60790 &_swigt__p_wxMemoryFSHandler,
60791 &_swigt__p_wxMenu,
60792 &_swigt__p_wxMenuBar,
60793 &_swigt__p_wxMenuBarBase,
60794 &_swigt__p_wxMenuEvent,
60795 &_swigt__p_wxMenuItem,
60796 &_swigt__p_wxMouseCaptureChangedEvent,
60797 &_swigt__p_wxMouseCaptureLostEvent,
60798 &_swigt__p_wxMouseEvent,
60799 &_swigt__p_wxMoveEvent,
60800 &_swigt__p_wxNavigationKeyEvent,
60801 &_swigt__p_wxNcPaintEvent,
60802 &_swigt__p_wxNotifyEvent,
60803 &_swigt__p_wxObject,
60804 &_swigt__p_wxOutputStream,
60805 &_swigt__p_wxPCXHandler,
60806 &_swigt__p_wxPNGHandler,
60807 &_swigt__p_wxPNMHandler,
60808 &_swigt__p_wxPaintEvent,
60809 &_swigt__p_wxPaletteChangedEvent,
60810 &_swigt__p_wxPaperSize,
60811 &_swigt__p_wxPoint,
60812 &_swigt__p_wxPoint2D,
60813 &_swigt__p_wxPosition,
60814 &_swigt__p_wxPropagateOnce,
60815 &_swigt__p_wxPropagationDisabler,
60816 &_swigt__p_wxPyApp,
60817 &_swigt__p_wxPyCommandEvent,
60818 &_swigt__p_wxPyDropTarget,
60819 &_swigt__p_wxPyEvent,
60820 &_swigt__p_wxPyFileSystemHandler,
60821 &_swigt__p_wxPyImageHandler,
60822 &_swigt__p_wxPyInputStream,
60823 &_swigt__p_wxPySizer,
60824 &_swigt__p_wxPyValidator,
60825 &_swigt__p_wxQuantize,
60826 &_swigt__p_wxQueryNewPaletteEvent,
60827 &_swigt__p_wxRealPoint,
60828 &_swigt__p_wxRect,
60829 &_swigt__p_wxRect2D,
60830 &_swigt__p_wxRegion,
60831 &_swigt__p_wxScrollEvent,
60832 &_swigt__p_wxScrollWinEvent,
60833 &_swigt__p_wxSetCursorEvent,
60834 &_swigt__p_wxShowEvent,
60835 &_swigt__p_wxSize,
60836 &_swigt__p_wxSizeEvent,
60837 &_swigt__p_wxSizer,
60838 &_swigt__p_wxSizerFlags,
60839 &_swigt__p_wxSizerItem,
60840 &_swigt__p_wxStaticBox,
60841 &_swigt__p_wxStaticBoxSizer,
60842 &_swigt__p_wxStdDialogButtonSizer,
60843 &_swigt__p_wxSysColourChangedEvent,
60844 &_swigt__p_wxTGAHandler,
60845 &_swigt__p_wxTIFFHandler,
60846 &_swigt__p_wxToolTip,
60847 &_swigt__p_wxUpdateUIEvent,
60848 &_swigt__p_wxValidator,
60849 &_swigt__p_wxVisualAttributes,
60850 &_swigt__p_wxWindow,
60851 &_swigt__p_wxWindowCreateEvent,
60852 &_swigt__p_wxWindowDestroyEvent,
60853 &_swigt__p_wxXPMHandler,
60854 &_swigt__p_wxZipFSHandler,
60855 };
60856
60857 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
60858 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
60859 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
60860 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
60861 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
60862 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
60863 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
60864 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
60865 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
60866 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
60867 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
60868 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
60869 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
60870 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
60871 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}};
60872 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
60873 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}};
60874 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
60875 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}};
60876 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
60877 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
60878 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
60879 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
60880 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
60881 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}};
60882 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
60883 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}};
60884 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
60885 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
60886 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
60887 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
60888 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
60889 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60890 static swig_cast_info _swigc__p_wxDouble[] = { {&_swigt__p_wxDouble, 0, 0, 0},{0, 0, 0, 0}};
60891 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
60892 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
60893 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
60894 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}};
60895 static swig_cast_info _swigc__p_wxEventBlocker[] = { {&_swigt__p_wxEventBlocker, 0, 0, 0},{0, 0, 0, 0}};
60896 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
60897 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
60898 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}, {&_swigt__p_wxEventBlocker, _p_wxEventBlockerTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
60899 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
60900 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
60901 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}};
60902 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}};
60903 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
60904 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
60905 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
60906 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
60907 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
60908 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
60909 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
60910 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
60911 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}};
60912 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
60913 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}};
60914 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
60915 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
60916 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
60917 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}};
60918 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
60919 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
60920 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
60921 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
60922 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
60923 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
60924 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
60925 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}};
60926 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
60927 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
60928 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
60929 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
60930 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
60931 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
60932 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
60933 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
60934 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
60935 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
60936 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60937 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
60938 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
60939 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
60940 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
60941 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
60942 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
60943 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxEventBlocker, _p_wxEventBlockerTo_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_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_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_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_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_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}};
60944 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
60945 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
60946 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
60947 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
60948 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
60949 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60950 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
60951 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
60952 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
60953 static swig_cast_info _swigc__p_wxPosition[] = { {&_swigt__p_wxPosition, 0, 0, 0},{0, 0, 0, 0}};
60954 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
60955 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
60956 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
60957 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
60958 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
60959 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
60960 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
60961 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
60962 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
60963 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
60964 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
60965 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
60966 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
60967 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
60968 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
60969 static swig_cast_info _swigc__p_wxRect2D[] = { {&_swigt__p_wxRect2D, 0, 0, 0},{0, 0, 0, 0}};
60970 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
60971 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
60972 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
60973 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
60974 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
60975 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
60976 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
60977 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}};
60978 static swig_cast_info _swigc__p_wxSizerFlags[] = { {&_swigt__p_wxSizerFlags, 0, 0, 0},{0, 0, 0, 0}};
60979 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}};
60980 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
60981 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
60982 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
60983 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60984 static swig_cast_info _swigc__p_wxTGAHandler[] = { {&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
60985 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
60986 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
60987 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
60988 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}};
60989 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
60990 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}};
60991 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
60992 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
60993 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
60994 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
60995
60996 static swig_cast_info *swig_cast_initial[] = {
60997 _swigc__p_buffer,
60998 _swigc__p_char,
60999 _swigc__p_form_ops_t,
61000 _swigc__p_int,
61001 _swigc__p_long,
61002 _swigc__p_unsigned_char,
61003 _swigc__p_unsigned_int,
61004 _swigc__p_unsigned_long,
61005 _swigc__p_wxANIHandler,
61006 _swigc__p_wxAcceleratorEntry,
61007 _swigc__p_wxAcceleratorTable,
61008 _swigc__p_wxActivateEvent,
61009 _swigc__p_wxAppTraits,
61010 _swigc__p_wxArrayString,
61011 _swigc__p_wxBMPHandler,
61012 _swigc__p_wxBitmap,
61013 _swigc__p_wxBoxSizer,
61014 _swigc__p_wxButton,
61015 _swigc__p_wxCURHandler,
61016 _swigc__p_wxCaret,
61017 _swigc__p_wxChildFocusEvent,
61018 _swigc__p_wxClipboardTextEvent,
61019 _swigc__p_wxCloseEvent,
61020 _swigc__p_wxColour,
61021 _swigc__p_wxCommandEvent,
61022 _swigc__p_wxContextMenuEvent,
61023 _swigc__p_wxControl,
61024 _swigc__p_wxControlWithItems,
61025 _swigc__p_wxCursor,
61026 _swigc__p_wxDC,
61027 _swigc__p_wxDateEvent,
61028 _swigc__p_wxDateTime,
61029 _swigc__p_wxDisplayChangedEvent,
61030 _swigc__p_wxDouble,
61031 _swigc__p_wxDropFilesEvent,
61032 _swigc__p_wxDuplexMode,
61033 _swigc__p_wxEraseEvent,
61034 _swigc__p_wxEvent,
61035 _swigc__p_wxEventBlocker,
61036 _swigc__p_wxEventLoop,
61037 _swigc__p_wxEventLoopActivator,
61038 _swigc__p_wxEvtHandler,
61039 _swigc__p_wxFSFile,
61040 _swigc__p_wxFileSystem,
61041 _swigc__p_wxFileSystemHandler,
61042 _swigc__p_wxFlexGridSizer,
61043 _swigc__p_wxFocusEvent,
61044 _swigc__p_wxFont,
61045 _swigc__p_wxFrame,
61046 _swigc__p_wxGBPosition,
61047 _swigc__p_wxGBSizerItem,
61048 _swigc__p_wxGBSpan,
61049 _swigc__p_wxGIFHandler,
61050 _swigc__p_wxGridBagSizer,
61051 _swigc__p_wxGridSizer,
61052 _swigc__p_wxHelpEvent__Origin,
61053 _swigc__p_wxICOHandler,
61054 _swigc__p_wxIconizeEvent,
61055 _swigc__p_wxIdleEvent,
61056 _swigc__p_wxImage,
61057 _swigc__p_wxImageHandler,
61058 _swigc__p_wxImageHistogram,
61059 _swigc__p_wxImage_HSVValue,
61060 _swigc__p_wxImage_RGBValue,
61061 _swigc__p_wxIndividualLayoutConstraint,
61062 _swigc__p_wxInitDialogEvent,
61063 _swigc__p_wxInputStream,
61064 _swigc__p_wxInternetFSHandler,
61065 _swigc__p_wxItemContainer,
61066 _swigc__p_wxJPEGHandler,
61067 _swigc__p_wxKeyEvent,
61068 _swigc__p_wxLayoutConstraints,
61069 _swigc__p_wxMaximizeEvent,
61070 _swigc__p_wxMemoryFSHandler,
61071 _swigc__p_wxMenu,
61072 _swigc__p_wxMenuBar,
61073 _swigc__p_wxMenuBarBase,
61074 _swigc__p_wxMenuEvent,
61075 _swigc__p_wxMenuItem,
61076 _swigc__p_wxMouseCaptureChangedEvent,
61077 _swigc__p_wxMouseCaptureLostEvent,
61078 _swigc__p_wxMouseEvent,
61079 _swigc__p_wxMoveEvent,
61080 _swigc__p_wxNavigationKeyEvent,
61081 _swigc__p_wxNcPaintEvent,
61082 _swigc__p_wxNotifyEvent,
61083 _swigc__p_wxObject,
61084 _swigc__p_wxOutputStream,
61085 _swigc__p_wxPCXHandler,
61086 _swigc__p_wxPNGHandler,
61087 _swigc__p_wxPNMHandler,
61088 _swigc__p_wxPaintEvent,
61089 _swigc__p_wxPaletteChangedEvent,
61090 _swigc__p_wxPaperSize,
61091 _swigc__p_wxPoint,
61092 _swigc__p_wxPoint2D,
61093 _swigc__p_wxPosition,
61094 _swigc__p_wxPropagateOnce,
61095 _swigc__p_wxPropagationDisabler,
61096 _swigc__p_wxPyApp,
61097 _swigc__p_wxPyCommandEvent,
61098 _swigc__p_wxPyDropTarget,
61099 _swigc__p_wxPyEvent,
61100 _swigc__p_wxPyFileSystemHandler,
61101 _swigc__p_wxPyImageHandler,
61102 _swigc__p_wxPyInputStream,
61103 _swigc__p_wxPySizer,
61104 _swigc__p_wxPyValidator,
61105 _swigc__p_wxQuantize,
61106 _swigc__p_wxQueryNewPaletteEvent,
61107 _swigc__p_wxRealPoint,
61108 _swigc__p_wxRect,
61109 _swigc__p_wxRect2D,
61110 _swigc__p_wxRegion,
61111 _swigc__p_wxScrollEvent,
61112 _swigc__p_wxScrollWinEvent,
61113 _swigc__p_wxSetCursorEvent,
61114 _swigc__p_wxShowEvent,
61115 _swigc__p_wxSize,
61116 _swigc__p_wxSizeEvent,
61117 _swigc__p_wxSizer,
61118 _swigc__p_wxSizerFlags,
61119 _swigc__p_wxSizerItem,
61120 _swigc__p_wxStaticBox,
61121 _swigc__p_wxStaticBoxSizer,
61122 _swigc__p_wxStdDialogButtonSizer,
61123 _swigc__p_wxSysColourChangedEvent,
61124 _swigc__p_wxTGAHandler,
61125 _swigc__p_wxTIFFHandler,
61126 _swigc__p_wxToolTip,
61127 _swigc__p_wxUpdateUIEvent,
61128 _swigc__p_wxValidator,
61129 _swigc__p_wxVisualAttributes,
61130 _swigc__p_wxWindow,
61131 _swigc__p_wxWindowCreateEvent,
61132 _swigc__p_wxWindowDestroyEvent,
61133 _swigc__p_wxXPMHandler,
61134 _swigc__p_wxZipFSHandler,
61135 };
61136
61137
61138 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
61139
61140 static swig_const_info swig_const_table[] = {
61141 {0, 0, 0, 0.0, 0, 0}};
61142
61143 #ifdef __cplusplus
61144 }
61145 #endif
61146 /* -----------------------------------------------------------------------------
61147 * Type initialization:
61148 * This problem is tough by the requirement that no dynamic
61149 * memory is used. Also, since swig_type_info structures store pointers to
61150 * swig_cast_info structures and swig_cast_info structures store pointers back
61151 * to swig_type_info structures, we need some lookup code at initialization.
61152 * The idea is that swig generates all the structures that are needed.
61153 * The runtime then collects these partially filled structures.
61154 * The SWIG_InitializeModule function takes these initial arrays out of
61155 * swig_module, and does all the lookup, filling in the swig_module.types
61156 * array with the correct data and linking the correct swig_cast_info
61157 * structures together.
61158 *
61159 * The generated swig_type_info structures are assigned staticly to an initial
61160 * array. We just loop though that array, and handle each type individually.
61161 * First we lookup if this type has been already loaded, and if so, use the
61162 * loaded structure instead of the generated one. Then we have to fill in the
61163 * cast linked list. The cast data is initially stored in something like a
61164 * two-dimensional array. Each row corresponds to a type (there are the same
61165 * number of rows as there are in the swig_type_initial array). Each entry in
61166 * a column is one of the swig_cast_info structures for that type.
61167 * The cast_initial array is actually an array of arrays, because each row has
61168 * a variable number of columns. So to actually build the cast linked list,
61169 * we find the array of casts associated with the type, and loop through it
61170 * adding the casts to the list. The one last trick we need to do is making
61171 * sure the type pointer in the swig_cast_info struct is correct.
61172 *
61173 * First off, we lookup the cast->type name to see if it is already loaded.
61174 * There are three cases to handle:
61175 * 1) If the cast->type has already been loaded AND the type we are adding
61176 * casting info to has not been loaded (it is in this module), THEN we
61177 * replace the cast->type pointer with the type pointer that has already
61178 * been loaded.
61179 * 2) If BOTH types (the one we are adding casting info to, and the
61180 * cast->type) are loaded, THEN the cast info has already been loaded by
61181 * the previous module so we just ignore it.
61182 * 3) Finally, if cast->type has not already been loaded, then we add that
61183 * swig_cast_info to the linked list (because the cast->type) pointer will
61184 * be correct.
61185 * ----------------------------------------------------------------------------- */
61186
61187 #ifdef __cplusplus
61188 extern "C" {
61189 #if 0
61190 } /* c-mode */
61191 #endif
61192 #endif
61193
61194 #if 0
61195 #define SWIGRUNTIME_DEBUG
61196 #endif
61197
61198 SWIGRUNTIME void
61199 SWIG_InitializeModule(void *clientdata) {
61200 size_t i;
61201 swig_module_info *module_head;
61202 static int init_run = 0;
61203
61204 clientdata = clientdata;
61205
61206 if (init_run) return;
61207 init_run = 1;
61208
61209 /* Initialize the swig_module */
61210 swig_module.type_initial = swig_type_initial;
61211 swig_module.cast_initial = swig_cast_initial;
61212
61213 /* Try and load any already created modules */
61214 module_head = SWIG_GetModule(clientdata);
61215 if (module_head) {
61216 swig_module.next = module_head->next;
61217 module_head->next = &swig_module;
61218 } else {
61219 /* This is the first module loaded */
61220 swig_module.next = &swig_module;
61221 SWIG_SetModule(clientdata, &swig_module);
61222 }
61223
61224 /* Now work on filling in swig_module.types */
61225 #ifdef SWIGRUNTIME_DEBUG
61226 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
61227 #endif
61228 for (i = 0; i < swig_module.size; ++i) {
61229 swig_type_info *type = 0;
61230 swig_type_info *ret;
61231 swig_cast_info *cast;
61232
61233 #ifdef SWIGRUNTIME_DEBUG
61234 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
61235 #endif
61236
61237 /* if there is another module already loaded */
61238 if (swig_module.next != &swig_module) {
61239 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
61240 }
61241 if (type) {
61242 /* Overwrite clientdata field */
61243 #ifdef SWIGRUNTIME_DEBUG
61244 printf("SWIG_InitializeModule: found type %s\n", type->name);
61245 #endif
61246 if (swig_module.type_initial[i]->clientdata) {
61247 type->clientdata = swig_module.type_initial[i]->clientdata;
61248 #ifdef SWIGRUNTIME_DEBUG
61249 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
61250 #endif
61251 }
61252 } else {
61253 type = swig_module.type_initial[i];
61254 }
61255
61256 /* Insert casting types */
61257 cast = swig_module.cast_initial[i];
61258 while (cast->type) {
61259 /* Don't need to add information already in the list */
61260 ret = 0;
61261 #ifdef SWIGRUNTIME_DEBUG
61262 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
61263 #endif
61264 if (swig_module.next != &swig_module) {
61265 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
61266 #ifdef SWIGRUNTIME_DEBUG
61267 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
61268 #endif
61269 }
61270 if (ret) {
61271 if (type == swig_module.type_initial[i]) {
61272 #ifdef SWIGRUNTIME_DEBUG
61273 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
61274 #endif
61275 cast->type = ret;
61276 ret = 0;
61277 } else {
61278 /* Check for casting already in the list */
61279 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
61280 #ifdef SWIGRUNTIME_DEBUG
61281 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
61282 #endif
61283 if (!ocast) ret = 0;
61284 }
61285 }
61286
61287 if (!ret) {
61288 #ifdef SWIGRUNTIME_DEBUG
61289 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
61290 #endif
61291 if (type->cast) {
61292 type->cast->prev = cast;
61293 cast->next = type->cast;
61294 }
61295 type->cast = cast;
61296 }
61297 cast++;
61298 }
61299 /* Set entry in modules->types array equal to the type */
61300 swig_module.types[i] = type;
61301 }
61302 swig_module.types[i] = 0;
61303
61304 #ifdef SWIGRUNTIME_DEBUG
61305 printf("**** SWIG_InitializeModule: Cast List ******\n");
61306 for (i = 0; i < swig_module.size; ++i) {
61307 int j = 0;
61308 swig_cast_info *cast = swig_module.cast_initial[i];
61309 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
61310 while (cast->type) {
61311 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
61312 cast++;
61313 ++j;
61314 }
61315 printf("---- Total casts: %d\n",j);
61316 }
61317 printf("**** SWIG_InitializeModule: Cast List ******\n");
61318 #endif
61319 }
61320
61321 /* This function will propagate the clientdata field of type to
61322 * any new swig_type_info structures that have been added into the list
61323 * of equivalent types. It is like calling
61324 * SWIG_TypeClientData(type, clientdata) a second time.
61325 */
61326 SWIGRUNTIME void
61327 SWIG_PropagateClientData(void) {
61328 size_t i;
61329 swig_cast_info *equiv;
61330 static int init_run = 0;
61331
61332 if (init_run) return;
61333 init_run = 1;
61334
61335 for (i = 0; i < swig_module.size; i++) {
61336 if (swig_module.types[i]->clientdata) {
61337 equiv = swig_module.types[i]->cast;
61338 while (equiv) {
61339 if (!equiv->converter) {
61340 if (equiv->type && !equiv->type->clientdata)
61341 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
61342 }
61343 equiv = equiv->next;
61344 }
61345 }
61346 }
61347 }
61348
61349 #ifdef __cplusplus
61350 #if 0
61351 {
61352 /* c-mode */
61353 #endif
61354 }
61355 #endif
61356
61357
61358
61359 #ifdef __cplusplus
61360 extern "C" {
61361 #endif
61362
61363 /* Python-specific SWIG API */
61364 #define SWIG_newvarlink() SWIG_Python_newvarlink()
61365 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
61366 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
61367
61368 /* -----------------------------------------------------------------------------
61369 * global variable support code.
61370 * ----------------------------------------------------------------------------- */
61371
61372 typedef struct swig_globalvar {
61373 char *name; /* Name of global variable */
61374 PyObject *(*get_attr)(void); /* Return the current value */
61375 int (*set_attr)(PyObject *); /* Set the value */
61376 struct swig_globalvar *next;
61377 } swig_globalvar;
61378
61379 typedef struct swig_varlinkobject {
61380 PyObject_HEAD
61381 swig_globalvar *vars;
61382 } swig_varlinkobject;
61383
61384 SWIGINTERN PyObject *
61385 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
61386 return PyString_FromString("<Swig global variables>");
61387 }
61388
61389 SWIGINTERN PyObject *
61390 swig_varlink_str(swig_varlinkobject *v) {
61391 PyObject *str = PyString_FromString("(");
61392 swig_globalvar *var;
61393 for (var = v->vars; var; var=var->next) {
61394 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
61395 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
61396 }
61397 PyString_ConcatAndDel(&str,PyString_FromString(")"));
61398 return str;
61399 }
61400
61401 SWIGINTERN int
61402 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
61403 PyObject *str = swig_varlink_str(v);
61404 fprintf(fp,"Swig global variables ");
61405 fprintf(fp,"%s\n", PyString_AsString(str));
61406 Py_DECREF(str);
61407 return 0;
61408 }
61409
61410 SWIGINTERN void
61411 swig_varlink_dealloc(swig_varlinkobject *v) {
61412 swig_globalvar *var = v->vars;
61413 while (var) {
61414 swig_globalvar *n = var->next;
61415 free(var->name);
61416 free(var);
61417 var = n;
61418 }
61419 }
61420
61421 SWIGINTERN PyObject *
61422 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
61423 PyObject *res = NULL;
61424 swig_globalvar *var = v->vars;
61425 while (var) {
61426 if (strcmp(var->name,n) == 0) {
61427 res = (*var->get_attr)();
61428 break;
61429 }
61430 var = var->next;
61431 }
61432 if (res == NULL && !PyErr_Occurred()) {
61433 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
61434 }
61435 return res;
61436 }
61437
61438 SWIGINTERN int
61439 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
61440 int res = 1;
61441 swig_globalvar *var = v->vars;
61442 while (var) {
61443 if (strcmp(var->name,n) == 0) {
61444 res = (*var->set_attr)(p);
61445 break;
61446 }
61447 var = var->next;
61448 }
61449 if (res == 1 && !PyErr_Occurred()) {
61450 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
61451 }
61452 return res;
61453 }
61454
61455 SWIGINTERN PyTypeObject*
61456 swig_varlink_type(void) {
61457 static char varlink__doc__[] = "Swig var link object";
61458 static PyTypeObject varlink_type;
61459 static int type_init = 0;
61460 if (!type_init) {
61461 const PyTypeObject tmp
61462 = {
61463 PyObject_HEAD_INIT(NULL)
61464 0, /* Number of items in variable part (ob_size) */
61465 (char *)"swigvarlink", /* Type name (tp_name) */
61466 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
61467 0, /* Itemsize (tp_itemsize) */
61468 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
61469 (printfunc) swig_varlink_print, /* Print (tp_print) */
61470 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
61471 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
61472 0, /* tp_compare */
61473 (reprfunc) swig_varlink_repr, /* tp_repr */
61474 0, /* tp_as_number */
61475 0, /* tp_as_sequence */
61476 0, /* tp_as_mapping */
61477 0, /* tp_hash */
61478 0, /* tp_call */
61479 (reprfunc)swig_varlink_str, /* tp_str */
61480 0, /* tp_getattro */
61481 0, /* tp_setattro */
61482 0, /* tp_as_buffer */
61483 0, /* tp_flags */
61484 varlink__doc__, /* tp_doc */
61485 0, /* tp_traverse */
61486 0, /* tp_clear */
61487 0, /* tp_richcompare */
61488 0, /* tp_weaklistoffset */
61489 #if PY_VERSION_HEX >= 0x02020000
61490 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
61491 #endif
61492 #if PY_VERSION_HEX >= 0x02030000
61493 0, /* tp_del */
61494 #endif
61495 #ifdef COUNT_ALLOCS
61496 0,0,0,0 /* tp_alloc -> tp_next */
61497 #endif
61498 };
61499 varlink_type = tmp;
61500 varlink_type.ob_type = &PyType_Type;
61501 type_init = 1;
61502 }
61503 return &varlink_type;
61504 }
61505
61506 /* Create a variable linking object for use later */
61507 SWIGINTERN PyObject *
61508 SWIG_Python_newvarlink(void) {
61509 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
61510 if (result) {
61511 result->vars = 0;
61512 }
61513 return ((PyObject*) result);
61514 }
61515
61516 SWIGINTERN void
61517 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
61518 swig_varlinkobject *v = (swig_varlinkobject *) p;
61519 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
61520 if (gv) {
61521 size_t size = strlen(name)+1;
61522 gv->name = (char *)malloc(size);
61523 if (gv->name) {
61524 strncpy(gv->name,name,size);
61525 gv->get_attr = get_attr;
61526 gv->set_attr = set_attr;
61527 gv->next = v->vars;
61528 }
61529 }
61530 v->vars = gv;
61531 }
61532
61533 SWIGINTERN PyObject *
61534 SWIG_globals() {
61535 static PyObject *_SWIG_globals = 0;
61536 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
61537 return _SWIG_globals;
61538 }
61539
61540 /* -----------------------------------------------------------------------------
61541 * constants/methods manipulation
61542 * ----------------------------------------------------------------------------- */
61543
61544 /* Install Constants */
61545 SWIGINTERN void
61546 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
61547 PyObject *obj = 0;
61548 size_t i;
61549 for (i = 0; constants[i].type; ++i) {
61550 switch(constants[i].type) {
61551 case SWIG_PY_POINTER:
61552 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
61553 break;
61554 case SWIG_PY_BINARY:
61555 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
61556 break;
61557 default:
61558 obj = 0;
61559 break;
61560 }
61561 if (obj) {
61562 PyDict_SetItemString(d, constants[i].name, obj);
61563 Py_DECREF(obj);
61564 }
61565 }
61566 }
61567
61568 /* -----------------------------------------------------------------------------*/
61569 /* Fix SwigMethods to carry the callback ptrs when needed */
61570 /* -----------------------------------------------------------------------------*/
61571
61572 SWIGINTERN void
61573 SWIG_Python_FixMethods(PyMethodDef *methods,
61574 swig_const_info *const_table,
61575 swig_type_info **types,
61576 swig_type_info **types_initial) {
61577 size_t i;
61578 for (i = 0; methods[i].ml_name; ++i) {
61579 const char *c = methods[i].ml_doc;
61580 if (c && (c = strstr(c, "swig_ptr: "))) {
61581 int j;
61582 swig_const_info *ci = 0;
61583 const char *name = c + 10;
61584 for (j = 0; const_table[j].type; ++j) {
61585 if (strncmp(const_table[j].name, name,
61586 strlen(const_table[j].name)) == 0) {
61587 ci = &(const_table[j]);
61588 break;
61589 }
61590 }
61591 if (ci) {
61592 size_t shift = (ci->ptype) - types;
61593 swig_type_info *ty = types_initial[shift];
61594 size_t ldoc = (c - methods[i].ml_doc);
61595 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
61596 char *ndoc = (char*)malloc(ldoc + lptr + 10);
61597 if (ndoc) {
61598 char *buff = ndoc;
61599 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
61600 if (ptr) {
61601 strncpy(buff, methods[i].ml_doc, ldoc);
61602 buff += ldoc;
61603 strncpy(buff, "swig_ptr: ", 10);
61604 buff += 10;
61605 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
61606 methods[i].ml_doc = ndoc;
61607 }
61608 }
61609 }
61610 }
61611 }
61612 }
61613
61614 #ifdef __cplusplus
61615 }
61616 #endif
61617
61618 /* -----------------------------------------------------------------------------*
61619 * Partial Init method
61620 * -----------------------------------------------------------------------------*/
61621
61622 #ifdef __cplusplus
61623 extern "C"
61624 #endif
61625 SWIGEXPORT void SWIG_init(void) {
61626 PyObject *m, *d;
61627
61628 /* Fix SwigMethods to carry the callback ptrs when needed */
61629 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
61630
61631 m = Py_InitModule((char *) SWIG_name, SwigMethods);
61632 d = PyModule_GetDict(m);
61633
61634 SWIG_InitializeModule(0);
61635 SWIG_InstallConstants(d,swig_const_table);
61636
61637
61638
61639 #ifndef wxPyUSE_EXPORT
61640 // Make our API structure a CObject so other modules can import it
61641 // from this module.
61642 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
61643 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
61644 Py_XDECREF(cobj);
61645 #endif
61646
61647 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
61648 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
61649 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
61650 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
61651 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
61652 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
61653 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
61654 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
61655 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
61656 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
61657 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
61658 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
61659 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
61660 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
61661 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
61662 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
61663 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
61664 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
61665 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
61666 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
61667 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
61668 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
61669 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
61670 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
61671 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
61672 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
61673 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
61674 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
61675 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
61676 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
61677 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
61678 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
61679 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
61680 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
61681 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
61682 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
61683 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
61684 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
61685 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
61686 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
61687 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
61688 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
61689 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
61690 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
61691 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
61692 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
61693 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
61694 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
61695 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
61696 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
61697 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
61698 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
61699 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
61700 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
61701 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
61702 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
61703 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
61704 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
61705 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
61706 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
61707 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
61708 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
61709 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
61710 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
61711 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
61712 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
61713 SWIG_Python_SetConstant(d, "APPLY",SWIG_From_int(static_cast< int >(wxAPPLY)));
61714 SWIG_Python_SetConstant(d, "CLOSE",SWIG_From_int(static_cast< int >(wxCLOSE)));
61715 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
61716 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
61717 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
61718 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
61719 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
61720 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
61721 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
61722 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
61723 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
61724 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
61725 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
61726 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
61727 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
61728 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
61729 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
61730 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
61731 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
61732 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
61733 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
61734 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
61735 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
61736 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
61737 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
61738 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
61739 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
61740 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
61741 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
61742 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
61743 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
61744 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
61745 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
61746 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
61747 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
61748 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
61749 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
61750 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
61751 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
61752 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
61753 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
61754 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
61755 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
61756 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
61757 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
61758 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
61759 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
61760 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
61761 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
61762 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
61763 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
61764 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
61765 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
61766 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
61767 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
61768 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
61769 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
61770 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
61771 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
61772 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
61773 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
61774 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
61775 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
61776 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
61777 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
61778 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
61779 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
61780 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
61781 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
61782 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
61783 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
61784 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
61785 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
61786 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
61787 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
61788 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
61789 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
61790 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
61791 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
61792 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
61793 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
61794 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
61795 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
61796 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
61797 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
61798 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
61799 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
61800 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
61801 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
61802 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
61803 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
61804 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
61805 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
61806 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
61807 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
61808 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
61809 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
61810 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
61811 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
61812 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
61813 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
61814 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
61815 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
61816 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
61817 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
61818 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
61819 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
61820 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
61821 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
61822 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
61823 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
61824 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
61825 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
61826 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
61827 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
61828 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
61829 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
61830 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
61831 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
61832 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
61833 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
61834 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
61835 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
61836 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
61837 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
61838 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
61839 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
61840 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
61841 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
61842 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
61843 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
61844 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
61845 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
61846 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
61847 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
61848 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
61849 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
61850 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
61851 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
61852 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
61853 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
61854 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
61855 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
61856 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
61857 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
61858 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
61859 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
61860 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
61861 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
61862 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
61863 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
61864 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
61865 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
61866 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
61867 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
61868 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
61869 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
61870 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
61871 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
61872 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
61873 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
61874 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
61875 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
61876 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
61877 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
61878 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
61879 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
61880 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
61881 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
61882 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
61883 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
61884 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
61885 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
61886 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
61887 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
61888 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
61889 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
61890 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
61891 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
61892 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
61893 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
61894 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
61895 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
61896 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
61897 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
61898 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
61899 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
61900 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
61901 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
61902 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
61903 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
61904 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
61905 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
61906 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
61907 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
61908 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
61909 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
61910 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
61911 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
61912 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
61913 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
61914 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
61915 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
61916 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
61917 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
61918 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
61919 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
61920 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
61921 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
61922 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
61923 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
61924 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
61925 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
61926 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
61927 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
61928 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
61929 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
61930 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
61931 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
61932 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
61933 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
61934 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
61935 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
61936 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
61937 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
61938 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
61939 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
61940 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
61941 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
61942 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
61943 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
61944 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
61945 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
61946 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
61947 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
61948 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
61949 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
61950 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
61951 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
61952 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
61953 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
61954 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
61955 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
61956 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
61957 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
61958 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
61959 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
61960 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
61961 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
61962 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
61963 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
61964 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
61965 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
61966 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
61967 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
61968 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
61969 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
61970 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
61971 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
61972 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
61973 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
61974 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
61975 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
61976 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
61977 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
61978 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
61979 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
61980 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
61981 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
61982 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
61983 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
61984 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
61985 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
61986 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
61987 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
61988 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
61989 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
61990 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
61991 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
61992 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
61993 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
61994 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
61995 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
61996 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
61997 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
61998 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
61999 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
62000 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
62001 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
62002 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
62003 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
62004 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
62005 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
62006 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
62007 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
62008 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
62009 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
62010 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
62011 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
62012 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
62013 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
62014 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
62015 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
62016 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
62017 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
62018 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
62019 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
62020 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
62021 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
62022 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
62023 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
62024 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
62025 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
62026 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
62027 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
62028 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
62029 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
62030 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
62031 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
62032 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
62033 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
62034 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
62035 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
62036 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
62037 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
62038 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
62039 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
62040 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
62041 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
62042 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
62043 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
62044 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
62045 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
62046 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
62047 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
62048 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
62049 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
62050 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
62051 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
62052 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
62053 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
62054 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
62055 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
62056 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
62057 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
62058 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
62059 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
62060 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
62061 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
62062 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
62063 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
62064 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
62065 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
62066 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
62067 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
62068 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
62069 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
62070 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
62071 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
62072 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
62073 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
62074 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
62075 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
62076 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
62077 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
62078 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
62079 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
62080 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
62081 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
62082 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
62083 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
62084 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
62085 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
62086 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
62087 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
62088 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
62089 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
62090 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
62091 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
62092 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
62093 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
62094 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
62095 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
62096 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
62097 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
62098 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
62099 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
62100 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
62101 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
62102 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
62103 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
62104 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
62105 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
62106 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
62107 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
62108 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
62109 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
62110 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
62111 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
62112 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
62113 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
62114 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
62115 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
62116 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
62117 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
62118 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
62119 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
62120 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
62121 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
62122 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
62123 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
62124 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
62125 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
62126 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
62127 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
62128 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
62129 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
62130 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
62131 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
62132 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
62133 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
62134 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
62135 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
62136 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
62137 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
62138 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
62139 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
62140 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
62141 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
62142 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
62143 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
62144 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
62145 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
62146 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
62147 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
62148 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
62149 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
62150 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
62151 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
62152 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
62153 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
62154 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
62155 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
62156 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
62157 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
62158 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
62159 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
62160 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
62161 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
62162 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
62163 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
62164 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
62165 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
62166 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
62167 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
62168 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
62169 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
62170 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
62171 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
62172 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
62173 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
62174 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
62175 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
62176 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
62177 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
62178 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
62179 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
62180 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
62181 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
62182 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
62183 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
62184 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
62185 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
62186 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
62187 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
62188 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
62189 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
62190 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
62191 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
62192 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
62193 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
62194 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
62195 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
62196 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
62197 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
62198 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
62199 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
62200 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
62201 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
62202 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
62203 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
62204 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
62205 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
62206 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
62207 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
62208 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
62209 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
62210 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
62211 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
62212 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
62213 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
62214 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
62215 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
62216 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
62217 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
62218 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
62219 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
62220 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
62221 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
62222 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
62223 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
62224 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
62225 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
62226 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
62227 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
62228 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
62229 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
62230 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
62231 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
62232 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
62233 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
62234 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
62235 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
62236 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
62237 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
62238 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
62239 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
62240 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
62241 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
62242 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
62243 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
62244 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
62245 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
62246 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
62247 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
62248 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
62249 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
62250 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
62251 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
62252 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
62253 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
62254 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
62255 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
62256 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
62257 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
62258 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
62259 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
62260 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TGA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TGA)));
62261 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
62262 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
62263 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
62264 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
62265 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
62266 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
62267 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
62268 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
62269 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
62270 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
62271 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
62272 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
62273 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
62274 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
62275 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
62276 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
62277 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
62278 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
62279 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
62280 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
62281 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
62282 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
62283 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
62284 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
62285 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
62286 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
62287 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
62288 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
62289 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
62290 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
62291 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
62292 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
62293 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
62294 SWIG_Python_SetConstant(d, "Inside",SWIG_From_int(static_cast< int >(wxInside)));
62295 SWIG_Python_SetConstant(d, "OutLeft",SWIG_From_int(static_cast< int >(wxOutLeft)));
62296 SWIG_Python_SetConstant(d, "OutRight",SWIG_From_int(static_cast< int >(wxOutRight)));
62297 SWIG_Python_SetConstant(d, "OutTop",SWIG_From_int(static_cast< int >(wxOutTop)));
62298 SWIG_Python_SetConstant(d, "OutBottom",SWIG_From_int(static_cast< int >(wxOutBottom)));
62299 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
62300 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
62301 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
62302 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
62303 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
62304
62305 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
62306
62307
62308 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
62309
62310 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
62311 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
62312 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
62313 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
62314 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
62315 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
62316 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
62317 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
62318 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
62319 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
62320 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
62321 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
62322 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
62323 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
62324 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
62325 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_NONE",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_NONE)));
62326 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
62327 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
62328 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
62329 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
62330 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
62331 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
62332 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
62333 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
62334 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
62335 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
62336 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
62337 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
62338 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
62339 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
62340 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
62341 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
62342 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
62343 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
62344 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
62345 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
62346 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
62347 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
62348 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
62349 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
62350 PyDict_SetItemString(d, "wxEVT_ANY", PyInt_FromLong(wxEVT_ANY));
62351 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
62352 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
62353 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
62354 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
62355 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
62356 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
62357 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
62358 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
62359 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
62360 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
62361 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
62362 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
62363 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
62364 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
62365 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
62366 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
62367 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
62368 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
62369 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
62370 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
62371 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
62372 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
62373 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
62374 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
62375 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
62376 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
62377 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
62378 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
62379 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
62380 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
62381 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
62382 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
62383 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
62384 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
62385 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
62386 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
62387 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
62388 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
62389 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
62390 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
62391 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
62392 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
62393 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
62394 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
62395 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
62396 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
62397 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
62398 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
62399 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
62400 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
62401 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
62402 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
62403 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
62404 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
62405 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
62406 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
62407 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
62408 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
62409 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
62410 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
62411 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
62412 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
62413 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
62414 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
62415 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
62416 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
62417 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
62418 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
62419 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
62420 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
62421 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
62422 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
62423 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
62424 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
62425 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
62426 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
62427 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
62428 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
62429 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
62430 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
62431 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
62432 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
62433 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
62434 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
62435 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
62436 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
62437 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
62438 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
62439 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
62440 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
62441 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
62442 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
62443 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
62444 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
62445 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
62446 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
62447 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
62448 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
62449 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
62450 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
62451 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
62452 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
62453 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
62454 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
62455 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
62456 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
62457 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
62458 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
62459 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
62460 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
62461 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
62462 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
62463 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
62464 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
62465 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
62466 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
62467 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
62468 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
62469 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
62470 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
62471 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
62472 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
62473 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
62474 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
62475 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
62476 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
62477 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
62478 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
62479 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
62480 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
62481 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
62482 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
62483 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
62484 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
62485 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
62486 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
62487 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
62488 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
62489 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
62490 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
62491 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
62492 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
62493 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
62494 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
62495 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
62496 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
62497 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
62498 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
62499 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
62500 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
62501 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
62502 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
62503 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
62504 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
62505 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
62506 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
62507 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
62508 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
62509 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
62510 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
62511 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
62512 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
62513 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
62514 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
62515 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
62516 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
62517 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
62518 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
62519 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
62520 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
62521 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
62522 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
62523 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
62524 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
62525 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
62526
62527 // Initialize threading, some globals and such
62528 __wxPyPreStart(d);
62529
62530
62531 // Although these are defined in __version__ they need to be here too so
62532 // that an assert can be done to ensure that the wxPython and the wxWindows
62533 // versions match.
62534 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
62535 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
62536 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
62537
62538 }
62539
wxWidgets (Impactor)