]> 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
Patch from FN that fixes bug in RefreshItem on an item that has no
[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_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36626 PyObject *resultobj = 0;
36627 wxWindow *arg1 = (wxWindow *) 0 ;
36628 bool arg2 = (bool) true ;
36629 void *argp1 = 0 ;
36630 int res1 = 0 ;
36631 bool val2 ;
36632 int ecode2 = 0 ;
36633 PyObject * obj0 = 0 ;
36634 PyObject * obj1 = 0 ;
36635 char * kwnames[] = {
36636 (char *) "self",(char *) "modal", NULL
36637 };
36638
36639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
36640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36641 if (!SWIG_IsOK(res1)) {
36642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
36643 }
36644 arg1 = reinterpret_cast< wxWindow * >(argp1);
36645 if (obj1) {
36646 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36647 if (!SWIG_IsOK(ecode2)) {
36648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
36649 }
36650 arg2 = static_cast< bool >(val2);
36651 }
36652 {
36653 PyThreadState* __tstate = wxPyBeginAllowThreads();
36654 (arg1)->MakeModal(arg2);
36655 wxPyEndAllowThreads(__tstate);
36656 if (PyErr_Occurred()) SWIG_fail;
36657 }
36658 resultobj = SWIG_Py_Void();
36659 return resultobj;
36660 fail:
36661 return NULL;
36662 }
36663
36664
36665 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36666 PyObject *resultobj = 0;
36667 wxWindow *arg1 = (wxWindow *) 0 ;
36668 bool arg2 ;
36669 void *argp1 = 0 ;
36670 int res1 = 0 ;
36671 bool val2 ;
36672 int ecode2 = 0 ;
36673 PyObject * obj0 = 0 ;
36674 PyObject * obj1 = 0 ;
36675 char * kwnames[] = {
36676 (char *) "self",(char *) "enableTheme", NULL
36677 };
36678
36679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
36680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36681 if (!SWIG_IsOK(res1)) {
36682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
36683 }
36684 arg1 = reinterpret_cast< wxWindow * >(argp1);
36685 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36686 if (!SWIG_IsOK(ecode2)) {
36687 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
36688 }
36689 arg2 = static_cast< bool >(val2);
36690 {
36691 PyThreadState* __tstate = wxPyBeginAllowThreads();
36692 (arg1)->SetThemeEnabled(arg2);
36693 wxPyEndAllowThreads(__tstate);
36694 if (PyErr_Occurred()) SWIG_fail;
36695 }
36696 resultobj = SWIG_Py_Void();
36697 return resultobj;
36698 fail:
36699 return NULL;
36700 }
36701
36702
36703 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36704 PyObject *resultobj = 0;
36705 wxWindow *arg1 = (wxWindow *) 0 ;
36706 bool result;
36707 void *argp1 = 0 ;
36708 int res1 = 0 ;
36709 PyObject *swig_obj[1] ;
36710
36711 if (!args) SWIG_fail;
36712 swig_obj[0] = args;
36713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36714 if (!SWIG_IsOK(res1)) {
36715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
36716 }
36717 arg1 = reinterpret_cast< wxWindow * >(argp1);
36718 {
36719 PyThreadState* __tstate = wxPyBeginAllowThreads();
36720 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
36721 wxPyEndAllowThreads(__tstate);
36722 if (PyErr_Occurred()) SWIG_fail;
36723 }
36724 {
36725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36726 }
36727 return resultobj;
36728 fail:
36729 return NULL;
36730 }
36731
36732
36733 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36734 PyObject *resultobj = 0;
36735 wxWindow *arg1 = (wxWindow *) 0 ;
36736 void *argp1 = 0 ;
36737 int res1 = 0 ;
36738 PyObject *swig_obj[1] ;
36739
36740 if (!args) SWIG_fail;
36741 swig_obj[0] = args;
36742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36743 if (!SWIG_IsOK(res1)) {
36744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
36745 }
36746 arg1 = reinterpret_cast< wxWindow * >(argp1);
36747 {
36748 PyThreadState* __tstate = wxPyBeginAllowThreads();
36749 (arg1)->SetFocus();
36750 wxPyEndAllowThreads(__tstate);
36751 if (PyErr_Occurred()) SWIG_fail;
36752 }
36753 resultobj = SWIG_Py_Void();
36754 return resultobj;
36755 fail:
36756 return NULL;
36757 }
36758
36759
36760 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36761 PyObject *resultobj = 0;
36762 wxWindow *arg1 = (wxWindow *) 0 ;
36763 void *argp1 = 0 ;
36764 int res1 = 0 ;
36765 PyObject *swig_obj[1] ;
36766
36767 if (!args) SWIG_fail;
36768 swig_obj[0] = args;
36769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36770 if (!SWIG_IsOK(res1)) {
36771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
36772 }
36773 arg1 = reinterpret_cast< wxWindow * >(argp1);
36774 {
36775 PyThreadState* __tstate = wxPyBeginAllowThreads();
36776 (arg1)->SetFocusFromKbd();
36777 wxPyEndAllowThreads(__tstate);
36778 if (PyErr_Occurred()) SWIG_fail;
36779 }
36780 resultobj = SWIG_Py_Void();
36781 return resultobj;
36782 fail:
36783 return NULL;
36784 }
36785
36786
36787 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36788 PyObject *resultobj = 0;
36789 wxWindow *result = 0 ;
36790
36791 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
36792 {
36793 if (!wxPyCheckForApp()) SWIG_fail;
36794 PyThreadState* __tstate = wxPyBeginAllowThreads();
36795 result = (wxWindow *)wxWindow::FindFocus();
36796 wxPyEndAllowThreads(__tstate);
36797 if (PyErr_Occurred()) SWIG_fail;
36798 }
36799 {
36800 resultobj = wxPyMake_wxObject(result, 0);
36801 }
36802 return resultobj;
36803 fail:
36804 return NULL;
36805 }
36806
36807
36808 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36809 PyObject *resultobj = 0;
36810 wxWindow *arg1 = (wxWindow *) 0 ;
36811 bool result;
36812 void *argp1 = 0 ;
36813 int res1 = 0 ;
36814 PyObject *swig_obj[1] ;
36815
36816 if (!args) SWIG_fail;
36817 swig_obj[0] = args;
36818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36819 if (!SWIG_IsOK(res1)) {
36820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36821 }
36822 arg1 = reinterpret_cast< wxWindow * >(argp1);
36823 {
36824 PyThreadState* __tstate = wxPyBeginAllowThreads();
36825 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
36826 wxPyEndAllowThreads(__tstate);
36827 if (PyErr_Occurred()) SWIG_fail;
36828 }
36829 {
36830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36831 }
36832 return resultobj;
36833 fail:
36834 return NULL;
36835 }
36836
36837
36838 SWIGINTERN PyObject *_wrap_Window_CanAcceptFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36839 PyObject *resultobj = 0;
36840 wxWindow *arg1 = (wxWindow *) 0 ;
36841 bool result;
36842 void *argp1 = 0 ;
36843 int res1 = 0 ;
36844 PyObject *swig_obj[1] ;
36845
36846 if (!args) SWIG_fail;
36847 swig_obj[0] = args;
36848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36849 if (!SWIG_IsOK(res1)) {
36850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanAcceptFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36851 }
36852 arg1 = reinterpret_cast< wxWindow * >(argp1);
36853 {
36854 PyThreadState* __tstate = wxPyBeginAllowThreads();
36855 result = (bool)((wxWindow const *)arg1)->CanAcceptFocus();
36856 wxPyEndAllowThreads(__tstate);
36857 if (PyErr_Occurred()) SWIG_fail;
36858 }
36859 {
36860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36861 }
36862 return resultobj;
36863 fail:
36864 return NULL;
36865 }
36866
36867
36868 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36869 PyObject *resultobj = 0;
36870 wxWindow *arg1 = (wxWindow *) 0 ;
36871 bool result;
36872 void *argp1 = 0 ;
36873 int res1 = 0 ;
36874 PyObject *swig_obj[1] ;
36875
36876 if (!args) SWIG_fail;
36877 swig_obj[0] = args;
36878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36879 if (!SWIG_IsOK(res1)) {
36880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36881 }
36882 arg1 = reinterpret_cast< wxWindow * >(argp1);
36883 {
36884 PyThreadState* __tstate = wxPyBeginAllowThreads();
36885 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
36886 wxPyEndAllowThreads(__tstate);
36887 if (PyErr_Occurred()) SWIG_fail;
36888 }
36889 {
36890 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36891 }
36892 return resultobj;
36893 fail:
36894 return NULL;
36895 }
36896
36897
36898 SWIGINTERN PyObject *_wrap_Window_CanAcceptFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36899 PyObject *resultobj = 0;
36900 wxWindow *arg1 = (wxWindow *) 0 ;
36901 bool result;
36902 void *argp1 = 0 ;
36903 int res1 = 0 ;
36904 PyObject *swig_obj[1] ;
36905
36906 if (!args) SWIG_fail;
36907 swig_obj[0] = args;
36908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36909 if (!SWIG_IsOK(res1)) {
36910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanAcceptFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36911 }
36912 arg1 = reinterpret_cast< wxWindow * >(argp1);
36913 {
36914 PyThreadState* __tstate = wxPyBeginAllowThreads();
36915 result = (bool)((wxWindow const *)arg1)->CanAcceptFocusFromKeyboard();
36916 wxPyEndAllowThreads(__tstate);
36917 if (PyErr_Occurred()) SWIG_fail;
36918 }
36919 {
36920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36921 }
36922 return resultobj;
36923 fail:
36924 return NULL;
36925 }
36926
36927
36928 SWIGINTERN PyObject *_wrap_Window_SetCanFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36929 PyObject *resultobj = 0;
36930 wxWindow *arg1 = (wxWindow *) 0 ;
36931 bool arg2 ;
36932 void *argp1 = 0 ;
36933 int res1 = 0 ;
36934 bool val2 ;
36935 int ecode2 = 0 ;
36936 PyObject * obj0 = 0 ;
36937 PyObject * obj1 = 0 ;
36938 char * kwnames[] = {
36939 (char *) "self",(char *) "canFocus", NULL
36940 };
36941
36942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCanFocus",kwnames,&obj0,&obj1)) SWIG_fail;
36943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36944 if (!SWIG_IsOK(res1)) {
36945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCanFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
36946 }
36947 arg1 = reinterpret_cast< wxWindow * >(argp1);
36948 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36949 if (!SWIG_IsOK(ecode2)) {
36950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetCanFocus" "', expected argument " "2"" of type '" "bool""'");
36951 }
36952 arg2 = static_cast< bool >(val2);
36953 {
36954 PyThreadState* __tstate = wxPyBeginAllowThreads();
36955 (arg1)->SetCanFocus(arg2);
36956 wxPyEndAllowThreads(__tstate);
36957 if (PyErr_Occurred()) SWIG_fail;
36958 }
36959 resultobj = SWIG_Py_Void();
36960 return resultobj;
36961 fail:
36962 return NULL;
36963 }
36964
36965
36966 SWIGINTERN PyObject *_wrap_Window_NavigateIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36967 PyObject *resultobj = 0;
36968 wxWindow *arg1 = (wxWindow *) 0 ;
36969 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
36970 bool result;
36971 void *argp1 = 0 ;
36972 int res1 = 0 ;
36973 int val2 ;
36974 int ecode2 = 0 ;
36975 PyObject * obj0 = 0 ;
36976 PyObject * obj1 = 0 ;
36977 char * kwnames[] = {
36978 (char *) "self",(char *) "flags", NULL
36979 };
36980
36981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_NavigateIn",kwnames,&obj0,&obj1)) SWIG_fail;
36982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36983 if (!SWIG_IsOK(res1)) {
36984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_NavigateIn" "', expected argument " "1"" of type '" "wxWindow *""'");
36985 }
36986 arg1 = reinterpret_cast< wxWindow * >(argp1);
36987 if (obj1) {
36988 ecode2 = SWIG_AsVal_int(obj1, &val2);
36989 if (!SWIG_IsOK(ecode2)) {
36990 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_NavigateIn" "', expected argument " "2"" of type '" "int""'");
36991 }
36992 arg2 = static_cast< int >(val2);
36993 }
36994 {
36995 PyThreadState* __tstate = wxPyBeginAllowThreads();
36996 result = (bool)(arg1)->NavigateIn(arg2);
36997 wxPyEndAllowThreads(__tstate);
36998 if (PyErr_Occurred()) SWIG_fail;
36999 }
37000 {
37001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37002 }
37003 return resultobj;
37004 fail:
37005 return NULL;
37006 }
37007
37008
37009 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37010 PyObject *resultobj = 0;
37011 wxWindow *arg1 = (wxWindow *) 0 ;
37012 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
37013 bool result;
37014 void *argp1 = 0 ;
37015 int res1 = 0 ;
37016 int val2 ;
37017 int ecode2 = 0 ;
37018 PyObject * obj0 = 0 ;
37019 PyObject * obj1 = 0 ;
37020 char * kwnames[] = {
37021 (char *) "self",(char *) "flags", NULL
37022 };
37023
37024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
37025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37026 if (!SWIG_IsOK(res1)) {
37027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
37028 }
37029 arg1 = reinterpret_cast< wxWindow * >(argp1);
37030 if (obj1) {
37031 ecode2 = SWIG_AsVal_int(obj1, &val2);
37032 if (!SWIG_IsOK(ecode2)) {
37033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
37034 }
37035 arg2 = static_cast< int >(val2);
37036 }
37037 {
37038 PyThreadState* __tstate = wxPyBeginAllowThreads();
37039 result = (bool)(arg1)->Navigate(arg2);
37040 wxPyEndAllowThreads(__tstate);
37041 if (PyErr_Occurred()) SWIG_fail;
37042 }
37043 {
37044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37045 }
37046 return resultobj;
37047 fail:
37048 return NULL;
37049 }
37050
37051
37052 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37053 PyObject *resultobj = 0;
37054 wxWindow *arg1 = (wxWindow *) 0 ;
37055 wxWindow *arg2 = (wxWindow *) 0 ;
37056 void *argp1 = 0 ;
37057 int res1 = 0 ;
37058 void *argp2 = 0 ;
37059 int res2 = 0 ;
37060 PyObject * obj0 = 0 ;
37061 PyObject * obj1 = 0 ;
37062 char * kwnames[] = {
37063 (char *) "self",(char *) "win", NULL
37064 };
37065
37066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
37067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37068 if (!SWIG_IsOK(res1)) {
37069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
37070 }
37071 arg1 = reinterpret_cast< wxWindow * >(argp1);
37072 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37073 if (!SWIG_IsOK(res2)) {
37074 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
37075 }
37076 arg2 = reinterpret_cast< wxWindow * >(argp2);
37077 {
37078 PyThreadState* __tstate = wxPyBeginAllowThreads();
37079 (arg1)->MoveAfterInTabOrder(arg2);
37080 wxPyEndAllowThreads(__tstate);
37081 if (PyErr_Occurred()) SWIG_fail;
37082 }
37083 resultobj = SWIG_Py_Void();
37084 return resultobj;
37085 fail:
37086 return NULL;
37087 }
37088
37089
37090 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37091 PyObject *resultobj = 0;
37092 wxWindow *arg1 = (wxWindow *) 0 ;
37093 wxWindow *arg2 = (wxWindow *) 0 ;
37094 void *argp1 = 0 ;
37095 int res1 = 0 ;
37096 void *argp2 = 0 ;
37097 int res2 = 0 ;
37098 PyObject * obj0 = 0 ;
37099 PyObject * obj1 = 0 ;
37100 char * kwnames[] = {
37101 (char *) "self",(char *) "win", NULL
37102 };
37103
37104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
37105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37106 if (!SWIG_IsOK(res1)) {
37107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
37108 }
37109 arg1 = reinterpret_cast< wxWindow * >(argp1);
37110 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37111 if (!SWIG_IsOK(res2)) {
37112 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
37113 }
37114 arg2 = reinterpret_cast< wxWindow * >(argp2);
37115 {
37116 PyThreadState* __tstate = wxPyBeginAllowThreads();
37117 (arg1)->MoveBeforeInTabOrder(arg2);
37118 wxPyEndAllowThreads(__tstate);
37119 if (PyErr_Occurred()) SWIG_fail;
37120 }
37121 resultobj = SWIG_Py_Void();
37122 return resultobj;
37123 fail:
37124 return NULL;
37125 }
37126
37127
37128 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37129 PyObject *resultobj = 0;
37130 wxWindow *arg1 = (wxWindow *) 0 ;
37131 PyObject *result = 0 ;
37132 void *argp1 = 0 ;
37133 int res1 = 0 ;
37134 PyObject *swig_obj[1] ;
37135
37136 if (!args) SWIG_fail;
37137 swig_obj[0] = args;
37138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37139 if (!SWIG_IsOK(res1)) {
37140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
37141 }
37142 arg1 = reinterpret_cast< wxWindow * >(argp1);
37143 {
37144 PyThreadState* __tstate = wxPyBeginAllowThreads();
37145 result = (PyObject *)wxWindow_GetChildren(arg1);
37146 wxPyEndAllowThreads(__tstate);
37147 if (PyErr_Occurred()) SWIG_fail;
37148 }
37149 resultobj = result;
37150 return resultobj;
37151 fail:
37152 return NULL;
37153 }
37154
37155
37156 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37157 PyObject *resultobj = 0;
37158 wxWindow *arg1 = (wxWindow *) 0 ;
37159 wxWindow *result = 0 ;
37160 void *argp1 = 0 ;
37161 int res1 = 0 ;
37162 PyObject *swig_obj[1] ;
37163
37164 if (!args) SWIG_fail;
37165 swig_obj[0] = args;
37166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37167 if (!SWIG_IsOK(res1)) {
37168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
37169 }
37170 arg1 = reinterpret_cast< wxWindow * >(argp1);
37171 {
37172 PyThreadState* __tstate = wxPyBeginAllowThreads();
37173 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
37174 wxPyEndAllowThreads(__tstate);
37175 if (PyErr_Occurred()) SWIG_fail;
37176 }
37177 {
37178 resultobj = wxPyMake_wxObject(result, 0);
37179 }
37180 return resultobj;
37181 fail:
37182 return NULL;
37183 }
37184
37185
37186 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37187 PyObject *resultobj = 0;
37188 wxWindow *arg1 = (wxWindow *) 0 ;
37189 wxWindow *result = 0 ;
37190 void *argp1 = 0 ;
37191 int res1 = 0 ;
37192 PyObject *swig_obj[1] ;
37193
37194 if (!args) SWIG_fail;
37195 swig_obj[0] = args;
37196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37197 if (!SWIG_IsOK(res1)) {
37198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
37199 }
37200 arg1 = reinterpret_cast< wxWindow * >(argp1);
37201 {
37202 PyThreadState* __tstate = wxPyBeginAllowThreads();
37203 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
37204 wxPyEndAllowThreads(__tstate);
37205 if (PyErr_Occurred()) SWIG_fail;
37206 }
37207 {
37208 resultobj = wxPyMake_wxObject(result, 0);
37209 }
37210 return resultobj;
37211 fail:
37212 return NULL;
37213 }
37214
37215
37216 SWIGINTERN PyObject *_wrap_Window_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37217 PyObject *resultobj = 0;
37218 wxWindow *arg1 = (wxWindow *) 0 ;
37219 wxWindow *result = 0 ;
37220 void *argp1 = 0 ;
37221 int res1 = 0 ;
37222 PyObject *swig_obj[1] ;
37223
37224 if (!args) SWIG_fail;
37225 swig_obj[0] = args;
37226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37227 if (!SWIG_IsOK(res1)) {
37228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
37229 }
37230 arg1 = reinterpret_cast< wxWindow * >(argp1);
37231 {
37232 PyThreadState* __tstate = wxPyBeginAllowThreads();
37233 result = (wxWindow *)wxWindow_GetTopLevelParent(arg1);
37234 wxPyEndAllowThreads(__tstate);
37235 if (PyErr_Occurred()) SWIG_fail;
37236 }
37237 {
37238 resultobj = wxPyMake_wxObject(result, 0);
37239 }
37240 return resultobj;
37241 fail:
37242 return NULL;
37243 }
37244
37245
37246 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37247 PyObject *resultobj = 0;
37248 wxWindow *arg1 = (wxWindow *) 0 ;
37249 bool result;
37250 void *argp1 = 0 ;
37251 int res1 = 0 ;
37252 PyObject *swig_obj[1] ;
37253
37254 if (!args) SWIG_fail;
37255 swig_obj[0] = args;
37256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37257 if (!SWIG_IsOK(res1)) {
37258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
37259 }
37260 arg1 = reinterpret_cast< wxWindow * >(argp1);
37261 {
37262 PyThreadState* __tstate = wxPyBeginAllowThreads();
37263 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
37264 wxPyEndAllowThreads(__tstate);
37265 if (PyErr_Occurred()) SWIG_fail;
37266 }
37267 {
37268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37269 }
37270 return resultobj;
37271 fail:
37272 return NULL;
37273 }
37274
37275
37276 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37277 PyObject *resultobj = 0;
37278 wxWindow *arg1 = (wxWindow *) 0 ;
37279 wxWindow *arg2 = (wxWindow *) 0 ;
37280 bool result;
37281 void *argp1 = 0 ;
37282 int res1 = 0 ;
37283 void *argp2 = 0 ;
37284 int res2 = 0 ;
37285 PyObject * obj0 = 0 ;
37286 PyObject * obj1 = 0 ;
37287 char * kwnames[] = {
37288 (char *) "self",(char *) "newParent", NULL
37289 };
37290
37291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
37292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37293 if (!SWIG_IsOK(res1)) {
37294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
37295 }
37296 arg1 = reinterpret_cast< wxWindow * >(argp1);
37297 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37298 if (!SWIG_IsOK(res2)) {
37299 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
37300 }
37301 arg2 = reinterpret_cast< wxWindow * >(argp2);
37302 {
37303 PyThreadState* __tstate = wxPyBeginAllowThreads();
37304 result = (bool)(arg1)->Reparent(arg2);
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_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37318 PyObject *resultobj = 0;
37319 wxWindow *arg1 = (wxWindow *) 0 ;
37320 wxWindow *arg2 = (wxWindow *) 0 ;
37321 void *argp1 = 0 ;
37322 int res1 = 0 ;
37323 void *argp2 = 0 ;
37324 int res2 = 0 ;
37325 PyObject * obj0 = 0 ;
37326 PyObject * obj1 = 0 ;
37327 char * kwnames[] = {
37328 (char *) "self",(char *) "child", NULL
37329 };
37330
37331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
37332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37333 if (!SWIG_IsOK(res1)) {
37334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
37335 }
37336 arg1 = reinterpret_cast< wxWindow * >(argp1);
37337 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37338 if (!SWIG_IsOK(res2)) {
37339 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
37340 }
37341 arg2 = reinterpret_cast< wxWindow * >(argp2);
37342 {
37343 PyThreadState* __tstate = wxPyBeginAllowThreads();
37344 (arg1)->AddChild(arg2);
37345 wxPyEndAllowThreads(__tstate);
37346 if (PyErr_Occurred()) SWIG_fail;
37347 }
37348 resultobj = SWIG_Py_Void();
37349 return resultobj;
37350 fail:
37351 return NULL;
37352 }
37353
37354
37355 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37356 PyObject *resultobj = 0;
37357 wxWindow *arg1 = (wxWindow *) 0 ;
37358 wxWindow *arg2 = (wxWindow *) 0 ;
37359 void *argp1 = 0 ;
37360 int res1 = 0 ;
37361 void *argp2 = 0 ;
37362 int res2 = 0 ;
37363 PyObject * obj0 = 0 ;
37364 PyObject * obj1 = 0 ;
37365 char * kwnames[] = {
37366 (char *) "self",(char *) "child", NULL
37367 };
37368
37369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
37370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37371 if (!SWIG_IsOK(res1)) {
37372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
37373 }
37374 arg1 = reinterpret_cast< wxWindow * >(argp1);
37375 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37376 if (!SWIG_IsOK(res2)) {
37377 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
37378 }
37379 arg2 = reinterpret_cast< wxWindow * >(argp2);
37380 {
37381 PyThreadState* __tstate = wxPyBeginAllowThreads();
37382 (arg1)->RemoveChild(arg2);
37383 wxPyEndAllowThreads(__tstate);
37384 if (PyErr_Occurred()) SWIG_fail;
37385 }
37386 resultobj = SWIG_Py_Void();
37387 return resultobj;
37388 fail:
37389 return NULL;
37390 }
37391
37392
37393 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37394 PyObject *resultobj = 0;
37395 wxWindow *arg1 = (wxWindow *) 0 ;
37396 bool arg2 ;
37397 void *argp1 = 0 ;
37398 int res1 = 0 ;
37399 bool val2 ;
37400 int ecode2 = 0 ;
37401 PyObject * obj0 = 0 ;
37402 PyObject * obj1 = 0 ;
37403 char * kwnames[] = {
37404 (char *) "self",(char *) "on", NULL
37405 };
37406
37407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
37408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37409 if (!SWIG_IsOK(res1)) {
37410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
37411 }
37412 arg1 = reinterpret_cast< wxWindow * >(argp1);
37413 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37414 if (!SWIG_IsOK(ecode2)) {
37415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
37416 }
37417 arg2 = static_cast< bool >(val2);
37418 {
37419 PyThreadState* __tstate = wxPyBeginAllowThreads();
37420 wxWindow_SetDoubleBuffered(arg1,arg2);
37421 wxPyEndAllowThreads(__tstate);
37422 if (PyErr_Occurred()) SWIG_fail;
37423 }
37424 resultobj = SWIG_Py_Void();
37425 return resultobj;
37426 fail:
37427 return NULL;
37428 }
37429
37430
37431 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37432 PyObject *resultobj = 0;
37433 wxWindow *arg1 = (wxWindow *) 0 ;
37434 long arg2 ;
37435 wxWindow *result = 0 ;
37436 void *argp1 = 0 ;
37437 int res1 = 0 ;
37438 long val2 ;
37439 int ecode2 = 0 ;
37440 PyObject * obj0 = 0 ;
37441 PyObject * obj1 = 0 ;
37442 char * kwnames[] = {
37443 (char *) "self",(char *) "winid", NULL
37444 };
37445
37446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37448 if (!SWIG_IsOK(res1)) {
37449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
37450 }
37451 arg1 = reinterpret_cast< wxWindow * >(argp1);
37452 ecode2 = SWIG_AsVal_long(obj1, &val2);
37453 if (!SWIG_IsOK(ecode2)) {
37454 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
37455 }
37456 arg2 = static_cast< long >(val2);
37457 {
37458 PyThreadState* __tstate = wxPyBeginAllowThreads();
37459 result = (wxWindow *)(arg1)->FindWindow(arg2);
37460 wxPyEndAllowThreads(__tstate);
37461 if (PyErr_Occurred()) SWIG_fail;
37462 }
37463 {
37464 resultobj = wxPyMake_wxObject(result, 0);
37465 }
37466 return resultobj;
37467 fail:
37468 return NULL;
37469 }
37470
37471
37472 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37473 PyObject *resultobj = 0;
37474 wxWindow *arg1 = (wxWindow *) 0 ;
37475 wxString *arg2 = 0 ;
37476 wxWindow *result = 0 ;
37477 void *argp1 = 0 ;
37478 int res1 = 0 ;
37479 bool temp2 = false ;
37480 PyObject * obj0 = 0 ;
37481 PyObject * obj1 = 0 ;
37482 char * kwnames[] = {
37483 (char *) "self",(char *) "name", NULL
37484 };
37485
37486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37488 if (!SWIG_IsOK(res1)) {
37489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
37490 }
37491 arg1 = reinterpret_cast< wxWindow * >(argp1);
37492 {
37493 arg2 = wxString_in_helper(obj1);
37494 if (arg2 == NULL) SWIG_fail;
37495 temp2 = true;
37496 }
37497 {
37498 PyThreadState* __tstate = wxPyBeginAllowThreads();
37499 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
37500 wxPyEndAllowThreads(__tstate);
37501 if (PyErr_Occurred()) SWIG_fail;
37502 }
37503 {
37504 resultobj = wxPyMake_wxObject(result, 0);
37505 }
37506 {
37507 if (temp2)
37508 delete arg2;
37509 }
37510 return resultobj;
37511 fail:
37512 {
37513 if (temp2)
37514 delete arg2;
37515 }
37516 return NULL;
37517 }
37518
37519
37520 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37521 PyObject *resultobj = 0;
37522 wxWindow *arg1 = (wxWindow *) 0 ;
37523 wxEvtHandler *result = 0 ;
37524 void *argp1 = 0 ;
37525 int res1 = 0 ;
37526 PyObject *swig_obj[1] ;
37527
37528 if (!args) SWIG_fail;
37529 swig_obj[0] = args;
37530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37531 if (!SWIG_IsOK(res1)) {
37532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
37533 }
37534 arg1 = reinterpret_cast< wxWindow * >(argp1);
37535 {
37536 PyThreadState* __tstate = wxPyBeginAllowThreads();
37537 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
37538 wxPyEndAllowThreads(__tstate);
37539 if (PyErr_Occurred()) SWIG_fail;
37540 }
37541 {
37542 resultobj = wxPyMake_wxObject(result, 0);
37543 }
37544 return resultobj;
37545 fail:
37546 return NULL;
37547 }
37548
37549
37550 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37551 PyObject *resultobj = 0;
37552 wxWindow *arg1 = (wxWindow *) 0 ;
37553 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
37554 void *argp1 = 0 ;
37555 int res1 = 0 ;
37556 void *argp2 = 0 ;
37557 int res2 = 0 ;
37558 PyObject * obj0 = 0 ;
37559 PyObject * obj1 = 0 ;
37560 char * kwnames[] = {
37561 (char *) "self",(char *) "handler", NULL
37562 };
37563
37564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37566 if (!SWIG_IsOK(res1)) {
37567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37568 }
37569 arg1 = reinterpret_cast< wxWindow * >(argp1);
37570 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
37571 if (!SWIG_IsOK(res2)) {
37572 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
37573 }
37574 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
37575 {
37576 PyThreadState* __tstate = wxPyBeginAllowThreads();
37577 (arg1)->SetEventHandler(arg2);
37578 wxPyEndAllowThreads(__tstate);
37579 if (PyErr_Occurred()) SWIG_fail;
37580 }
37581 resultobj = SWIG_Py_Void();
37582 return resultobj;
37583 fail:
37584 return NULL;
37585 }
37586
37587
37588 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37589 PyObject *resultobj = 0;
37590 wxWindow *arg1 = (wxWindow *) 0 ;
37591 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
37592 void *argp1 = 0 ;
37593 int res1 = 0 ;
37594 void *argp2 = 0 ;
37595 int res2 = 0 ;
37596 PyObject * obj0 = 0 ;
37597 PyObject * obj1 = 0 ;
37598 char * kwnames[] = {
37599 (char *) "self",(char *) "handler", NULL
37600 };
37601
37602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37604 if (!SWIG_IsOK(res1)) {
37605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37606 }
37607 arg1 = reinterpret_cast< wxWindow * >(argp1);
37608 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
37609 if (!SWIG_IsOK(res2)) {
37610 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
37611 }
37612 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
37613 {
37614 PyThreadState* __tstate = wxPyBeginAllowThreads();
37615 (arg1)->PushEventHandler(arg2);
37616 wxPyEndAllowThreads(__tstate);
37617 if (PyErr_Occurred()) SWIG_fail;
37618 }
37619 resultobj = SWIG_Py_Void();
37620 return resultobj;
37621 fail:
37622 return NULL;
37623 }
37624
37625
37626 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37627 PyObject *resultobj = 0;
37628 wxWindow *arg1 = (wxWindow *) 0 ;
37629 bool arg2 = (bool) false ;
37630 wxEvtHandler *result = 0 ;
37631 void *argp1 = 0 ;
37632 int res1 = 0 ;
37633 bool val2 ;
37634 int ecode2 = 0 ;
37635 PyObject * obj0 = 0 ;
37636 PyObject * obj1 = 0 ;
37637 char * kwnames[] = {
37638 (char *) "self",(char *) "deleteHandler", NULL
37639 };
37640
37641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37643 if (!SWIG_IsOK(res1)) {
37644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37645 }
37646 arg1 = reinterpret_cast< wxWindow * >(argp1);
37647 if (obj1) {
37648 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37649 if (!SWIG_IsOK(ecode2)) {
37650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
37651 }
37652 arg2 = static_cast< bool >(val2);
37653 }
37654 {
37655 PyThreadState* __tstate = wxPyBeginAllowThreads();
37656 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
37657 wxPyEndAllowThreads(__tstate);
37658 if (PyErr_Occurred()) SWIG_fail;
37659 }
37660 {
37661 resultobj = wxPyMake_wxObject(result, 0);
37662 }
37663 return resultobj;
37664 fail:
37665 return NULL;
37666 }
37667
37668
37669 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37670 PyObject *resultobj = 0;
37671 wxWindow *arg1 = (wxWindow *) 0 ;
37672 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
37673 bool result;
37674 void *argp1 = 0 ;
37675 int res1 = 0 ;
37676 void *argp2 = 0 ;
37677 int res2 = 0 ;
37678 PyObject * obj0 = 0 ;
37679 PyObject * obj1 = 0 ;
37680 char * kwnames[] = {
37681 (char *) "self",(char *) "handler", NULL
37682 };
37683
37684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37686 if (!SWIG_IsOK(res1)) {
37687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37688 }
37689 arg1 = reinterpret_cast< wxWindow * >(argp1);
37690 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
37691 if (!SWIG_IsOK(res2)) {
37692 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
37693 }
37694 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
37695 {
37696 PyThreadState* __tstate = wxPyBeginAllowThreads();
37697 result = (bool)(arg1)->RemoveEventHandler(arg2);
37698 wxPyEndAllowThreads(__tstate);
37699 if (PyErr_Occurred()) SWIG_fail;
37700 }
37701 {
37702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37703 }
37704 return resultobj;
37705 fail:
37706 return NULL;
37707 }
37708
37709
37710 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37711 PyObject *resultobj = 0;
37712 wxWindow *arg1 = (wxWindow *) 0 ;
37713 wxValidator *arg2 = 0 ;
37714 void *argp1 = 0 ;
37715 int res1 = 0 ;
37716 void *argp2 = 0 ;
37717 int res2 = 0 ;
37718 PyObject * obj0 = 0 ;
37719 PyObject * obj1 = 0 ;
37720 char * kwnames[] = {
37721 (char *) "self",(char *) "validator", NULL
37722 };
37723
37724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
37725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37726 if (!SWIG_IsOK(res1)) {
37727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
37728 }
37729 arg1 = reinterpret_cast< wxWindow * >(argp1);
37730 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
37731 if (!SWIG_IsOK(res2)) {
37732 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
37733 }
37734 if (!argp2) {
37735 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
37736 }
37737 arg2 = reinterpret_cast< wxValidator * >(argp2);
37738 {
37739 PyThreadState* __tstate = wxPyBeginAllowThreads();
37740 (arg1)->SetValidator((wxValidator const &)*arg2);
37741 wxPyEndAllowThreads(__tstate);
37742 if (PyErr_Occurred()) SWIG_fail;
37743 }
37744 resultobj = SWIG_Py_Void();
37745 return resultobj;
37746 fail:
37747 return NULL;
37748 }
37749
37750
37751 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37752 PyObject *resultobj = 0;
37753 wxWindow *arg1 = (wxWindow *) 0 ;
37754 wxValidator *result = 0 ;
37755 void *argp1 = 0 ;
37756 int res1 = 0 ;
37757 PyObject *swig_obj[1] ;
37758
37759 if (!args) SWIG_fail;
37760 swig_obj[0] = args;
37761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37762 if (!SWIG_IsOK(res1)) {
37763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
37764 }
37765 arg1 = reinterpret_cast< wxWindow * >(argp1);
37766 {
37767 PyThreadState* __tstate = wxPyBeginAllowThreads();
37768 result = (wxValidator *)(arg1)->GetValidator();
37769 wxPyEndAllowThreads(__tstate);
37770 if (PyErr_Occurred()) SWIG_fail;
37771 }
37772 {
37773 resultobj = wxPyMake_wxObject(result, (bool)0);
37774 }
37775 return resultobj;
37776 fail:
37777 return NULL;
37778 }
37779
37780
37781 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37782 PyObject *resultobj = 0;
37783 wxWindow *arg1 = (wxWindow *) 0 ;
37784 bool result;
37785 void *argp1 = 0 ;
37786 int res1 = 0 ;
37787 PyObject *swig_obj[1] ;
37788
37789 if (!args) SWIG_fail;
37790 swig_obj[0] = args;
37791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37792 if (!SWIG_IsOK(res1)) {
37793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
37794 }
37795 arg1 = reinterpret_cast< wxWindow * >(argp1);
37796 {
37797 PyThreadState* __tstate = wxPyBeginAllowThreads();
37798 result = (bool)(arg1)->Validate();
37799 wxPyEndAllowThreads(__tstate);
37800 if (PyErr_Occurred()) SWIG_fail;
37801 }
37802 {
37803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37804 }
37805 return resultobj;
37806 fail:
37807 return NULL;
37808 }
37809
37810
37811 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37812 PyObject *resultobj = 0;
37813 wxWindow *arg1 = (wxWindow *) 0 ;
37814 bool result;
37815 void *argp1 = 0 ;
37816 int res1 = 0 ;
37817 PyObject *swig_obj[1] ;
37818
37819 if (!args) SWIG_fail;
37820 swig_obj[0] = args;
37821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37822 if (!SWIG_IsOK(res1)) {
37823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37824 }
37825 arg1 = reinterpret_cast< wxWindow * >(argp1);
37826 {
37827 PyThreadState* __tstate = wxPyBeginAllowThreads();
37828 result = (bool)(arg1)->TransferDataToWindow();
37829 wxPyEndAllowThreads(__tstate);
37830 if (PyErr_Occurred()) SWIG_fail;
37831 }
37832 {
37833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37834 }
37835 return resultobj;
37836 fail:
37837 return NULL;
37838 }
37839
37840
37841 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37842 PyObject *resultobj = 0;
37843 wxWindow *arg1 = (wxWindow *) 0 ;
37844 bool result;
37845 void *argp1 = 0 ;
37846 int res1 = 0 ;
37847 PyObject *swig_obj[1] ;
37848
37849 if (!args) SWIG_fail;
37850 swig_obj[0] = args;
37851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37852 if (!SWIG_IsOK(res1)) {
37853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37854 }
37855 arg1 = reinterpret_cast< wxWindow * >(argp1);
37856 {
37857 PyThreadState* __tstate = wxPyBeginAllowThreads();
37858 result = (bool)(arg1)->TransferDataFromWindow();
37859 wxPyEndAllowThreads(__tstate);
37860 if (PyErr_Occurred()) SWIG_fail;
37861 }
37862 {
37863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37864 }
37865 return resultobj;
37866 fail:
37867 return NULL;
37868 }
37869
37870
37871 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37872 PyObject *resultobj = 0;
37873 wxWindow *arg1 = (wxWindow *) 0 ;
37874 void *argp1 = 0 ;
37875 int res1 = 0 ;
37876 PyObject *swig_obj[1] ;
37877
37878 if (!args) SWIG_fail;
37879 swig_obj[0] = args;
37880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37881 if (!SWIG_IsOK(res1)) {
37882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37883 }
37884 arg1 = reinterpret_cast< wxWindow * >(argp1);
37885 {
37886 PyThreadState* __tstate = wxPyBeginAllowThreads();
37887 (arg1)->InitDialog();
37888 wxPyEndAllowThreads(__tstate);
37889 if (PyErr_Occurred()) SWIG_fail;
37890 }
37891 resultobj = SWIG_Py_Void();
37892 return resultobj;
37893 fail:
37894 return NULL;
37895 }
37896
37897
37898 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37899 PyObject *resultobj = 0;
37900 wxWindow *arg1 = (wxWindow *) 0 ;
37901 wxAcceleratorTable *arg2 = 0 ;
37902 void *argp1 = 0 ;
37903 int res1 = 0 ;
37904 void *argp2 = 0 ;
37905 int res2 = 0 ;
37906 PyObject * obj0 = 0 ;
37907 PyObject * obj1 = 0 ;
37908 char * kwnames[] = {
37909 (char *) "self",(char *) "accel", NULL
37910 };
37911
37912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
37913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37914 if (!SWIG_IsOK(res1)) {
37915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37916 }
37917 arg1 = reinterpret_cast< wxWindow * >(argp1);
37918 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
37919 if (!SWIG_IsOK(res2)) {
37920 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37921 }
37922 if (!argp2) {
37923 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37924 }
37925 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
37926 {
37927 PyThreadState* __tstate = wxPyBeginAllowThreads();
37928 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
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_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37940 PyObject *resultobj = 0;
37941 wxWindow *arg1 = (wxWindow *) 0 ;
37942 wxAcceleratorTable *result = 0 ;
37943 void *argp1 = 0 ;
37944 int res1 = 0 ;
37945 PyObject *swig_obj[1] ;
37946
37947 if (!args) SWIG_fail;
37948 swig_obj[0] = args;
37949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37950 if (!SWIG_IsOK(res1)) {
37951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37952 }
37953 arg1 = reinterpret_cast< wxWindow * >(argp1);
37954 {
37955 PyThreadState* __tstate = wxPyBeginAllowThreads();
37956 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
37957 wxPyEndAllowThreads(__tstate);
37958 if (PyErr_Occurred()) SWIG_fail;
37959 }
37960 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
37961 return resultobj;
37962 fail:
37963 return NULL;
37964 }
37965
37966
37967 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37968 PyObject *resultobj = 0;
37969 wxWindow *arg1 = (wxWindow *) 0 ;
37970 int arg2 ;
37971 int arg3 ;
37972 int arg4 ;
37973 bool result;
37974 void *argp1 = 0 ;
37975 int res1 = 0 ;
37976 int val2 ;
37977 int ecode2 = 0 ;
37978 int val3 ;
37979 int ecode3 = 0 ;
37980 int val4 ;
37981 int ecode4 = 0 ;
37982 PyObject * obj0 = 0 ;
37983 PyObject * obj1 = 0 ;
37984 PyObject * obj2 = 0 ;
37985 PyObject * obj3 = 0 ;
37986 char * kwnames[] = {
37987 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
37988 };
37989
37990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37992 if (!SWIG_IsOK(res1)) {
37993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37994 }
37995 arg1 = reinterpret_cast< wxWindow * >(argp1);
37996 ecode2 = SWIG_AsVal_int(obj1, &val2);
37997 if (!SWIG_IsOK(ecode2)) {
37998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
37999 }
38000 arg2 = static_cast< int >(val2);
38001 ecode3 = SWIG_AsVal_int(obj2, &val3);
38002 if (!SWIG_IsOK(ecode3)) {
38003 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
38004 }
38005 arg3 = static_cast< int >(val3);
38006 ecode4 = SWIG_AsVal_int(obj3, &val4);
38007 if (!SWIG_IsOK(ecode4)) {
38008 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
38009 }
38010 arg4 = static_cast< int >(val4);
38011 {
38012 PyThreadState* __tstate = wxPyBeginAllowThreads();
38013 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
38014 wxPyEndAllowThreads(__tstate);
38015 if (PyErr_Occurred()) SWIG_fail;
38016 }
38017 {
38018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38019 }
38020 return resultobj;
38021 fail:
38022 return NULL;
38023 }
38024
38025
38026 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38027 PyObject *resultobj = 0;
38028 wxWindow *arg1 = (wxWindow *) 0 ;
38029 int arg2 ;
38030 bool result;
38031 void *argp1 = 0 ;
38032 int res1 = 0 ;
38033 int val2 ;
38034 int ecode2 = 0 ;
38035 PyObject * obj0 = 0 ;
38036 PyObject * obj1 = 0 ;
38037 char * kwnames[] = {
38038 (char *) "self",(char *) "hotkeyId", NULL
38039 };
38040
38041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
38042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38043 if (!SWIG_IsOK(res1)) {
38044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
38045 }
38046 arg1 = reinterpret_cast< wxWindow * >(argp1);
38047 ecode2 = SWIG_AsVal_int(obj1, &val2);
38048 if (!SWIG_IsOK(ecode2)) {
38049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
38050 }
38051 arg2 = static_cast< int >(val2);
38052 {
38053 PyThreadState* __tstate = wxPyBeginAllowThreads();
38054 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
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_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38068 PyObject *resultobj = 0;
38069 wxWindow *arg1 = (wxWindow *) 0 ;
38070 wxPoint *arg2 = 0 ;
38071 wxPoint result;
38072 void *argp1 = 0 ;
38073 int res1 = 0 ;
38074 wxPoint temp2 ;
38075 PyObject * obj0 = 0 ;
38076 PyObject * obj1 = 0 ;
38077 char * kwnames[] = {
38078 (char *) "self",(char *) "pt", NULL
38079 };
38080
38081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
38082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38083 if (!SWIG_IsOK(res1)) {
38084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
38085 }
38086 arg1 = reinterpret_cast< wxWindow * >(argp1);
38087 {
38088 arg2 = &temp2;
38089 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38090 }
38091 {
38092 PyThreadState* __tstate = wxPyBeginAllowThreads();
38093 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
38094 wxPyEndAllowThreads(__tstate);
38095 if (PyErr_Occurred()) SWIG_fail;
38096 }
38097 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
38098 return resultobj;
38099 fail:
38100 return NULL;
38101 }
38102
38103
38104 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38105 PyObject *resultobj = 0;
38106 wxWindow *arg1 = (wxWindow *) 0 ;
38107 wxSize *arg2 = 0 ;
38108 wxSize result;
38109 void *argp1 = 0 ;
38110 int res1 = 0 ;
38111 wxSize temp2 ;
38112 PyObject * obj0 = 0 ;
38113 PyObject * obj1 = 0 ;
38114 char * kwnames[] = {
38115 (char *) "self",(char *) "sz", NULL
38116 };
38117
38118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
38119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38120 if (!SWIG_IsOK(res1)) {
38121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
38122 }
38123 arg1 = reinterpret_cast< wxWindow * >(argp1);
38124 {
38125 arg2 = &temp2;
38126 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38127 }
38128 {
38129 PyThreadState* __tstate = wxPyBeginAllowThreads();
38130 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
38131 wxPyEndAllowThreads(__tstate);
38132 if (PyErr_Occurred()) SWIG_fail;
38133 }
38134 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
38135 return resultobj;
38136 fail:
38137 return NULL;
38138 }
38139
38140
38141 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38142 PyObject *resultobj = 0;
38143 wxWindow *arg1 = (wxWindow *) 0 ;
38144 wxPoint *arg2 = 0 ;
38145 wxPoint result;
38146 void *argp1 = 0 ;
38147 int res1 = 0 ;
38148 wxPoint temp2 ;
38149 PyObject * obj0 = 0 ;
38150 PyObject * obj1 = 0 ;
38151 char * kwnames[] = {
38152 (char *) "self",(char *) "pt", NULL
38153 };
38154
38155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
38156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38157 if (!SWIG_IsOK(res1)) {
38158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
38159 }
38160 arg1 = reinterpret_cast< wxWindow * >(argp1);
38161 {
38162 arg2 = &temp2;
38163 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38164 }
38165 {
38166 PyThreadState* __tstate = wxPyBeginAllowThreads();
38167 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
38168 wxPyEndAllowThreads(__tstate);
38169 if (PyErr_Occurred()) SWIG_fail;
38170 }
38171 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
38172 return resultobj;
38173 fail:
38174 return NULL;
38175 }
38176
38177
38178 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38179 PyObject *resultobj = 0;
38180 wxWindow *arg1 = (wxWindow *) 0 ;
38181 wxSize *arg2 = 0 ;
38182 wxSize result;
38183 void *argp1 = 0 ;
38184 int res1 = 0 ;
38185 wxSize temp2 ;
38186 PyObject * obj0 = 0 ;
38187 PyObject * obj1 = 0 ;
38188 char * kwnames[] = {
38189 (char *) "self",(char *) "sz", NULL
38190 };
38191
38192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
38193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38194 if (!SWIG_IsOK(res1)) {
38195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
38196 }
38197 arg1 = reinterpret_cast< wxWindow * >(argp1);
38198 {
38199 arg2 = &temp2;
38200 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38201 }
38202 {
38203 PyThreadState* __tstate = wxPyBeginAllowThreads();
38204 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
38205 wxPyEndAllowThreads(__tstate);
38206 if (PyErr_Occurred()) SWIG_fail;
38207 }
38208 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
38209 return resultobj;
38210 fail:
38211 return NULL;
38212 }
38213
38214
38215 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38216 PyObject *resultobj = 0;
38217 wxWindow *arg1 = (wxWindow *) 0 ;
38218 wxPoint *arg2 = 0 ;
38219 wxPoint result;
38220 void *argp1 = 0 ;
38221 int res1 = 0 ;
38222 wxPoint temp2 ;
38223 PyObject * obj0 = 0 ;
38224 PyObject * obj1 = 0 ;
38225 char * kwnames[] = {
38226 (char *) "self",(char *) "pt", NULL
38227 };
38228
38229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
38230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38231 if (!SWIG_IsOK(res1)) {
38232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
38233 }
38234 arg1 = reinterpret_cast< wxWindow * >(argp1);
38235 {
38236 arg2 = &temp2;
38237 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38238 }
38239 {
38240 PyThreadState* __tstate = wxPyBeginAllowThreads();
38241 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
38242 wxPyEndAllowThreads(__tstate);
38243 if (PyErr_Occurred()) SWIG_fail;
38244 }
38245 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
38246 return resultobj;
38247 fail:
38248 return NULL;
38249 }
38250
38251
38252 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38253 PyObject *resultobj = 0;
38254 wxWindow *arg1 = (wxWindow *) 0 ;
38255 wxSize *arg2 = 0 ;
38256 wxSize result;
38257 void *argp1 = 0 ;
38258 int res1 = 0 ;
38259 wxSize temp2 ;
38260 PyObject * obj0 = 0 ;
38261 PyObject * obj1 = 0 ;
38262 char * kwnames[] = {
38263 (char *) "self",(char *) "sz", NULL
38264 };
38265
38266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
38267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38268 if (!SWIG_IsOK(res1)) {
38269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
38270 }
38271 arg1 = reinterpret_cast< wxWindow * >(argp1);
38272 {
38273 arg2 = &temp2;
38274 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38275 }
38276 {
38277 PyThreadState* __tstate = wxPyBeginAllowThreads();
38278 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
38279 wxPyEndAllowThreads(__tstate);
38280 if (PyErr_Occurred()) SWIG_fail;
38281 }
38282 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
38283 return resultobj;
38284 fail:
38285 return NULL;
38286 }
38287
38288
38289 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38290 PyObject *resultobj = 0;
38291 wxWindow *arg1 = (wxWindow *) 0 ;
38292 int arg2 ;
38293 int arg3 ;
38294 void *argp1 = 0 ;
38295 int res1 = 0 ;
38296 int val2 ;
38297 int ecode2 = 0 ;
38298 int val3 ;
38299 int ecode3 = 0 ;
38300 PyObject * obj0 = 0 ;
38301 PyObject * obj1 = 0 ;
38302 PyObject * obj2 = 0 ;
38303 char * kwnames[] = {
38304 (char *) "self",(char *) "x",(char *) "y", NULL
38305 };
38306
38307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) 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_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
38311 }
38312 arg1 = reinterpret_cast< wxWindow * >(argp1);
38313 ecode2 = SWIG_AsVal_int(obj1, &val2);
38314 if (!SWIG_IsOK(ecode2)) {
38315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
38316 }
38317 arg2 = static_cast< int >(val2);
38318 ecode3 = SWIG_AsVal_int(obj2, &val3);
38319 if (!SWIG_IsOK(ecode3)) {
38320 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
38321 }
38322 arg3 = static_cast< int >(val3);
38323 {
38324 PyThreadState* __tstate = wxPyBeginAllowThreads();
38325 (arg1)->WarpPointer(arg2,arg3);
38326 wxPyEndAllowThreads(__tstate);
38327 if (PyErr_Occurred()) SWIG_fail;
38328 }
38329 resultobj = SWIG_Py_Void();
38330 return resultobj;
38331 fail:
38332 return NULL;
38333 }
38334
38335
38336 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38337 PyObject *resultobj = 0;
38338 wxWindow *arg1 = (wxWindow *) 0 ;
38339 void *argp1 = 0 ;
38340 int res1 = 0 ;
38341 PyObject *swig_obj[1] ;
38342
38343 if (!args) SWIG_fail;
38344 swig_obj[0] = args;
38345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38346 if (!SWIG_IsOK(res1)) {
38347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
38348 }
38349 arg1 = reinterpret_cast< wxWindow * >(argp1);
38350 {
38351 PyThreadState* __tstate = wxPyBeginAllowThreads();
38352 (arg1)->CaptureMouse();
38353 wxPyEndAllowThreads(__tstate);
38354 if (PyErr_Occurred()) SWIG_fail;
38355 }
38356 resultobj = SWIG_Py_Void();
38357 return resultobj;
38358 fail:
38359 return NULL;
38360 }
38361
38362
38363 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38364 PyObject *resultobj = 0;
38365 wxWindow *arg1 = (wxWindow *) 0 ;
38366 void *argp1 = 0 ;
38367 int res1 = 0 ;
38368 PyObject *swig_obj[1] ;
38369
38370 if (!args) SWIG_fail;
38371 swig_obj[0] = args;
38372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38373 if (!SWIG_IsOK(res1)) {
38374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
38375 }
38376 arg1 = reinterpret_cast< wxWindow * >(argp1);
38377 {
38378 PyThreadState* __tstate = wxPyBeginAllowThreads();
38379 (arg1)->ReleaseMouse();
38380 wxPyEndAllowThreads(__tstate);
38381 if (PyErr_Occurred()) SWIG_fail;
38382 }
38383 resultobj = SWIG_Py_Void();
38384 return resultobj;
38385 fail:
38386 return NULL;
38387 }
38388
38389
38390 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38391 PyObject *resultobj = 0;
38392 wxWindow *result = 0 ;
38393
38394 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
38395 {
38396 if (!wxPyCheckForApp()) SWIG_fail;
38397 PyThreadState* __tstate = wxPyBeginAllowThreads();
38398 result = (wxWindow *)wxWindow::GetCapture();
38399 wxPyEndAllowThreads(__tstate);
38400 if (PyErr_Occurred()) SWIG_fail;
38401 }
38402 {
38403 resultobj = wxPyMake_wxObject(result, 0);
38404 }
38405 return resultobj;
38406 fail:
38407 return NULL;
38408 }
38409
38410
38411 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38412 PyObject *resultobj = 0;
38413 wxWindow *arg1 = (wxWindow *) 0 ;
38414 bool result;
38415 void *argp1 = 0 ;
38416 int res1 = 0 ;
38417 PyObject *swig_obj[1] ;
38418
38419 if (!args) SWIG_fail;
38420 swig_obj[0] = args;
38421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38422 if (!SWIG_IsOK(res1)) {
38423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
38424 }
38425 arg1 = reinterpret_cast< wxWindow * >(argp1);
38426 {
38427 PyThreadState* __tstate = wxPyBeginAllowThreads();
38428 result = (bool)((wxWindow const *)arg1)->HasCapture();
38429 wxPyEndAllowThreads(__tstate);
38430 if (PyErr_Occurred()) SWIG_fail;
38431 }
38432 {
38433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38434 }
38435 return resultobj;
38436 fail:
38437 return NULL;
38438 }
38439
38440
38441 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38442 PyObject *resultobj = 0;
38443 wxWindow *arg1 = (wxWindow *) 0 ;
38444 bool arg2 = (bool) true ;
38445 wxRect *arg3 = (wxRect *) NULL ;
38446 void *argp1 = 0 ;
38447 int res1 = 0 ;
38448 bool val2 ;
38449 int ecode2 = 0 ;
38450 void *argp3 = 0 ;
38451 int res3 = 0 ;
38452 PyObject * obj0 = 0 ;
38453 PyObject * obj1 = 0 ;
38454 PyObject * obj2 = 0 ;
38455 char * kwnames[] = {
38456 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
38457 };
38458
38459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38461 if (!SWIG_IsOK(res1)) {
38462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
38463 }
38464 arg1 = reinterpret_cast< wxWindow * >(argp1);
38465 if (obj1) {
38466 ecode2 = SWIG_AsVal_bool(obj1, &val2);
38467 if (!SWIG_IsOK(ecode2)) {
38468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
38469 }
38470 arg2 = static_cast< bool >(val2);
38471 }
38472 if (obj2) {
38473 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
38474 if (!SWIG_IsOK(res3)) {
38475 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
38476 }
38477 arg3 = reinterpret_cast< wxRect * >(argp3);
38478 }
38479 {
38480 PyThreadState* __tstate = wxPyBeginAllowThreads();
38481 (arg1)->Refresh(arg2,(wxRect const *)arg3);
38482 wxPyEndAllowThreads(__tstate);
38483 if (PyErr_Occurred()) SWIG_fail;
38484 }
38485 resultobj = SWIG_Py_Void();
38486 return resultobj;
38487 fail:
38488 return NULL;
38489 }
38490
38491
38492 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38493 PyObject *resultobj = 0;
38494 wxWindow *arg1 = (wxWindow *) 0 ;
38495 wxRect *arg2 = 0 ;
38496 bool arg3 = (bool) true ;
38497 void *argp1 = 0 ;
38498 int res1 = 0 ;
38499 wxRect temp2 ;
38500 bool val3 ;
38501 int ecode3 = 0 ;
38502 PyObject * obj0 = 0 ;
38503 PyObject * obj1 = 0 ;
38504 PyObject * obj2 = 0 ;
38505 char * kwnames[] = {
38506 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
38507 };
38508
38509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38511 if (!SWIG_IsOK(res1)) {
38512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
38513 }
38514 arg1 = reinterpret_cast< wxWindow * >(argp1);
38515 {
38516 arg2 = &temp2;
38517 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38518 }
38519 if (obj2) {
38520 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38521 if (!SWIG_IsOK(ecode3)) {
38522 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
38523 }
38524 arg3 = static_cast< bool >(val3);
38525 }
38526 {
38527 PyThreadState* __tstate = wxPyBeginAllowThreads();
38528 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
38529 wxPyEndAllowThreads(__tstate);
38530 if (PyErr_Occurred()) SWIG_fail;
38531 }
38532 resultobj = SWIG_Py_Void();
38533 return resultobj;
38534 fail:
38535 return NULL;
38536 }
38537
38538
38539 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38540 PyObject *resultobj = 0;
38541 wxWindow *arg1 = (wxWindow *) 0 ;
38542 void *argp1 = 0 ;
38543 int res1 = 0 ;
38544 PyObject *swig_obj[1] ;
38545
38546 if (!args) SWIG_fail;
38547 swig_obj[0] = args;
38548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38549 if (!SWIG_IsOK(res1)) {
38550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
38551 }
38552 arg1 = reinterpret_cast< wxWindow * >(argp1);
38553 {
38554 PyThreadState* __tstate = wxPyBeginAllowThreads();
38555 (arg1)->Update();
38556 wxPyEndAllowThreads(__tstate);
38557 if (PyErr_Occurred()) SWIG_fail;
38558 }
38559 resultobj = SWIG_Py_Void();
38560 return resultobj;
38561 fail:
38562 return NULL;
38563 }
38564
38565
38566 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38567 PyObject *resultobj = 0;
38568 wxWindow *arg1 = (wxWindow *) 0 ;
38569 void *argp1 = 0 ;
38570 int res1 = 0 ;
38571 PyObject *swig_obj[1] ;
38572
38573 if (!args) SWIG_fail;
38574 swig_obj[0] = args;
38575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38576 if (!SWIG_IsOK(res1)) {
38577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
38578 }
38579 arg1 = reinterpret_cast< wxWindow * >(argp1);
38580 {
38581 PyThreadState* __tstate = wxPyBeginAllowThreads();
38582 (arg1)->ClearBackground();
38583 wxPyEndAllowThreads(__tstate);
38584 if (PyErr_Occurred()) SWIG_fail;
38585 }
38586 resultobj = SWIG_Py_Void();
38587 return resultobj;
38588 fail:
38589 return NULL;
38590 }
38591
38592
38593 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38594 PyObject *resultobj = 0;
38595 wxWindow *arg1 = (wxWindow *) 0 ;
38596 void *argp1 = 0 ;
38597 int res1 = 0 ;
38598 PyObject *swig_obj[1] ;
38599
38600 if (!args) SWIG_fail;
38601 swig_obj[0] = args;
38602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38603 if (!SWIG_IsOK(res1)) {
38604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
38605 }
38606 arg1 = reinterpret_cast< wxWindow * >(argp1);
38607 {
38608 PyThreadState* __tstate = wxPyBeginAllowThreads();
38609 (arg1)->Freeze();
38610 wxPyEndAllowThreads(__tstate);
38611 if (PyErr_Occurred()) SWIG_fail;
38612 }
38613 resultobj = SWIG_Py_Void();
38614 return resultobj;
38615 fail:
38616 return NULL;
38617 }
38618
38619
38620 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38621 PyObject *resultobj = 0;
38622 wxWindow *arg1 = (wxWindow *) 0 ;
38623 bool result;
38624 void *argp1 = 0 ;
38625 int res1 = 0 ;
38626 PyObject *swig_obj[1] ;
38627
38628 if (!args) SWIG_fail;
38629 swig_obj[0] = args;
38630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38631 if (!SWIG_IsOK(res1)) {
38632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
38633 }
38634 arg1 = reinterpret_cast< wxWindow * >(argp1);
38635 {
38636 PyThreadState* __tstate = wxPyBeginAllowThreads();
38637 result = (bool)((wxWindow const *)arg1)->IsFrozen();
38638 wxPyEndAllowThreads(__tstate);
38639 if (PyErr_Occurred()) SWIG_fail;
38640 }
38641 {
38642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38643 }
38644 return resultobj;
38645 fail:
38646 return NULL;
38647 }
38648
38649
38650 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38651 PyObject *resultobj = 0;
38652 wxWindow *arg1 = (wxWindow *) 0 ;
38653 void *argp1 = 0 ;
38654 int res1 = 0 ;
38655 PyObject *swig_obj[1] ;
38656
38657 if (!args) SWIG_fail;
38658 swig_obj[0] = args;
38659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38660 if (!SWIG_IsOK(res1)) {
38661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
38662 }
38663 arg1 = reinterpret_cast< wxWindow * >(argp1);
38664 {
38665 PyThreadState* __tstate = wxPyBeginAllowThreads();
38666 (arg1)->Thaw();
38667 wxPyEndAllowThreads(__tstate);
38668 if (PyErr_Occurred()) SWIG_fail;
38669 }
38670 resultobj = SWIG_Py_Void();
38671 return resultobj;
38672 fail:
38673 return NULL;
38674 }
38675
38676
38677 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38678 PyObject *resultobj = 0;
38679 wxWindow *arg1 = (wxWindow *) 0 ;
38680 wxDC *arg2 = 0 ;
38681 void *argp1 = 0 ;
38682 int res1 = 0 ;
38683 void *argp2 = 0 ;
38684 int res2 = 0 ;
38685 PyObject * obj0 = 0 ;
38686 PyObject * obj1 = 0 ;
38687 char * kwnames[] = {
38688 (char *) "self",(char *) "dc", NULL
38689 };
38690
38691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
38692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38693 if (!SWIG_IsOK(res1)) {
38694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
38695 }
38696 arg1 = reinterpret_cast< wxWindow * >(argp1);
38697 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
38698 if (!SWIG_IsOK(res2)) {
38699 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
38700 }
38701 if (!argp2) {
38702 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
38703 }
38704 arg2 = reinterpret_cast< wxDC * >(argp2);
38705 {
38706 PyThreadState* __tstate = wxPyBeginAllowThreads();
38707 (arg1)->PrepareDC(*arg2);
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_IsDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38719 PyObject *resultobj = 0;
38720 wxWindow *arg1 = (wxWindow *) 0 ;
38721 bool result;
38722 void *argp1 = 0 ;
38723 int res1 = 0 ;
38724 PyObject *swig_obj[1] ;
38725
38726 if (!args) SWIG_fail;
38727 swig_obj[0] = args;
38728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38729 if (!SWIG_IsOK(res1)) {
38730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow const *""'");
38731 }
38732 arg1 = reinterpret_cast< wxWindow * >(argp1);
38733 {
38734 PyThreadState* __tstate = wxPyBeginAllowThreads();
38735 result = (bool)((wxWindow const *)arg1)->IsDoubleBuffered();
38736 wxPyEndAllowThreads(__tstate);
38737 if (PyErr_Occurred()) SWIG_fail;
38738 }
38739 {
38740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38741 }
38742 return resultobj;
38743 fail:
38744 return NULL;
38745 }
38746
38747
38748 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38749 PyObject *resultobj = 0;
38750 wxWindow *arg1 = (wxWindow *) 0 ;
38751 wxRegion *result = 0 ;
38752 void *argp1 = 0 ;
38753 int res1 = 0 ;
38754 PyObject *swig_obj[1] ;
38755
38756 if (!args) SWIG_fail;
38757 swig_obj[0] = args;
38758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38759 if (!SWIG_IsOK(res1)) {
38760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
38761 }
38762 arg1 = reinterpret_cast< wxWindow * >(argp1);
38763 {
38764 PyThreadState* __tstate = wxPyBeginAllowThreads();
38765 {
38766 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
38767 result = (wxRegion *) &_result_ref;
38768 }
38769 wxPyEndAllowThreads(__tstate);
38770 if (PyErr_Occurred()) SWIG_fail;
38771 }
38772 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
38773 return resultobj;
38774 fail:
38775 return NULL;
38776 }
38777
38778
38779 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38780 PyObject *resultobj = 0;
38781 wxWindow *arg1 = (wxWindow *) 0 ;
38782 wxRect result;
38783 void *argp1 = 0 ;
38784 int res1 = 0 ;
38785 PyObject *swig_obj[1] ;
38786
38787 if (!args) SWIG_fail;
38788 swig_obj[0] = args;
38789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38790 if (!SWIG_IsOK(res1)) {
38791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38792 }
38793 arg1 = reinterpret_cast< wxWindow * >(argp1);
38794 {
38795 PyThreadState* __tstate = wxPyBeginAllowThreads();
38796 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
38797 wxPyEndAllowThreads(__tstate);
38798 if (PyErr_Occurred()) SWIG_fail;
38799 }
38800 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
38801 return resultobj;
38802 fail:
38803 return NULL;
38804 }
38805
38806
38807 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38808 PyObject *resultobj = 0;
38809 wxWindow *arg1 = (wxWindow *) 0 ;
38810 int arg2 ;
38811 int arg3 ;
38812 int arg4 = (int) 1 ;
38813 int arg5 = (int) 1 ;
38814 bool result;
38815 void *argp1 = 0 ;
38816 int res1 = 0 ;
38817 int val2 ;
38818 int ecode2 = 0 ;
38819 int val3 ;
38820 int ecode3 = 0 ;
38821 int val4 ;
38822 int ecode4 = 0 ;
38823 int val5 ;
38824 int ecode5 = 0 ;
38825 PyObject * obj0 = 0 ;
38826 PyObject * obj1 = 0 ;
38827 PyObject * obj2 = 0 ;
38828 PyObject * obj3 = 0 ;
38829 PyObject * obj4 = 0 ;
38830 char * kwnames[] = {
38831 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
38832 };
38833
38834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38836 if (!SWIG_IsOK(res1)) {
38837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
38838 }
38839 arg1 = reinterpret_cast< wxWindow * >(argp1);
38840 ecode2 = SWIG_AsVal_int(obj1, &val2);
38841 if (!SWIG_IsOK(ecode2)) {
38842 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
38843 }
38844 arg2 = static_cast< int >(val2);
38845 ecode3 = SWIG_AsVal_int(obj2, &val3);
38846 if (!SWIG_IsOK(ecode3)) {
38847 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
38848 }
38849 arg3 = static_cast< int >(val3);
38850 if (obj3) {
38851 ecode4 = SWIG_AsVal_int(obj3, &val4);
38852 if (!SWIG_IsOK(ecode4)) {
38853 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
38854 }
38855 arg4 = static_cast< int >(val4);
38856 }
38857 if (obj4) {
38858 ecode5 = SWIG_AsVal_int(obj4, &val5);
38859 if (!SWIG_IsOK(ecode5)) {
38860 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
38861 }
38862 arg5 = static_cast< int >(val5);
38863 }
38864 {
38865 PyThreadState* __tstate = wxPyBeginAllowThreads();
38866 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
38867 wxPyEndAllowThreads(__tstate);
38868 if (PyErr_Occurred()) SWIG_fail;
38869 }
38870 {
38871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38872 }
38873 return resultobj;
38874 fail:
38875 return NULL;
38876 }
38877
38878
38879 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38880 PyObject *resultobj = 0;
38881 wxWindow *arg1 = (wxWindow *) 0 ;
38882 wxPoint *arg2 = 0 ;
38883 bool result;
38884 void *argp1 = 0 ;
38885 int res1 = 0 ;
38886 wxPoint temp2 ;
38887 PyObject * obj0 = 0 ;
38888 PyObject * obj1 = 0 ;
38889 char * kwnames[] = {
38890 (char *) "self",(char *) "pt", NULL
38891 };
38892
38893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
38894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38895 if (!SWIG_IsOK(res1)) {
38896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
38897 }
38898 arg1 = reinterpret_cast< wxWindow * >(argp1);
38899 {
38900 arg2 = &temp2;
38901 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38902 }
38903 {
38904 PyThreadState* __tstate = wxPyBeginAllowThreads();
38905 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
38906 wxPyEndAllowThreads(__tstate);
38907 if (PyErr_Occurred()) SWIG_fail;
38908 }
38909 {
38910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38911 }
38912 return resultobj;
38913 fail:
38914 return NULL;
38915 }
38916
38917
38918 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38919 PyObject *resultobj = 0;
38920 wxWindow *arg1 = (wxWindow *) 0 ;
38921 wxRect *arg2 = 0 ;
38922 bool result;
38923 void *argp1 = 0 ;
38924 int res1 = 0 ;
38925 wxRect temp2 ;
38926 PyObject * obj0 = 0 ;
38927 PyObject * obj1 = 0 ;
38928 char * kwnames[] = {
38929 (char *) "self",(char *) "rect", NULL
38930 };
38931
38932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
38933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38934 if (!SWIG_IsOK(res1)) {
38935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38936 }
38937 arg1 = reinterpret_cast< wxWindow * >(argp1);
38938 {
38939 arg2 = &temp2;
38940 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38941 }
38942 {
38943 PyThreadState* __tstate = wxPyBeginAllowThreads();
38944 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
38945 wxPyEndAllowThreads(__tstate);
38946 if (PyErr_Occurred()) SWIG_fail;
38947 }
38948 {
38949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38950 }
38951 return resultobj;
38952 fail:
38953 return NULL;
38954 }
38955
38956
38957 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38958 PyObject *resultobj = 0;
38959 wxWindow *arg1 = (wxWindow *) 0 ;
38960 SwigValueWrapper<wxVisualAttributes > result;
38961 void *argp1 = 0 ;
38962 int res1 = 0 ;
38963 PyObject *swig_obj[1] ;
38964
38965 if (!args) SWIG_fail;
38966 swig_obj[0] = args;
38967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38968 if (!SWIG_IsOK(res1)) {
38969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
38970 }
38971 arg1 = reinterpret_cast< wxWindow * >(argp1);
38972 {
38973 PyThreadState* __tstate = wxPyBeginAllowThreads();
38974 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
38975 wxPyEndAllowThreads(__tstate);
38976 if (PyErr_Occurred()) SWIG_fail;
38977 }
38978 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38979 return resultobj;
38980 fail:
38981 return NULL;
38982 }
38983
38984
38985 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38986 PyObject *resultobj = 0;
38987 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38988 SwigValueWrapper<wxVisualAttributes > result;
38989 int val1 ;
38990 int ecode1 = 0 ;
38991 PyObject * obj0 = 0 ;
38992 char * kwnames[] = {
38993 (char *) "variant", NULL
38994 };
38995
38996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
38997 if (obj0) {
38998 ecode1 = SWIG_AsVal_int(obj0, &val1);
38999 if (!SWIG_IsOK(ecode1)) {
39000 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
39001 }
39002 arg1 = static_cast< wxWindowVariant >(val1);
39003 }
39004 {
39005 if (!wxPyCheckForApp()) SWIG_fail;
39006 PyThreadState* __tstate = wxPyBeginAllowThreads();
39007 result = wxWindow::GetClassDefaultAttributes(arg1);
39008 wxPyEndAllowThreads(__tstate);
39009 if (PyErr_Occurred()) SWIG_fail;
39010 }
39011 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
39012 return resultobj;
39013 fail:
39014 return NULL;
39015 }
39016
39017
39018 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39019 PyObject *resultobj = 0;
39020 wxWindow *arg1 = (wxWindow *) 0 ;
39021 wxColour *arg2 = 0 ;
39022 bool result;
39023 void *argp1 = 0 ;
39024 int res1 = 0 ;
39025 wxColour temp2 ;
39026 PyObject * obj0 = 0 ;
39027 PyObject * obj1 = 0 ;
39028 char * kwnames[] = {
39029 (char *) "self",(char *) "colour", NULL
39030 };
39031
39032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
39033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39034 if (!SWIG_IsOK(res1)) {
39035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
39036 }
39037 arg1 = reinterpret_cast< wxWindow * >(argp1);
39038 {
39039 arg2 = &temp2;
39040 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
39041 }
39042 {
39043 PyThreadState* __tstate = wxPyBeginAllowThreads();
39044 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
39045 wxPyEndAllowThreads(__tstate);
39046 if (PyErr_Occurred()) SWIG_fail;
39047 }
39048 {
39049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39050 }
39051 return resultobj;
39052 fail:
39053 return NULL;
39054 }
39055
39056
39057 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39058 PyObject *resultobj = 0;
39059 wxWindow *arg1 = (wxWindow *) 0 ;
39060 wxColour *arg2 = 0 ;
39061 void *argp1 = 0 ;
39062 int res1 = 0 ;
39063 wxColour temp2 ;
39064 PyObject * obj0 = 0 ;
39065 PyObject * obj1 = 0 ;
39066 char * kwnames[] = {
39067 (char *) "self",(char *) "colour", NULL
39068 };
39069
39070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
39071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39072 if (!SWIG_IsOK(res1)) {
39073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
39074 }
39075 arg1 = reinterpret_cast< wxWindow * >(argp1);
39076 {
39077 arg2 = &temp2;
39078 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
39079 }
39080 {
39081 PyThreadState* __tstate = wxPyBeginAllowThreads();
39082 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
39083 wxPyEndAllowThreads(__tstate);
39084 if (PyErr_Occurred()) SWIG_fail;
39085 }
39086 resultobj = SWIG_Py_Void();
39087 return resultobj;
39088 fail:
39089 return NULL;
39090 }
39091
39092
39093 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39094 PyObject *resultobj = 0;
39095 wxWindow *arg1 = (wxWindow *) 0 ;
39096 wxColour *arg2 = 0 ;
39097 bool result;
39098 void *argp1 = 0 ;
39099 int res1 = 0 ;
39100 wxColour temp2 ;
39101 PyObject * obj0 = 0 ;
39102 PyObject * obj1 = 0 ;
39103 char * kwnames[] = {
39104 (char *) "self",(char *) "colour", NULL
39105 };
39106
39107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
39108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39109 if (!SWIG_IsOK(res1)) {
39110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
39111 }
39112 arg1 = reinterpret_cast< wxWindow * >(argp1);
39113 {
39114 arg2 = &temp2;
39115 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
39116 }
39117 {
39118 PyThreadState* __tstate = wxPyBeginAllowThreads();
39119 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
39120 wxPyEndAllowThreads(__tstate);
39121 if (PyErr_Occurred()) SWIG_fail;
39122 }
39123 {
39124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39125 }
39126 return resultobj;
39127 fail:
39128 return NULL;
39129 }
39130
39131
39132 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39133 PyObject *resultobj = 0;
39134 wxWindow *arg1 = (wxWindow *) 0 ;
39135 wxColour *arg2 = 0 ;
39136 void *argp1 = 0 ;
39137 int res1 = 0 ;
39138 wxColour temp2 ;
39139 PyObject * obj0 = 0 ;
39140 PyObject * obj1 = 0 ;
39141 char * kwnames[] = {
39142 (char *) "self",(char *) "colour", NULL
39143 };
39144
39145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
39146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39147 if (!SWIG_IsOK(res1)) {
39148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
39149 }
39150 arg1 = reinterpret_cast< wxWindow * >(argp1);
39151 {
39152 arg2 = &temp2;
39153 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
39154 }
39155 {
39156 PyThreadState* __tstate = wxPyBeginAllowThreads();
39157 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
39158 wxPyEndAllowThreads(__tstate);
39159 if (PyErr_Occurred()) SWIG_fail;
39160 }
39161 resultobj = SWIG_Py_Void();
39162 return resultobj;
39163 fail:
39164 return NULL;
39165 }
39166
39167
39168 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39169 PyObject *resultobj = 0;
39170 wxWindow *arg1 = (wxWindow *) 0 ;
39171 wxColour result;
39172 void *argp1 = 0 ;
39173 int res1 = 0 ;
39174 PyObject *swig_obj[1] ;
39175
39176 if (!args) SWIG_fail;
39177 swig_obj[0] = args;
39178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39179 if (!SWIG_IsOK(res1)) {
39180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
39181 }
39182 arg1 = reinterpret_cast< wxWindow * >(argp1);
39183 {
39184 PyThreadState* __tstate = wxPyBeginAllowThreads();
39185 result = ((wxWindow const *)arg1)->GetBackgroundColour();
39186 wxPyEndAllowThreads(__tstate);
39187 if (PyErr_Occurred()) SWIG_fail;
39188 }
39189 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
39190 return resultobj;
39191 fail:
39192 return NULL;
39193 }
39194
39195
39196 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39197 PyObject *resultobj = 0;
39198 wxWindow *arg1 = (wxWindow *) 0 ;
39199 wxColour result;
39200 void *argp1 = 0 ;
39201 int res1 = 0 ;
39202 PyObject *swig_obj[1] ;
39203
39204 if (!args) SWIG_fail;
39205 swig_obj[0] = args;
39206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39207 if (!SWIG_IsOK(res1)) {
39208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
39209 }
39210 arg1 = reinterpret_cast< wxWindow * >(argp1);
39211 {
39212 PyThreadState* __tstate = wxPyBeginAllowThreads();
39213 result = ((wxWindow const *)arg1)->GetForegroundColour();
39214 wxPyEndAllowThreads(__tstate);
39215 if (PyErr_Occurred()) SWIG_fail;
39216 }
39217 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
39218 return resultobj;
39219 fail:
39220 return NULL;
39221 }
39222
39223
39224 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39225 PyObject *resultobj = 0;
39226 wxWindow *arg1 = (wxWindow *) 0 ;
39227 bool result;
39228 void *argp1 = 0 ;
39229 int res1 = 0 ;
39230 PyObject *swig_obj[1] ;
39231
39232 if (!args) SWIG_fail;
39233 swig_obj[0] = args;
39234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39235 if (!SWIG_IsOK(res1)) {
39236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
39237 }
39238 arg1 = reinterpret_cast< wxWindow * >(argp1);
39239 {
39240 PyThreadState* __tstate = wxPyBeginAllowThreads();
39241 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
39242 wxPyEndAllowThreads(__tstate);
39243 if (PyErr_Occurred()) SWIG_fail;
39244 }
39245 {
39246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39247 }
39248 return resultobj;
39249 fail:
39250 return NULL;
39251 }
39252
39253
39254 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39255 PyObject *resultobj = 0;
39256 wxWindow *arg1 = (wxWindow *) 0 ;
39257 bool result;
39258 void *argp1 = 0 ;
39259 int res1 = 0 ;
39260 PyObject *swig_obj[1] ;
39261
39262 if (!args) SWIG_fail;
39263 swig_obj[0] = args;
39264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39265 if (!SWIG_IsOK(res1)) {
39266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
39267 }
39268 arg1 = reinterpret_cast< wxWindow * >(argp1);
39269 {
39270 PyThreadState* __tstate = wxPyBeginAllowThreads();
39271 result = (bool)((wxWindow const *)arg1)->UseBgCol();
39272 wxPyEndAllowThreads(__tstate);
39273 if (PyErr_Occurred()) SWIG_fail;
39274 }
39275 {
39276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39277 }
39278 return resultobj;
39279 fail:
39280 return NULL;
39281 }
39282
39283
39284 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39285 PyObject *resultobj = 0;
39286 wxWindow *arg1 = (wxWindow *) 0 ;
39287 wxBackgroundStyle arg2 ;
39288 bool result;
39289 void *argp1 = 0 ;
39290 int res1 = 0 ;
39291 int val2 ;
39292 int ecode2 = 0 ;
39293 PyObject * obj0 = 0 ;
39294 PyObject * obj1 = 0 ;
39295 char * kwnames[] = {
39296 (char *) "self",(char *) "style", NULL
39297 };
39298
39299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
39300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39301 if (!SWIG_IsOK(res1)) {
39302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
39303 }
39304 arg1 = reinterpret_cast< wxWindow * >(argp1);
39305 ecode2 = SWIG_AsVal_int(obj1, &val2);
39306 if (!SWIG_IsOK(ecode2)) {
39307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
39308 }
39309 arg2 = static_cast< wxBackgroundStyle >(val2);
39310 {
39311 PyThreadState* __tstate = wxPyBeginAllowThreads();
39312 result = (bool)(arg1)->SetBackgroundStyle(arg2);
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_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39326 PyObject *resultobj = 0;
39327 wxWindow *arg1 = (wxWindow *) 0 ;
39328 wxBackgroundStyle result;
39329 void *argp1 = 0 ;
39330 int res1 = 0 ;
39331 PyObject *swig_obj[1] ;
39332
39333 if (!args) SWIG_fail;
39334 swig_obj[0] = args;
39335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39336 if (!SWIG_IsOK(res1)) {
39337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
39338 }
39339 arg1 = reinterpret_cast< wxWindow * >(argp1);
39340 {
39341 PyThreadState* __tstate = wxPyBeginAllowThreads();
39342 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
39343 wxPyEndAllowThreads(__tstate);
39344 if (PyErr_Occurred()) SWIG_fail;
39345 }
39346 resultobj = SWIG_From_int(static_cast< int >(result));
39347 return resultobj;
39348 fail:
39349 return NULL;
39350 }
39351
39352
39353 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39354 PyObject *resultobj = 0;
39355 wxWindow *arg1 = (wxWindow *) 0 ;
39356 bool result;
39357 void *argp1 = 0 ;
39358 int res1 = 0 ;
39359 PyObject *swig_obj[1] ;
39360
39361 if (!args) SWIG_fail;
39362 swig_obj[0] = args;
39363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39364 if (!SWIG_IsOK(res1)) {
39365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
39366 }
39367 arg1 = reinterpret_cast< wxWindow * >(argp1);
39368 {
39369 PyThreadState* __tstate = wxPyBeginAllowThreads();
39370 result = (bool)(arg1)->HasTransparentBackground();
39371 wxPyEndAllowThreads(__tstate);
39372 if (PyErr_Occurred()) SWIG_fail;
39373 }
39374 {
39375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39376 }
39377 return resultobj;
39378 fail:
39379 return NULL;
39380 }
39381
39382
39383 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39384 PyObject *resultobj = 0;
39385 wxWindow *arg1 = (wxWindow *) 0 ;
39386 wxCursor *arg2 = 0 ;
39387 bool result;
39388 void *argp1 = 0 ;
39389 int res1 = 0 ;
39390 void *argp2 = 0 ;
39391 int res2 = 0 ;
39392 PyObject * obj0 = 0 ;
39393 PyObject * obj1 = 0 ;
39394 char * kwnames[] = {
39395 (char *) "self",(char *) "cursor", NULL
39396 };
39397
39398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
39399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39400 if (!SWIG_IsOK(res1)) {
39401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
39402 }
39403 arg1 = reinterpret_cast< wxWindow * >(argp1);
39404 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
39405 if (!SWIG_IsOK(res2)) {
39406 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
39407 }
39408 if (!argp2) {
39409 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
39410 }
39411 arg2 = reinterpret_cast< wxCursor * >(argp2);
39412 {
39413 PyThreadState* __tstate = wxPyBeginAllowThreads();
39414 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
39415 wxPyEndAllowThreads(__tstate);
39416 if (PyErr_Occurred()) SWIG_fail;
39417 }
39418 {
39419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39420 }
39421 return resultobj;
39422 fail:
39423 return NULL;
39424 }
39425
39426
39427 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39428 PyObject *resultobj = 0;
39429 wxWindow *arg1 = (wxWindow *) 0 ;
39430 wxCursor result;
39431 void *argp1 = 0 ;
39432 int res1 = 0 ;
39433 PyObject *swig_obj[1] ;
39434
39435 if (!args) SWIG_fail;
39436 swig_obj[0] = args;
39437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39438 if (!SWIG_IsOK(res1)) {
39439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
39440 }
39441 arg1 = reinterpret_cast< wxWindow * >(argp1);
39442 {
39443 PyThreadState* __tstate = wxPyBeginAllowThreads();
39444 result = (arg1)->GetCursor();
39445 wxPyEndAllowThreads(__tstate);
39446 if (PyErr_Occurred()) SWIG_fail;
39447 }
39448 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
39449 return resultobj;
39450 fail:
39451 return NULL;
39452 }
39453
39454
39455 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39456 PyObject *resultobj = 0;
39457 wxWindow *arg1 = (wxWindow *) 0 ;
39458 wxFont *arg2 = 0 ;
39459 bool result;
39460 void *argp1 = 0 ;
39461 int res1 = 0 ;
39462 void *argp2 = 0 ;
39463 int res2 = 0 ;
39464 PyObject * obj0 = 0 ;
39465 PyObject * obj1 = 0 ;
39466 char * kwnames[] = {
39467 (char *) "self",(char *) "font", NULL
39468 };
39469
39470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
39471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39472 if (!SWIG_IsOK(res1)) {
39473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
39474 }
39475 arg1 = reinterpret_cast< wxWindow * >(argp1);
39476 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
39477 if (!SWIG_IsOK(res2)) {
39478 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
39479 }
39480 if (!argp2) {
39481 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
39482 }
39483 arg2 = reinterpret_cast< wxFont * >(argp2);
39484 {
39485 PyThreadState* __tstate = wxPyBeginAllowThreads();
39486 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
39487 wxPyEndAllowThreads(__tstate);
39488 if (PyErr_Occurred()) SWIG_fail;
39489 }
39490 {
39491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39492 }
39493 return resultobj;
39494 fail:
39495 return NULL;
39496 }
39497
39498
39499 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39500 PyObject *resultobj = 0;
39501 wxWindow *arg1 = (wxWindow *) 0 ;
39502 wxFont *arg2 = 0 ;
39503 void *argp1 = 0 ;
39504 int res1 = 0 ;
39505 void *argp2 = 0 ;
39506 int res2 = 0 ;
39507 PyObject * obj0 = 0 ;
39508 PyObject * obj1 = 0 ;
39509 char * kwnames[] = {
39510 (char *) "self",(char *) "font", NULL
39511 };
39512
39513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
39514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39515 if (!SWIG_IsOK(res1)) {
39516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
39517 }
39518 arg1 = reinterpret_cast< wxWindow * >(argp1);
39519 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
39520 if (!SWIG_IsOK(res2)) {
39521 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
39522 }
39523 if (!argp2) {
39524 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
39525 }
39526 arg2 = reinterpret_cast< wxFont * >(argp2);
39527 {
39528 PyThreadState* __tstate = wxPyBeginAllowThreads();
39529 (arg1)->SetOwnFont((wxFont const &)*arg2);
39530 wxPyEndAllowThreads(__tstate);
39531 if (PyErr_Occurred()) SWIG_fail;
39532 }
39533 resultobj = SWIG_Py_Void();
39534 return resultobj;
39535 fail:
39536 return NULL;
39537 }
39538
39539
39540 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39541 PyObject *resultobj = 0;
39542 wxWindow *arg1 = (wxWindow *) 0 ;
39543 wxFont result;
39544 void *argp1 = 0 ;
39545 int res1 = 0 ;
39546 PyObject *swig_obj[1] ;
39547
39548 if (!args) SWIG_fail;
39549 swig_obj[0] = args;
39550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39551 if (!SWIG_IsOK(res1)) {
39552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
39553 }
39554 arg1 = reinterpret_cast< wxWindow * >(argp1);
39555 {
39556 PyThreadState* __tstate = wxPyBeginAllowThreads();
39557 result = (arg1)->GetFont();
39558 wxPyEndAllowThreads(__tstate);
39559 if (PyErr_Occurred()) SWIG_fail;
39560 }
39561 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
39562 return resultobj;
39563 fail:
39564 return NULL;
39565 }
39566
39567
39568 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39569 PyObject *resultobj = 0;
39570 wxWindow *arg1 = (wxWindow *) 0 ;
39571 wxCaret *arg2 = (wxCaret *) 0 ;
39572 void *argp1 = 0 ;
39573 int res1 = 0 ;
39574 int res2 = 0 ;
39575 PyObject * obj0 = 0 ;
39576 PyObject * obj1 = 0 ;
39577 char * kwnames[] = {
39578 (char *) "self",(char *) "caret", NULL
39579 };
39580
39581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
39582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39583 if (!SWIG_IsOK(res1)) {
39584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
39585 }
39586 arg1 = reinterpret_cast< wxWindow * >(argp1);
39587 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
39588 if (!SWIG_IsOK(res2)) {
39589 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
39590 }
39591 {
39592 PyThreadState* __tstate = wxPyBeginAllowThreads();
39593 (arg1)->SetCaret(arg2);
39594 wxPyEndAllowThreads(__tstate);
39595 if (PyErr_Occurred()) SWIG_fail;
39596 }
39597 resultobj = SWIG_Py_Void();
39598 return resultobj;
39599 fail:
39600 return NULL;
39601 }
39602
39603
39604 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39605 PyObject *resultobj = 0;
39606 wxWindow *arg1 = (wxWindow *) 0 ;
39607 wxCaret *result = 0 ;
39608 void *argp1 = 0 ;
39609 int res1 = 0 ;
39610 PyObject *swig_obj[1] ;
39611
39612 if (!args) SWIG_fail;
39613 swig_obj[0] = args;
39614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39615 if (!SWIG_IsOK(res1)) {
39616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
39617 }
39618 arg1 = reinterpret_cast< wxWindow * >(argp1);
39619 {
39620 PyThreadState* __tstate = wxPyBeginAllowThreads();
39621 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
39622 wxPyEndAllowThreads(__tstate);
39623 if (PyErr_Occurred()) SWIG_fail;
39624 }
39625 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
39626 return resultobj;
39627 fail:
39628 return NULL;
39629 }
39630
39631
39632 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39633 PyObject *resultobj = 0;
39634 wxWindow *arg1 = (wxWindow *) 0 ;
39635 int result;
39636 void *argp1 = 0 ;
39637 int res1 = 0 ;
39638 PyObject *swig_obj[1] ;
39639
39640 if (!args) SWIG_fail;
39641 swig_obj[0] = args;
39642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39643 if (!SWIG_IsOK(res1)) {
39644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
39645 }
39646 arg1 = reinterpret_cast< wxWindow * >(argp1);
39647 {
39648 PyThreadState* __tstate = wxPyBeginAllowThreads();
39649 result = (int)((wxWindow const *)arg1)->GetCharHeight();
39650 wxPyEndAllowThreads(__tstate);
39651 if (PyErr_Occurred()) SWIG_fail;
39652 }
39653 resultobj = SWIG_From_int(static_cast< int >(result));
39654 return resultobj;
39655 fail:
39656 return NULL;
39657 }
39658
39659
39660 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39661 PyObject *resultobj = 0;
39662 wxWindow *arg1 = (wxWindow *) 0 ;
39663 int result;
39664 void *argp1 = 0 ;
39665 int res1 = 0 ;
39666 PyObject *swig_obj[1] ;
39667
39668 if (!args) SWIG_fail;
39669 swig_obj[0] = args;
39670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39671 if (!SWIG_IsOK(res1)) {
39672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
39673 }
39674 arg1 = reinterpret_cast< wxWindow * >(argp1);
39675 {
39676 PyThreadState* __tstate = wxPyBeginAllowThreads();
39677 result = (int)((wxWindow const *)arg1)->GetCharWidth();
39678 wxPyEndAllowThreads(__tstate);
39679 if (PyErr_Occurred()) SWIG_fail;
39680 }
39681 resultobj = SWIG_From_int(static_cast< int >(result));
39682 return resultobj;
39683 fail:
39684 return NULL;
39685 }
39686
39687
39688 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39689 PyObject *resultobj = 0;
39690 wxWindow *arg1 = (wxWindow *) 0 ;
39691 wxString *arg2 = 0 ;
39692 int *arg3 = (int *) 0 ;
39693 int *arg4 = (int *) 0 ;
39694 void *argp1 = 0 ;
39695 int res1 = 0 ;
39696 bool temp2 = false ;
39697 int temp3 ;
39698 int res3 = SWIG_TMPOBJ ;
39699 int temp4 ;
39700 int res4 = SWIG_TMPOBJ ;
39701 PyObject * obj0 = 0 ;
39702 PyObject * obj1 = 0 ;
39703 char * kwnames[] = {
39704 (char *) "self",(char *) "string", NULL
39705 };
39706
39707 arg3 = &temp3;
39708 arg4 = &temp4;
39709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
39710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39711 if (!SWIG_IsOK(res1)) {
39712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
39713 }
39714 arg1 = reinterpret_cast< wxWindow * >(argp1);
39715 {
39716 arg2 = wxString_in_helper(obj1);
39717 if (arg2 == NULL) SWIG_fail;
39718 temp2 = true;
39719 }
39720 {
39721 PyThreadState* __tstate = wxPyBeginAllowThreads();
39722 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
39723 wxPyEndAllowThreads(__tstate);
39724 if (PyErr_Occurred()) SWIG_fail;
39725 }
39726 resultobj = SWIG_Py_Void();
39727 if (SWIG_IsTmpObj(res3)) {
39728 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39729 } else {
39730 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39731 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39732 }
39733 if (SWIG_IsTmpObj(res4)) {
39734 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
39735 } else {
39736 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39737 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
39738 }
39739 {
39740 if (temp2)
39741 delete arg2;
39742 }
39743 return resultobj;
39744 fail:
39745 {
39746 if (temp2)
39747 delete arg2;
39748 }
39749 return NULL;
39750 }
39751
39752
39753 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39754 PyObject *resultobj = 0;
39755 wxWindow *arg1 = (wxWindow *) 0 ;
39756 wxString *arg2 = 0 ;
39757 int *arg3 = (int *) 0 ;
39758 int *arg4 = (int *) 0 ;
39759 int *arg5 = (int *) 0 ;
39760 int *arg6 = (int *) 0 ;
39761 wxFont *arg7 = (wxFont *) NULL ;
39762 void *argp1 = 0 ;
39763 int res1 = 0 ;
39764 bool temp2 = false ;
39765 int temp3 ;
39766 int res3 = SWIG_TMPOBJ ;
39767 int temp4 ;
39768 int res4 = SWIG_TMPOBJ ;
39769 int temp5 ;
39770 int res5 = SWIG_TMPOBJ ;
39771 int temp6 ;
39772 int res6 = SWIG_TMPOBJ ;
39773 void *argp7 = 0 ;
39774 int res7 = 0 ;
39775 PyObject * obj0 = 0 ;
39776 PyObject * obj1 = 0 ;
39777 PyObject * obj2 = 0 ;
39778 char * kwnames[] = {
39779 (char *) "self",(char *) "string",(char *) "font", NULL
39780 };
39781
39782 arg3 = &temp3;
39783 arg4 = &temp4;
39784 arg5 = &temp5;
39785 arg6 = &temp6;
39786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39788 if (!SWIG_IsOK(res1)) {
39789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
39790 }
39791 arg1 = reinterpret_cast< wxWindow * >(argp1);
39792 {
39793 arg2 = wxString_in_helper(obj1);
39794 if (arg2 == NULL) SWIG_fail;
39795 temp2 = true;
39796 }
39797 if (obj2) {
39798 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
39799 if (!SWIG_IsOK(res7)) {
39800 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
39801 }
39802 arg7 = reinterpret_cast< wxFont * >(argp7);
39803 }
39804 {
39805 PyThreadState* __tstate = wxPyBeginAllowThreads();
39806 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
39807 wxPyEndAllowThreads(__tstate);
39808 if (PyErr_Occurred()) SWIG_fail;
39809 }
39810 resultobj = SWIG_Py_Void();
39811 if (SWIG_IsTmpObj(res3)) {
39812 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39813 } else {
39814 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39815 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39816 }
39817 if (SWIG_IsTmpObj(res4)) {
39818 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
39819 } else {
39820 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39821 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
39822 }
39823 if (SWIG_IsTmpObj(res5)) {
39824 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
39825 } else {
39826 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39827 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
39828 }
39829 if (SWIG_IsTmpObj(res6)) {
39830 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
39831 } else {
39832 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39833 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
39834 }
39835 {
39836 if (temp2)
39837 delete arg2;
39838 }
39839 return resultobj;
39840 fail:
39841 {
39842 if (temp2)
39843 delete arg2;
39844 }
39845 return NULL;
39846 }
39847
39848
39849 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39850 PyObject *resultobj = 0;
39851 wxWindow *arg1 = (wxWindow *) 0 ;
39852 int *arg2 = (int *) 0 ;
39853 int *arg3 = (int *) 0 ;
39854 void *argp1 = 0 ;
39855 int res1 = 0 ;
39856 int temp2 ;
39857 int res2 = 0 ;
39858 int temp3 ;
39859 int res3 = 0 ;
39860 PyObject * obj0 = 0 ;
39861 PyObject * obj1 = 0 ;
39862 PyObject * obj2 = 0 ;
39863 char * kwnames[] = {
39864 (char *) "self",(char *) "x",(char *) "y", NULL
39865 };
39866
39867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39869 if (!SWIG_IsOK(res1)) {
39870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39871 }
39872 arg1 = reinterpret_cast< wxWindow * >(argp1);
39873 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39874 int val;
39875 int ecode = SWIG_AsVal_int(obj1, &val);
39876 if (!SWIG_IsOK(ecode)) {
39877 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
39878 }
39879 temp2 = static_cast< int >(val);
39880 arg2 = &temp2;
39881 res2 = SWIG_AddTmpMask(ecode);
39882 }
39883 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39884 int val;
39885 int ecode = SWIG_AsVal_int(obj2, &val);
39886 if (!SWIG_IsOK(ecode)) {
39887 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
39888 }
39889 temp3 = static_cast< int >(val);
39890 arg3 = &temp3;
39891 res3 = SWIG_AddTmpMask(ecode);
39892 }
39893 {
39894 PyThreadState* __tstate = wxPyBeginAllowThreads();
39895 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
39896 wxPyEndAllowThreads(__tstate);
39897 if (PyErr_Occurred()) SWIG_fail;
39898 }
39899 resultobj = SWIG_Py_Void();
39900 if (SWIG_IsTmpObj(res2)) {
39901 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39902 } else {
39903 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39904 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39905 }
39906 if (SWIG_IsTmpObj(res3)) {
39907 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39908 } else {
39909 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39910 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39911 }
39912 return resultobj;
39913 fail:
39914 return NULL;
39915 }
39916
39917
39918 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39919 PyObject *resultobj = 0;
39920 wxWindow *arg1 = (wxWindow *) 0 ;
39921 int *arg2 = (int *) 0 ;
39922 int *arg3 = (int *) 0 ;
39923 void *argp1 = 0 ;
39924 int res1 = 0 ;
39925 int temp2 ;
39926 int res2 = 0 ;
39927 int temp3 ;
39928 int res3 = 0 ;
39929 PyObject * obj0 = 0 ;
39930 PyObject * obj1 = 0 ;
39931 PyObject * obj2 = 0 ;
39932 char * kwnames[] = {
39933 (char *) "self",(char *) "x",(char *) "y", NULL
39934 };
39935
39936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39938 if (!SWIG_IsOK(res1)) {
39939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39940 }
39941 arg1 = reinterpret_cast< wxWindow * >(argp1);
39942 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39943 int val;
39944 int ecode = SWIG_AsVal_int(obj1, &val);
39945 if (!SWIG_IsOK(ecode)) {
39946 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
39947 }
39948 temp2 = static_cast< int >(val);
39949 arg2 = &temp2;
39950 res2 = SWIG_AddTmpMask(ecode);
39951 }
39952 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39953 int val;
39954 int ecode = SWIG_AsVal_int(obj2, &val);
39955 if (!SWIG_IsOK(ecode)) {
39956 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
39957 }
39958 temp3 = static_cast< int >(val);
39959 arg3 = &temp3;
39960 res3 = SWIG_AddTmpMask(ecode);
39961 }
39962 {
39963 PyThreadState* __tstate = wxPyBeginAllowThreads();
39964 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
39965 wxPyEndAllowThreads(__tstate);
39966 if (PyErr_Occurred()) SWIG_fail;
39967 }
39968 resultobj = SWIG_Py_Void();
39969 if (SWIG_IsTmpObj(res2)) {
39970 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39971 } else {
39972 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39973 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39974 }
39975 if (SWIG_IsTmpObj(res3)) {
39976 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39977 } else {
39978 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39979 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39980 }
39981 return resultobj;
39982 fail:
39983 return NULL;
39984 }
39985
39986
39987 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39988 PyObject *resultobj = 0;
39989 wxWindow *arg1 = (wxWindow *) 0 ;
39990 wxPoint *arg2 = 0 ;
39991 wxPoint result;
39992 void *argp1 = 0 ;
39993 int res1 = 0 ;
39994 wxPoint temp2 ;
39995 PyObject * obj0 = 0 ;
39996 PyObject * obj1 = 0 ;
39997 char * kwnames[] = {
39998 (char *) "self",(char *) "pt", NULL
39999 };
40000
40001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
40002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40003 if (!SWIG_IsOK(res1)) {
40004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
40005 }
40006 arg1 = reinterpret_cast< wxWindow * >(argp1);
40007 {
40008 arg2 = &temp2;
40009 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40010 }
40011 {
40012 PyThreadState* __tstate = wxPyBeginAllowThreads();
40013 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
40014 wxPyEndAllowThreads(__tstate);
40015 if (PyErr_Occurred()) SWIG_fail;
40016 }
40017 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
40018 return resultobj;
40019 fail:
40020 return NULL;
40021 }
40022
40023
40024 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40025 PyObject *resultobj = 0;
40026 wxWindow *arg1 = (wxWindow *) 0 ;
40027 wxPoint *arg2 = 0 ;
40028 wxPoint result;
40029 void *argp1 = 0 ;
40030 int res1 = 0 ;
40031 wxPoint temp2 ;
40032 PyObject * obj0 = 0 ;
40033 PyObject * obj1 = 0 ;
40034 char * kwnames[] = {
40035 (char *) "self",(char *) "pt", NULL
40036 };
40037
40038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
40039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40040 if (!SWIG_IsOK(res1)) {
40041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
40042 }
40043 arg1 = reinterpret_cast< wxWindow * >(argp1);
40044 {
40045 arg2 = &temp2;
40046 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40047 }
40048 {
40049 PyThreadState* __tstate = wxPyBeginAllowThreads();
40050 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
40051 wxPyEndAllowThreads(__tstate);
40052 if (PyErr_Occurred()) SWIG_fail;
40053 }
40054 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
40055 return resultobj;
40056 fail:
40057 return NULL;
40058 }
40059
40060
40061 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40062 PyObject *resultobj = 0;
40063 wxWindow *arg1 = (wxWindow *) 0 ;
40064 int arg2 ;
40065 int arg3 ;
40066 wxHitTest result;
40067 void *argp1 = 0 ;
40068 int res1 = 0 ;
40069 int val2 ;
40070 int ecode2 = 0 ;
40071 int val3 ;
40072 int ecode3 = 0 ;
40073 PyObject * obj0 = 0 ;
40074 PyObject * obj1 = 0 ;
40075 PyObject * obj2 = 0 ;
40076 char * kwnames[] = {
40077 (char *) "self",(char *) "x",(char *) "y", NULL
40078 };
40079
40080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40082 if (!SWIG_IsOK(res1)) {
40083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
40084 }
40085 arg1 = reinterpret_cast< wxWindow * >(argp1);
40086 ecode2 = SWIG_AsVal_int(obj1, &val2);
40087 if (!SWIG_IsOK(ecode2)) {
40088 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
40089 }
40090 arg2 = static_cast< int >(val2);
40091 ecode3 = SWIG_AsVal_int(obj2, &val3);
40092 if (!SWIG_IsOK(ecode3)) {
40093 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
40094 }
40095 arg3 = static_cast< int >(val3);
40096 {
40097 PyThreadState* __tstate = wxPyBeginAllowThreads();
40098 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
40099 wxPyEndAllowThreads(__tstate);
40100 if (PyErr_Occurred()) SWIG_fail;
40101 }
40102 resultobj = SWIG_From_int(static_cast< int >(result));
40103 return resultobj;
40104 fail:
40105 return NULL;
40106 }
40107
40108
40109 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40110 PyObject *resultobj = 0;
40111 wxWindow *arg1 = (wxWindow *) 0 ;
40112 wxPoint *arg2 = 0 ;
40113 wxHitTest result;
40114 void *argp1 = 0 ;
40115 int res1 = 0 ;
40116 wxPoint temp2 ;
40117 PyObject * obj0 = 0 ;
40118 PyObject * obj1 = 0 ;
40119 char * kwnames[] = {
40120 (char *) "self",(char *) "pt", NULL
40121 };
40122
40123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
40124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40125 if (!SWIG_IsOK(res1)) {
40126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
40127 }
40128 arg1 = reinterpret_cast< wxWindow * >(argp1);
40129 {
40130 arg2 = &temp2;
40131 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40132 }
40133 {
40134 PyThreadState* __tstate = wxPyBeginAllowThreads();
40135 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
40136 wxPyEndAllowThreads(__tstate);
40137 if (PyErr_Occurred()) SWIG_fail;
40138 }
40139 resultobj = SWIG_From_int(static_cast< int >(result));
40140 return resultobj;
40141 fail:
40142 return NULL;
40143 }
40144
40145
40146 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
40147 PyObject *resultobj = 0;
40148 wxWindow *arg1 = (wxWindow *) 0 ;
40149 long arg2 ;
40150 wxBorder result;
40151 void *argp1 = 0 ;
40152 int res1 = 0 ;
40153 long val2 ;
40154 int ecode2 = 0 ;
40155
40156 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
40157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40158 if (!SWIG_IsOK(res1)) {
40159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
40160 }
40161 arg1 = reinterpret_cast< wxWindow * >(argp1);
40162 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
40163 if (!SWIG_IsOK(ecode2)) {
40164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
40165 }
40166 arg2 = static_cast< long >(val2);
40167 {
40168 PyThreadState* __tstate = wxPyBeginAllowThreads();
40169 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
40170 wxPyEndAllowThreads(__tstate);
40171 if (PyErr_Occurred()) SWIG_fail;
40172 }
40173 resultobj = SWIG_From_int(static_cast< int >(result));
40174 return resultobj;
40175 fail:
40176 return NULL;
40177 }
40178
40179
40180 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
40181 PyObject *resultobj = 0;
40182 wxWindow *arg1 = (wxWindow *) 0 ;
40183 wxBorder result;
40184 void *argp1 = 0 ;
40185 int res1 = 0 ;
40186
40187 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
40188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40189 if (!SWIG_IsOK(res1)) {
40190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
40191 }
40192 arg1 = reinterpret_cast< wxWindow * >(argp1);
40193 {
40194 PyThreadState* __tstate = wxPyBeginAllowThreads();
40195 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
40196 wxPyEndAllowThreads(__tstate);
40197 if (PyErr_Occurred()) SWIG_fail;
40198 }
40199 resultobj = SWIG_From_int(static_cast< int >(result));
40200 return resultobj;
40201 fail:
40202 return NULL;
40203 }
40204
40205
40206 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
40207 int argc;
40208 PyObject *argv[3];
40209
40210 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
40211 --argc;
40212 if (argc == 1) {
40213 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
40214 }
40215 if (argc == 2) {
40216 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
40217 }
40218
40219 fail:
40220 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
40221 return NULL;
40222 }
40223
40224
40225 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40226 PyObject *resultobj = 0;
40227 wxWindow *arg1 = (wxWindow *) 0 ;
40228 long arg2 = (long) wxUPDATE_UI_NONE ;
40229 void *argp1 = 0 ;
40230 int res1 = 0 ;
40231 long val2 ;
40232 int ecode2 = 0 ;
40233 PyObject * obj0 = 0 ;
40234 PyObject * obj1 = 0 ;
40235 char * kwnames[] = {
40236 (char *) "self",(char *) "flags", NULL
40237 };
40238
40239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
40240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40241 if (!SWIG_IsOK(res1)) {
40242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
40243 }
40244 arg1 = reinterpret_cast< wxWindow * >(argp1);
40245 if (obj1) {
40246 ecode2 = SWIG_AsVal_long(obj1, &val2);
40247 if (!SWIG_IsOK(ecode2)) {
40248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
40249 }
40250 arg2 = static_cast< long >(val2);
40251 }
40252 {
40253 PyThreadState* __tstate = wxPyBeginAllowThreads();
40254 (arg1)->UpdateWindowUI(arg2);
40255 wxPyEndAllowThreads(__tstate);
40256 if (PyErr_Occurred()) SWIG_fail;
40257 }
40258 resultobj = SWIG_Py_Void();
40259 return resultobj;
40260 fail:
40261 return NULL;
40262 }
40263
40264
40265 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40266 PyObject *resultobj = 0;
40267 wxWindow *arg1 = (wxWindow *) 0 ;
40268 wxMenu *arg2 = (wxMenu *) 0 ;
40269 int arg3 = (int) -1 ;
40270 int arg4 = (int) -1 ;
40271 bool result;
40272 void *argp1 = 0 ;
40273 int res1 = 0 ;
40274 void *argp2 = 0 ;
40275 int res2 = 0 ;
40276 int val3 ;
40277 int ecode3 = 0 ;
40278 int val4 ;
40279 int ecode4 = 0 ;
40280 PyObject * obj0 = 0 ;
40281 PyObject * obj1 = 0 ;
40282 PyObject * obj2 = 0 ;
40283 PyObject * obj3 = 0 ;
40284 char * kwnames[] = {
40285 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
40286 };
40287
40288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40290 if (!SWIG_IsOK(res1)) {
40291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
40292 }
40293 arg1 = reinterpret_cast< wxWindow * >(argp1);
40294 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40295 if (!SWIG_IsOK(res2)) {
40296 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
40297 }
40298 arg2 = reinterpret_cast< wxMenu * >(argp2);
40299 if (obj2) {
40300 ecode3 = SWIG_AsVal_int(obj2, &val3);
40301 if (!SWIG_IsOK(ecode3)) {
40302 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
40303 }
40304 arg3 = static_cast< int >(val3);
40305 }
40306 if (obj3) {
40307 ecode4 = SWIG_AsVal_int(obj3, &val4);
40308 if (!SWIG_IsOK(ecode4)) {
40309 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
40310 }
40311 arg4 = static_cast< int >(val4);
40312 }
40313 {
40314 PyThreadState* __tstate = wxPyBeginAllowThreads();
40315 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
40316 wxPyEndAllowThreads(__tstate);
40317 if (PyErr_Occurred()) SWIG_fail;
40318 }
40319 {
40320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40321 }
40322 return resultobj;
40323 fail:
40324 return NULL;
40325 }
40326
40327
40328 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40329 PyObject *resultobj = 0;
40330 wxWindow *arg1 = (wxWindow *) 0 ;
40331 wxMenu *arg2 = (wxMenu *) 0 ;
40332 wxPoint const &arg3_defvalue = wxDefaultPosition ;
40333 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
40334 bool result;
40335 void *argp1 = 0 ;
40336 int res1 = 0 ;
40337 void *argp2 = 0 ;
40338 int res2 = 0 ;
40339 wxPoint temp3 ;
40340 PyObject * obj0 = 0 ;
40341 PyObject * obj1 = 0 ;
40342 PyObject * obj2 = 0 ;
40343 char * kwnames[] = {
40344 (char *) "self",(char *) "menu",(char *) "pos", NULL
40345 };
40346
40347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40349 if (!SWIG_IsOK(res1)) {
40350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
40351 }
40352 arg1 = reinterpret_cast< wxWindow * >(argp1);
40353 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40354 if (!SWIG_IsOK(res2)) {
40355 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
40356 }
40357 arg2 = reinterpret_cast< wxMenu * >(argp2);
40358 if (obj2) {
40359 {
40360 arg3 = &temp3;
40361 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
40362 }
40363 }
40364 {
40365 PyThreadState* __tstate = wxPyBeginAllowThreads();
40366 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
40367 wxPyEndAllowThreads(__tstate);
40368 if (PyErr_Occurred()) SWIG_fail;
40369 }
40370 {
40371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40372 }
40373 return resultobj;
40374 fail:
40375 return NULL;
40376 }
40377
40378
40379 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40380 PyObject *resultobj = 0;
40381 wxWindow *arg1 = (wxWindow *) 0 ;
40382 bool result;
40383 void *argp1 = 0 ;
40384 int res1 = 0 ;
40385 PyObject *swig_obj[1] ;
40386
40387 if (!args) SWIG_fail;
40388 swig_obj[0] = args;
40389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40390 if (!SWIG_IsOK(res1)) {
40391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
40392 }
40393 arg1 = reinterpret_cast< wxWindow * >(argp1);
40394 {
40395 PyThreadState* __tstate = wxPyBeginAllowThreads();
40396 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
40397 wxPyEndAllowThreads(__tstate);
40398 if (PyErr_Occurred()) SWIG_fail;
40399 }
40400 {
40401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40402 }
40403 return resultobj;
40404 fail:
40405 return NULL;
40406 }
40407
40408
40409 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40410 PyObject *resultobj = 0;
40411 wxWindow *arg1 = (wxWindow *) 0 ;
40412 long result;
40413 void *argp1 = 0 ;
40414 int res1 = 0 ;
40415 PyObject *swig_obj[1] ;
40416
40417 if (!args) SWIG_fail;
40418 swig_obj[0] = args;
40419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40420 if (!SWIG_IsOK(res1)) {
40421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
40422 }
40423 arg1 = reinterpret_cast< wxWindow * >(argp1);
40424 {
40425 PyThreadState* __tstate = wxPyBeginAllowThreads();
40426 result = (long)wxWindow_GetHandle(arg1);
40427 wxPyEndAllowThreads(__tstate);
40428 if (PyErr_Occurred()) SWIG_fail;
40429 }
40430 resultobj = SWIG_From_long(static_cast< long >(result));
40431 return resultobj;
40432 fail:
40433 return NULL;
40434 }
40435
40436
40437 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40438 PyObject *resultobj = 0;
40439 wxWindow *arg1 = (wxWindow *) 0 ;
40440 long arg2 ;
40441 void *argp1 = 0 ;
40442 int res1 = 0 ;
40443 long val2 ;
40444 int ecode2 = 0 ;
40445 PyObject * obj0 = 0 ;
40446 PyObject * obj1 = 0 ;
40447 char * kwnames[] = {
40448 (char *) "self",(char *) "handle", NULL
40449 };
40450
40451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
40452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40453 if (!SWIG_IsOK(res1)) {
40454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
40455 }
40456 arg1 = reinterpret_cast< wxWindow * >(argp1);
40457 ecode2 = SWIG_AsVal_long(obj1, &val2);
40458 if (!SWIG_IsOK(ecode2)) {
40459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
40460 }
40461 arg2 = static_cast< long >(val2);
40462 {
40463 PyThreadState* __tstate = wxPyBeginAllowThreads();
40464 wxWindow_AssociateHandle(arg1,arg2);
40465 wxPyEndAllowThreads(__tstate);
40466 if (PyErr_Occurred()) SWIG_fail;
40467 }
40468 resultobj = SWIG_Py_Void();
40469 return resultobj;
40470 fail:
40471 return NULL;
40472 }
40473
40474
40475 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40476 PyObject *resultobj = 0;
40477 wxWindow *arg1 = (wxWindow *) 0 ;
40478 void *argp1 = 0 ;
40479 int res1 = 0 ;
40480 PyObject *swig_obj[1] ;
40481
40482 if (!args) SWIG_fail;
40483 swig_obj[0] = args;
40484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40485 if (!SWIG_IsOK(res1)) {
40486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
40487 }
40488 arg1 = reinterpret_cast< wxWindow * >(argp1);
40489 {
40490 PyThreadState* __tstate = wxPyBeginAllowThreads();
40491 (arg1)->DissociateHandle();
40492 wxPyEndAllowThreads(__tstate);
40493 if (PyErr_Occurred()) SWIG_fail;
40494 }
40495 resultobj = SWIG_Py_Void();
40496 return resultobj;
40497 fail:
40498 return NULL;
40499 }
40500
40501
40502 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40503 PyObject *resultobj = 0;
40504 wxWindow *arg1 = (wxWindow *) 0 ;
40505 int arg2 ;
40506 bool result;
40507 void *argp1 = 0 ;
40508 int res1 = 0 ;
40509 int val2 ;
40510 int ecode2 = 0 ;
40511 PyObject * obj0 = 0 ;
40512 PyObject * obj1 = 0 ;
40513 char * kwnames[] = {
40514 (char *) "self",(char *) "orient", NULL
40515 };
40516
40517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
40518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40519 if (!SWIG_IsOK(res1)) {
40520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
40521 }
40522 arg1 = reinterpret_cast< wxWindow * >(argp1);
40523 ecode2 = SWIG_AsVal_int(obj1, &val2);
40524 if (!SWIG_IsOK(ecode2)) {
40525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
40526 }
40527 arg2 = static_cast< int >(val2);
40528 {
40529 PyThreadState* __tstate = wxPyBeginAllowThreads();
40530 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
40531 wxPyEndAllowThreads(__tstate);
40532 if (PyErr_Occurred()) SWIG_fail;
40533 }
40534 {
40535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40536 }
40537 return resultobj;
40538 fail:
40539 return NULL;
40540 }
40541
40542
40543 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40544 PyObject *resultobj = 0;
40545 wxWindow *arg1 = (wxWindow *) 0 ;
40546 int arg2 ;
40547 int arg3 ;
40548 int arg4 ;
40549 int arg5 ;
40550 bool arg6 = (bool) true ;
40551 void *argp1 = 0 ;
40552 int res1 = 0 ;
40553 int val2 ;
40554 int ecode2 = 0 ;
40555 int val3 ;
40556 int ecode3 = 0 ;
40557 int val4 ;
40558 int ecode4 = 0 ;
40559 int val5 ;
40560 int ecode5 = 0 ;
40561 bool val6 ;
40562 int ecode6 = 0 ;
40563 PyObject * obj0 = 0 ;
40564 PyObject * obj1 = 0 ;
40565 PyObject * obj2 = 0 ;
40566 PyObject * obj3 = 0 ;
40567 PyObject * obj4 = 0 ;
40568 PyObject * obj5 = 0 ;
40569 char * kwnames[] = {
40570 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
40571 };
40572
40573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
40574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40575 if (!SWIG_IsOK(res1)) {
40576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
40577 }
40578 arg1 = reinterpret_cast< wxWindow * >(argp1);
40579 ecode2 = SWIG_AsVal_int(obj1, &val2);
40580 if (!SWIG_IsOK(ecode2)) {
40581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
40582 }
40583 arg2 = static_cast< int >(val2);
40584 ecode3 = SWIG_AsVal_int(obj2, &val3);
40585 if (!SWIG_IsOK(ecode3)) {
40586 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
40587 }
40588 arg3 = static_cast< int >(val3);
40589 ecode4 = SWIG_AsVal_int(obj3, &val4);
40590 if (!SWIG_IsOK(ecode4)) {
40591 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
40592 }
40593 arg4 = static_cast< int >(val4);
40594 ecode5 = SWIG_AsVal_int(obj4, &val5);
40595 if (!SWIG_IsOK(ecode5)) {
40596 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
40597 }
40598 arg5 = static_cast< int >(val5);
40599 if (obj5) {
40600 ecode6 = SWIG_AsVal_bool(obj5, &val6);
40601 if (!SWIG_IsOK(ecode6)) {
40602 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
40603 }
40604 arg6 = static_cast< bool >(val6);
40605 }
40606 {
40607 PyThreadState* __tstate = wxPyBeginAllowThreads();
40608 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
40609 wxPyEndAllowThreads(__tstate);
40610 if (PyErr_Occurred()) SWIG_fail;
40611 }
40612 resultobj = SWIG_Py_Void();
40613 return resultobj;
40614 fail:
40615 return NULL;
40616 }
40617
40618
40619 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40620 PyObject *resultobj = 0;
40621 wxWindow *arg1 = (wxWindow *) 0 ;
40622 int arg2 ;
40623 int arg3 ;
40624 bool arg4 = (bool) true ;
40625 void *argp1 = 0 ;
40626 int res1 = 0 ;
40627 int val2 ;
40628 int ecode2 = 0 ;
40629 int val3 ;
40630 int ecode3 = 0 ;
40631 bool val4 ;
40632 int ecode4 = 0 ;
40633 PyObject * obj0 = 0 ;
40634 PyObject * obj1 = 0 ;
40635 PyObject * obj2 = 0 ;
40636 PyObject * obj3 = 0 ;
40637 char * kwnames[] = {
40638 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
40639 };
40640
40641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40643 if (!SWIG_IsOK(res1)) {
40644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
40645 }
40646 arg1 = reinterpret_cast< wxWindow * >(argp1);
40647 ecode2 = SWIG_AsVal_int(obj1, &val2);
40648 if (!SWIG_IsOK(ecode2)) {
40649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
40650 }
40651 arg2 = static_cast< int >(val2);
40652 ecode3 = SWIG_AsVal_int(obj2, &val3);
40653 if (!SWIG_IsOK(ecode3)) {
40654 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
40655 }
40656 arg3 = static_cast< int >(val3);
40657 if (obj3) {
40658 ecode4 = SWIG_AsVal_bool(obj3, &val4);
40659 if (!SWIG_IsOK(ecode4)) {
40660 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
40661 }
40662 arg4 = static_cast< bool >(val4);
40663 }
40664 {
40665 PyThreadState* __tstate = wxPyBeginAllowThreads();
40666 (arg1)->SetScrollPos(arg2,arg3,arg4);
40667 wxPyEndAllowThreads(__tstate);
40668 if (PyErr_Occurred()) SWIG_fail;
40669 }
40670 resultobj = SWIG_Py_Void();
40671 return resultobj;
40672 fail:
40673 return NULL;
40674 }
40675
40676
40677 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40678 PyObject *resultobj = 0;
40679 wxWindow *arg1 = (wxWindow *) 0 ;
40680 int arg2 ;
40681 int result;
40682 void *argp1 = 0 ;
40683 int res1 = 0 ;
40684 int val2 ;
40685 int ecode2 = 0 ;
40686 PyObject * obj0 = 0 ;
40687 PyObject * obj1 = 0 ;
40688 char * kwnames[] = {
40689 (char *) "self",(char *) "orientation", NULL
40690 };
40691
40692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
40693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40694 if (!SWIG_IsOK(res1)) {
40695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
40696 }
40697 arg1 = reinterpret_cast< wxWindow * >(argp1);
40698 ecode2 = SWIG_AsVal_int(obj1, &val2);
40699 if (!SWIG_IsOK(ecode2)) {
40700 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
40701 }
40702 arg2 = static_cast< int >(val2);
40703 {
40704 PyThreadState* __tstate = wxPyBeginAllowThreads();
40705 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
40706 wxPyEndAllowThreads(__tstate);
40707 if (PyErr_Occurred()) SWIG_fail;
40708 }
40709 resultobj = SWIG_From_int(static_cast< int >(result));
40710 return resultobj;
40711 fail:
40712 return NULL;
40713 }
40714
40715
40716 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40717 PyObject *resultobj = 0;
40718 wxWindow *arg1 = (wxWindow *) 0 ;
40719 int arg2 ;
40720 int result;
40721 void *argp1 = 0 ;
40722 int res1 = 0 ;
40723 int val2 ;
40724 int ecode2 = 0 ;
40725 PyObject * obj0 = 0 ;
40726 PyObject * obj1 = 0 ;
40727 char * kwnames[] = {
40728 (char *) "self",(char *) "orientation", NULL
40729 };
40730
40731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
40732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40733 if (!SWIG_IsOK(res1)) {
40734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
40735 }
40736 arg1 = reinterpret_cast< wxWindow * >(argp1);
40737 ecode2 = SWIG_AsVal_int(obj1, &val2);
40738 if (!SWIG_IsOK(ecode2)) {
40739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
40740 }
40741 arg2 = static_cast< int >(val2);
40742 {
40743 PyThreadState* __tstate = wxPyBeginAllowThreads();
40744 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
40745 wxPyEndAllowThreads(__tstate);
40746 if (PyErr_Occurred()) SWIG_fail;
40747 }
40748 resultobj = SWIG_From_int(static_cast< int >(result));
40749 return resultobj;
40750 fail:
40751 return NULL;
40752 }
40753
40754
40755 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40756 PyObject *resultobj = 0;
40757 wxWindow *arg1 = (wxWindow *) 0 ;
40758 int arg2 ;
40759 int result;
40760 void *argp1 = 0 ;
40761 int res1 = 0 ;
40762 int val2 ;
40763 int ecode2 = 0 ;
40764 PyObject * obj0 = 0 ;
40765 PyObject * obj1 = 0 ;
40766 char * kwnames[] = {
40767 (char *) "self",(char *) "orientation", NULL
40768 };
40769
40770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
40771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40772 if (!SWIG_IsOK(res1)) {
40773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
40774 }
40775 arg1 = reinterpret_cast< wxWindow * >(argp1);
40776 ecode2 = SWIG_AsVal_int(obj1, &val2);
40777 if (!SWIG_IsOK(ecode2)) {
40778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
40779 }
40780 arg2 = static_cast< int >(val2);
40781 {
40782 PyThreadState* __tstate = wxPyBeginAllowThreads();
40783 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
40784 wxPyEndAllowThreads(__tstate);
40785 if (PyErr_Occurred()) SWIG_fail;
40786 }
40787 resultobj = SWIG_From_int(static_cast< int >(result));
40788 return resultobj;
40789 fail:
40790 return NULL;
40791 }
40792
40793
40794 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40795 PyObject *resultobj = 0;
40796 wxWindow *arg1 = (wxWindow *) 0 ;
40797 int arg2 ;
40798 int arg3 ;
40799 wxRect *arg4 = (wxRect *) NULL ;
40800 void *argp1 = 0 ;
40801 int res1 = 0 ;
40802 int val2 ;
40803 int ecode2 = 0 ;
40804 int val3 ;
40805 int ecode3 = 0 ;
40806 void *argp4 = 0 ;
40807 int res4 = 0 ;
40808 PyObject * obj0 = 0 ;
40809 PyObject * obj1 = 0 ;
40810 PyObject * obj2 = 0 ;
40811 PyObject * obj3 = 0 ;
40812 char * kwnames[] = {
40813 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
40814 };
40815
40816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40818 if (!SWIG_IsOK(res1)) {
40819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
40820 }
40821 arg1 = reinterpret_cast< wxWindow * >(argp1);
40822 ecode2 = SWIG_AsVal_int(obj1, &val2);
40823 if (!SWIG_IsOK(ecode2)) {
40824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
40825 }
40826 arg2 = static_cast< int >(val2);
40827 ecode3 = SWIG_AsVal_int(obj2, &val3);
40828 if (!SWIG_IsOK(ecode3)) {
40829 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
40830 }
40831 arg3 = static_cast< int >(val3);
40832 if (obj3) {
40833 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
40834 if (!SWIG_IsOK(res4)) {
40835 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
40836 }
40837 arg4 = reinterpret_cast< wxRect * >(argp4);
40838 }
40839 {
40840 PyThreadState* __tstate = wxPyBeginAllowThreads();
40841 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
40842 wxPyEndAllowThreads(__tstate);
40843 if (PyErr_Occurred()) SWIG_fail;
40844 }
40845 resultobj = SWIG_Py_Void();
40846 return resultobj;
40847 fail:
40848 return NULL;
40849 }
40850
40851
40852 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40853 PyObject *resultobj = 0;
40854 wxWindow *arg1 = (wxWindow *) 0 ;
40855 int arg2 ;
40856 bool result;
40857 void *argp1 = 0 ;
40858 int res1 = 0 ;
40859 int val2 ;
40860 int ecode2 = 0 ;
40861 PyObject * obj0 = 0 ;
40862 PyObject * obj1 = 0 ;
40863 char * kwnames[] = {
40864 (char *) "self",(char *) "lines", NULL
40865 };
40866
40867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
40868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40869 if (!SWIG_IsOK(res1)) {
40870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
40871 }
40872 arg1 = reinterpret_cast< wxWindow * >(argp1);
40873 ecode2 = SWIG_AsVal_int(obj1, &val2);
40874 if (!SWIG_IsOK(ecode2)) {
40875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
40876 }
40877 arg2 = static_cast< int >(val2);
40878 {
40879 PyThreadState* __tstate = wxPyBeginAllowThreads();
40880 result = (bool)(arg1)->ScrollLines(arg2);
40881 wxPyEndAllowThreads(__tstate);
40882 if (PyErr_Occurred()) SWIG_fail;
40883 }
40884 {
40885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40886 }
40887 return resultobj;
40888 fail:
40889 return NULL;
40890 }
40891
40892
40893 SWIGINTERN PyObject *_wrap_Window_ScrollPages(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 *) "pages", NULL
40906 };
40907
40908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",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_ScrollPages" "', 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_ScrollPages" "', expected argument " "2"" of type '" "int""'");
40917 }
40918 arg2 = static_cast< int >(val2);
40919 {
40920 PyThreadState* __tstate = wxPyBeginAllowThreads();
40921 result = (bool)(arg1)->ScrollPages(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_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40935 PyObject *resultobj = 0;
40936 wxWindow *arg1 = (wxWindow *) 0 ;
40937 bool result;
40938 void *argp1 = 0 ;
40939 int res1 = 0 ;
40940 PyObject *swig_obj[1] ;
40941
40942 if (!args) SWIG_fail;
40943 swig_obj[0] = args;
40944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40945 if (!SWIG_IsOK(res1)) {
40946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40947 }
40948 arg1 = reinterpret_cast< wxWindow * >(argp1);
40949 {
40950 PyThreadState* __tstate = wxPyBeginAllowThreads();
40951 result = (bool)(arg1)->LineUp();
40952 wxPyEndAllowThreads(__tstate);
40953 if (PyErr_Occurred()) SWIG_fail;
40954 }
40955 {
40956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40957 }
40958 return resultobj;
40959 fail:
40960 return NULL;
40961 }
40962
40963
40964 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40965 PyObject *resultobj = 0;
40966 wxWindow *arg1 = (wxWindow *) 0 ;
40967 bool result;
40968 void *argp1 = 0 ;
40969 int res1 = 0 ;
40970 PyObject *swig_obj[1] ;
40971
40972 if (!args) SWIG_fail;
40973 swig_obj[0] = args;
40974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40975 if (!SWIG_IsOK(res1)) {
40976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40977 }
40978 arg1 = reinterpret_cast< wxWindow * >(argp1);
40979 {
40980 PyThreadState* __tstate = wxPyBeginAllowThreads();
40981 result = (bool)(arg1)->LineDown();
40982 wxPyEndAllowThreads(__tstate);
40983 if (PyErr_Occurred()) SWIG_fail;
40984 }
40985 {
40986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40987 }
40988 return resultobj;
40989 fail:
40990 return NULL;
40991 }
40992
40993
40994 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40995 PyObject *resultobj = 0;
40996 wxWindow *arg1 = (wxWindow *) 0 ;
40997 bool result;
40998 void *argp1 = 0 ;
40999 int res1 = 0 ;
41000 PyObject *swig_obj[1] ;
41001
41002 if (!args) SWIG_fail;
41003 swig_obj[0] = args;
41004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41005 if (!SWIG_IsOK(res1)) {
41006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
41007 }
41008 arg1 = reinterpret_cast< wxWindow * >(argp1);
41009 {
41010 PyThreadState* __tstate = wxPyBeginAllowThreads();
41011 result = (bool)(arg1)->PageUp();
41012 wxPyEndAllowThreads(__tstate);
41013 if (PyErr_Occurred()) SWIG_fail;
41014 }
41015 {
41016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41017 }
41018 return resultobj;
41019 fail:
41020 return NULL;
41021 }
41022
41023
41024 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41025 PyObject *resultobj = 0;
41026 wxWindow *arg1 = (wxWindow *) 0 ;
41027 bool result;
41028 void *argp1 = 0 ;
41029 int res1 = 0 ;
41030 PyObject *swig_obj[1] ;
41031
41032 if (!args) SWIG_fail;
41033 swig_obj[0] = args;
41034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41035 if (!SWIG_IsOK(res1)) {
41036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
41037 }
41038 arg1 = reinterpret_cast< wxWindow * >(argp1);
41039 {
41040 PyThreadState* __tstate = wxPyBeginAllowThreads();
41041 result = (bool)(arg1)->PageDown();
41042 wxPyEndAllowThreads(__tstate);
41043 if (PyErr_Occurred()) SWIG_fail;
41044 }
41045 {
41046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41047 }
41048 return resultobj;
41049 fail:
41050 return NULL;
41051 }
41052
41053
41054 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41055 PyObject *resultobj = 0;
41056 wxWindow *arg1 = (wxWindow *) 0 ;
41057 wxString *arg2 = 0 ;
41058 void *argp1 = 0 ;
41059 int res1 = 0 ;
41060 bool temp2 = false ;
41061 PyObject * obj0 = 0 ;
41062 PyObject * obj1 = 0 ;
41063 char * kwnames[] = {
41064 (char *) "self",(char *) "text", NULL
41065 };
41066
41067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
41068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41069 if (!SWIG_IsOK(res1)) {
41070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
41071 }
41072 arg1 = reinterpret_cast< wxWindow * >(argp1);
41073 {
41074 arg2 = wxString_in_helper(obj1);
41075 if (arg2 == NULL) SWIG_fail;
41076 temp2 = true;
41077 }
41078 {
41079 PyThreadState* __tstate = wxPyBeginAllowThreads();
41080 (arg1)->SetHelpText((wxString const &)*arg2);
41081 wxPyEndAllowThreads(__tstate);
41082 if (PyErr_Occurred()) SWIG_fail;
41083 }
41084 resultobj = SWIG_Py_Void();
41085 {
41086 if (temp2)
41087 delete arg2;
41088 }
41089 return resultobj;
41090 fail:
41091 {
41092 if (temp2)
41093 delete arg2;
41094 }
41095 return NULL;
41096 }
41097
41098
41099 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41100 PyObject *resultobj = 0;
41101 wxWindow *arg1 = (wxWindow *) 0 ;
41102 wxString *arg2 = 0 ;
41103 void *argp1 = 0 ;
41104 int res1 = 0 ;
41105 bool temp2 = false ;
41106 PyObject * obj0 = 0 ;
41107 PyObject * obj1 = 0 ;
41108 char * kwnames[] = {
41109 (char *) "self",(char *) "text", NULL
41110 };
41111
41112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
41113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41114 if (!SWIG_IsOK(res1)) {
41115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
41116 }
41117 arg1 = reinterpret_cast< wxWindow * >(argp1);
41118 {
41119 arg2 = wxString_in_helper(obj1);
41120 if (arg2 == NULL) SWIG_fail;
41121 temp2 = true;
41122 }
41123 {
41124 PyThreadState* __tstate = wxPyBeginAllowThreads();
41125 (arg1)->SetHelpTextForId((wxString const &)*arg2);
41126 wxPyEndAllowThreads(__tstate);
41127 if (PyErr_Occurred()) SWIG_fail;
41128 }
41129 resultobj = SWIG_Py_Void();
41130 {
41131 if (temp2)
41132 delete arg2;
41133 }
41134 return resultobj;
41135 fail:
41136 {
41137 if (temp2)
41138 delete arg2;
41139 }
41140 return NULL;
41141 }
41142
41143
41144 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41145 PyObject *resultobj = 0;
41146 wxWindow *arg1 = (wxWindow *) 0 ;
41147 wxPoint *arg2 = 0 ;
41148 wxHelpEvent::Origin arg3 ;
41149 wxString result;
41150 void *argp1 = 0 ;
41151 int res1 = 0 ;
41152 wxPoint temp2 ;
41153 void *argp3 ;
41154 int res3 = 0 ;
41155 PyObject * obj0 = 0 ;
41156 PyObject * obj1 = 0 ;
41157 PyObject * obj2 = 0 ;
41158 char * kwnames[] = {
41159 (char *) "self",(char *) "pt",(char *) "origin", NULL
41160 };
41161
41162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41164 if (!SWIG_IsOK(res1)) {
41165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
41166 }
41167 arg1 = reinterpret_cast< wxWindow * >(argp1);
41168 {
41169 arg2 = &temp2;
41170 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
41171 }
41172 {
41173 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
41174 if (!SWIG_IsOK(res3)) {
41175 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
41176 }
41177 if (!argp3) {
41178 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
41179 } else {
41180 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
41181 arg3 = *temp;
41182 if (SWIG_IsNewObj(res3)) delete temp;
41183 }
41184 }
41185 {
41186 PyThreadState* __tstate = wxPyBeginAllowThreads();
41187 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
41188 wxPyEndAllowThreads(__tstate);
41189 if (PyErr_Occurred()) SWIG_fail;
41190 }
41191 {
41192 #if wxUSE_UNICODE
41193 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41194 #else
41195 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41196 #endif
41197 }
41198 return resultobj;
41199 fail:
41200 return NULL;
41201 }
41202
41203
41204 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41205 PyObject *resultobj = 0;
41206 wxWindow *arg1 = (wxWindow *) 0 ;
41207 wxString result;
41208 void *argp1 = 0 ;
41209 int res1 = 0 ;
41210 PyObject *swig_obj[1] ;
41211
41212 if (!args) SWIG_fail;
41213 swig_obj[0] = args;
41214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41215 if (!SWIG_IsOK(res1)) {
41216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
41217 }
41218 arg1 = reinterpret_cast< wxWindow * >(argp1);
41219 {
41220 PyThreadState* __tstate = wxPyBeginAllowThreads();
41221 result = ((wxWindow const *)arg1)->GetHelpText();
41222 wxPyEndAllowThreads(__tstate);
41223 if (PyErr_Occurred()) SWIG_fail;
41224 }
41225 {
41226 #if wxUSE_UNICODE
41227 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41228 #else
41229 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41230 #endif
41231 }
41232 return resultobj;
41233 fail:
41234 return NULL;
41235 }
41236
41237
41238 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41239 PyObject *resultobj = 0;
41240 wxWindow *arg1 = (wxWindow *) 0 ;
41241 wxString *arg2 = 0 ;
41242 void *argp1 = 0 ;
41243 int res1 = 0 ;
41244 bool temp2 = false ;
41245 PyObject * obj0 = 0 ;
41246 PyObject * obj1 = 0 ;
41247 char * kwnames[] = {
41248 (char *) "self",(char *) "tip", NULL
41249 };
41250
41251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
41252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41253 if (!SWIG_IsOK(res1)) {
41254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
41255 }
41256 arg1 = reinterpret_cast< wxWindow * >(argp1);
41257 {
41258 arg2 = wxString_in_helper(obj1);
41259 if (arg2 == NULL) SWIG_fail;
41260 temp2 = true;
41261 }
41262 {
41263 PyThreadState* __tstate = wxPyBeginAllowThreads();
41264 (arg1)->SetToolTip((wxString const &)*arg2);
41265 wxPyEndAllowThreads(__tstate);
41266 if (PyErr_Occurred()) SWIG_fail;
41267 }
41268 resultobj = SWIG_Py_Void();
41269 {
41270 if (temp2)
41271 delete arg2;
41272 }
41273 return resultobj;
41274 fail:
41275 {
41276 if (temp2)
41277 delete arg2;
41278 }
41279 return NULL;
41280 }
41281
41282
41283 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41284 PyObject *resultobj = 0;
41285 wxWindow *arg1 = (wxWindow *) 0 ;
41286 wxToolTip *arg2 = (wxToolTip *) 0 ;
41287 void *argp1 = 0 ;
41288 int res1 = 0 ;
41289 int res2 = 0 ;
41290 PyObject * obj0 = 0 ;
41291 PyObject * obj1 = 0 ;
41292 char * kwnames[] = {
41293 (char *) "self",(char *) "tip", NULL
41294 };
41295
41296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
41297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41298 if (!SWIG_IsOK(res1)) {
41299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
41300 }
41301 arg1 = reinterpret_cast< wxWindow * >(argp1);
41302 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
41303 if (!SWIG_IsOK(res2)) {
41304 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
41305 }
41306 {
41307 PyThreadState* __tstate = wxPyBeginAllowThreads();
41308 (arg1)->SetToolTip(arg2);
41309 wxPyEndAllowThreads(__tstate);
41310 if (PyErr_Occurred()) SWIG_fail;
41311 }
41312 resultobj = SWIG_Py_Void();
41313 return resultobj;
41314 fail:
41315 return NULL;
41316 }
41317
41318
41319 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41320 PyObject *resultobj = 0;
41321 wxWindow *arg1 = (wxWindow *) 0 ;
41322 wxToolTip *result = 0 ;
41323 void *argp1 = 0 ;
41324 int res1 = 0 ;
41325 PyObject *swig_obj[1] ;
41326
41327 if (!args) SWIG_fail;
41328 swig_obj[0] = args;
41329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41330 if (!SWIG_IsOK(res1)) {
41331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
41332 }
41333 arg1 = reinterpret_cast< wxWindow * >(argp1);
41334 {
41335 PyThreadState* __tstate = wxPyBeginAllowThreads();
41336 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
41337 wxPyEndAllowThreads(__tstate);
41338 if (PyErr_Occurred()) SWIG_fail;
41339 }
41340 {
41341 resultobj = wxPyMake_wxObject(result, (bool)0);
41342 }
41343 return resultobj;
41344 fail:
41345 return NULL;
41346 }
41347
41348
41349 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41350 PyObject *resultobj = 0;
41351 wxWindow *arg1 = (wxWindow *) 0 ;
41352 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
41353 void *argp1 = 0 ;
41354 int res1 = 0 ;
41355 int res2 = 0 ;
41356 PyObject * obj0 = 0 ;
41357 PyObject * obj1 = 0 ;
41358 char * kwnames[] = {
41359 (char *) "self",(char *) "dropTarget", NULL
41360 };
41361
41362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
41363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41364 if (!SWIG_IsOK(res1)) {
41365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
41366 }
41367 arg1 = reinterpret_cast< wxWindow * >(argp1);
41368 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
41369 if (!SWIG_IsOK(res2)) {
41370 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
41371 }
41372 {
41373 PyThreadState* __tstate = wxPyBeginAllowThreads();
41374 (arg1)->SetDropTarget(arg2);
41375 wxPyEndAllowThreads(__tstate);
41376 if (PyErr_Occurred()) SWIG_fail;
41377 }
41378 resultobj = SWIG_Py_Void();
41379 return resultobj;
41380 fail:
41381 return NULL;
41382 }
41383
41384
41385 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41386 PyObject *resultobj = 0;
41387 wxWindow *arg1 = (wxWindow *) 0 ;
41388 wxPyDropTarget *result = 0 ;
41389 void *argp1 = 0 ;
41390 int res1 = 0 ;
41391 PyObject *swig_obj[1] ;
41392
41393 if (!args) SWIG_fail;
41394 swig_obj[0] = args;
41395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41396 if (!SWIG_IsOK(res1)) {
41397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
41398 }
41399 arg1 = reinterpret_cast< wxWindow * >(argp1);
41400 {
41401 PyThreadState* __tstate = wxPyBeginAllowThreads();
41402 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
41403 wxPyEndAllowThreads(__tstate);
41404 if (PyErr_Occurred()) SWIG_fail;
41405 }
41406 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
41407 return resultobj;
41408 fail:
41409 return NULL;
41410 }
41411
41412
41413 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41414 PyObject *resultobj = 0;
41415 wxWindow *arg1 = (wxWindow *) 0 ;
41416 bool arg2 ;
41417 void *argp1 = 0 ;
41418 int res1 = 0 ;
41419 bool val2 ;
41420 int ecode2 = 0 ;
41421 PyObject * obj0 = 0 ;
41422 PyObject * obj1 = 0 ;
41423 char * kwnames[] = {
41424 (char *) "self",(char *) "accept", NULL
41425 };
41426
41427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
41428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41429 if (!SWIG_IsOK(res1)) {
41430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
41431 }
41432 arg1 = reinterpret_cast< wxWindow * >(argp1);
41433 ecode2 = SWIG_AsVal_bool(obj1, &val2);
41434 if (!SWIG_IsOK(ecode2)) {
41435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
41436 }
41437 arg2 = static_cast< bool >(val2);
41438 {
41439 PyThreadState* __tstate = wxPyBeginAllowThreads();
41440 wxWindow_DragAcceptFiles(arg1,arg2);
41441 wxPyEndAllowThreads(__tstate);
41442 if (PyErr_Occurred()) SWIG_fail;
41443 }
41444 resultobj = SWIG_Py_Void();
41445 return resultobj;
41446 fail:
41447 return NULL;
41448 }
41449
41450
41451 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41452 PyObject *resultobj = 0;
41453 wxWindow *arg1 = (wxWindow *) 0 ;
41454 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
41455 void *argp1 = 0 ;
41456 int res1 = 0 ;
41457 int res2 = 0 ;
41458 PyObject * obj0 = 0 ;
41459 PyObject * obj1 = 0 ;
41460 char * kwnames[] = {
41461 (char *) "self",(char *) "constraints", NULL
41462 };
41463
41464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
41465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41466 if (!SWIG_IsOK(res1)) {
41467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
41468 }
41469 arg1 = reinterpret_cast< wxWindow * >(argp1);
41470 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
41471 if (!SWIG_IsOK(res2)) {
41472 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
41473 }
41474 {
41475 PyThreadState* __tstate = wxPyBeginAllowThreads();
41476 (arg1)->SetConstraints(arg2);
41477 wxPyEndAllowThreads(__tstate);
41478 if (PyErr_Occurred()) SWIG_fail;
41479 }
41480 resultobj = SWIG_Py_Void();
41481 return resultobj;
41482 fail:
41483 return NULL;
41484 }
41485
41486
41487 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41488 PyObject *resultobj = 0;
41489 wxWindow *arg1 = (wxWindow *) 0 ;
41490 wxLayoutConstraints *result = 0 ;
41491 void *argp1 = 0 ;
41492 int res1 = 0 ;
41493 PyObject *swig_obj[1] ;
41494
41495 if (!args) SWIG_fail;
41496 swig_obj[0] = args;
41497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41498 if (!SWIG_IsOK(res1)) {
41499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
41500 }
41501 arg1 = reinterpret_cast< wxWindow * >(argp1);
41502 {
41503 PyThreadState* __tstate = wxPyBeginAllowThreads();
41504 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
41505 wxPyEndAllowThreads(__tstate);
41506 if (PyErr_Occurred()) SWIG_fail;
41507 }
41508 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
41509 return resultobj;
41510 fail:
41511 return NULL;
41512 }
41513
41514
41515 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41516 PyObject *resultobj = 0;
41517 wxWindow *arg1 = (wxWindow *) 0 ;
41518 bool arg2 ;
41519 void *argp1 = 0 ;
41520 int res1 = 0 ;
41521 bool val2 ;
41522 int ecode2 = 0 ;
41523 PyObject * obj0 = 0 ;
41524 PyObject * obj1 = 0 ;
41525 char * kwnames[] = {
41526 (char *) "self",(char *) "autoLayout", NULL
41527 };
41528
41529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
41530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41531 if (!SWIG_IsOK(res1)) {
41532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
41533 }
41534 arg1 = reinterpret_cast< wxWindow * >(argp1);
41535 ecode2 = SWIG_AsVal_bool(obj1, &val2);
41536 if (!SWIG_IsOK(ecode2)) {
41537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
41538 }
41539 arg2 = static_cast< bool >(val2);
41540 {
41541 PyThreadState* __tstate = wxPyBeginAllowThreads();
41542 (arg1)->SetAutoLayout(arg2);
41543 wxPyEndAllowThreads(__tstate);
41544 if (PyErr_Occurred()) SWIG_fail;
41545 }
41546 resultobj = SWIG_Py_Void();
41547 return resultobj;
41548 fail:
41549 return NULL;
41550 }
41551
41552
41553 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41554 PyObject *resultobj = 0;
41555 wxWindow *arg1 = (wxWindow *) 0 ;
41556 bool result;
41557 void *argp1 = 0 ;
41558 int res1 = 0 ;
41559 PyObject *swig_obj[1] ;
41560
41561 if (!args) SWIG_fail;
41562 swig_obj[0] = args;
41563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41564 if (!SWIG_IsOK(res1)) {
41565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
41566 }
41567 arg1 = reinterpret_cast< wxWindow * >(argp1);
41568 {
41569 PyThreadState* __tstate = wxPyBeginAllowThreads();
41570 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
41571 wxPyEndAllowThreads(__tstate);
41572 if (PyErr_Occurred()) SWIG_fail;
41573 }
41574 {
41575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41576 }
41577 return resultobj;
41578 fail:
41579 return NULL;
41580 }
41581
41582
41583 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41584 PyObject *resultobj = 0;
41585 wxWindow *arg1 = (wxWindow *) 0 ;
41586 bool result;
41587 void *argp1 = 0 ;
41588 int res1 = 0 ;
41589 PyObject *swig_obj[1] ;
41590
41591 if (!args) SWIG_fail;
41592 swig_obj[0] = args;
41593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41594 if (!SWIG_IsOK(res1)) {
41595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
41596 }
41597 arg1 = reinterpret_cast< wxWindow * >(argp1);
41598 {
41599 PyThreadState* __tstate = wxPyBeginAllowThreads();
41600 result = (bool)(arg1)->Layout();
41601 wxPyEndAllowThreads(__tstate);
41602 if (PyErr_Occurred()) SWIG_fail;
41603 }
41604 {
41605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41606 }
41607 return resultobj;
41608 fail:
41609 return NULL;
41610 }
41611
41612
41613 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41614 PyObject *resultobj = 0;
41615 wxWindow *arg1 = (wxWindow *) 0 ;
41616 wxSizer *arg2 = (wxSizer *) 0 ;
41617 bool arg3 = (bool) true ;
41618 void *argp1 = 0 ;
41619 int res1 = 0 ;
41620 int res2 = 0 ;
41621 bool val3 ;
41622 int ecode3 = 0 ;
41623 PyObject * obj0 = 0 ;
41624 PyObject * obj1 = 0 ;
41625 PyObject * obj2 = 0 ;
41626 char * kwnames[] = {
41627 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
41628 };
41629
41630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41632 if (!SWIG_IsOK(res1)) {
41633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
41634 }
41635 arg1 = reinterpret_cast< wxWindow * >(argp1);
41636 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
41637 if (!SWIG_IsOK(res2)) {
41638 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
41639 }
41640 if (obj2) {
41641 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41642 if (!SWIG_IsOK(ecode3)) {
41643 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
41644 }
41645 arg3 = static_cast< bool >(val3);
41646 }
41647 {
41648 PyThreadState* __tstate = wxPyBeginAllowThreads();
41649 (arg1)->SetSizer(arg2,arg3);
41650 wxPyEndAllowThreads(__tstate);
41651 if (PyErr_Occurred()) SWIG_fail;
41652 }
41653 resultobj = SWIG_Py_Void();
41654 return resultobj;
41655 fail:
41656 return NULL;
41657 }
41658
41659
41660 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41661 PyObject *resultobj = 0;
41662 wxWindow *arg1 = (wxWindow *) 0 ;
41663 wxSizer *arg2 = (wxSizer *) 0 ;
41664 bool arg3 = (bool) true ;
41665 void *argp1 = 0 ;
41666 int res1 = 0 ;
41667 int res2 = 0 ;
41668 bool val3 ;
41669 int ecode3 = 0 ;
41670 PyObject * obj0 = 0 ;
41671 PyObject * obj1 = 0 ;
41672 PyObject * obj2 = 0 ;
41673 char * kwnames[] = {
41674 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
41675 };
41676
41677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41679 if (!SWIG_IsOK(res1)) {
41680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
41681 }
41682 arg1 = reinterpret_cast< wxWindow * >(argp1);
41683 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
41684 if (!SWIG_IsOK(res2)) {
41685 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
41686 }
41687 if (obj2) {
41688 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41689 if (!SWIG_IsOK(ecode3)) {
41690 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
41691 }
41692 arg3 = static_cast< bool >(val3);
41693 }
41694 {
41695 PyThreadState* __tstate = wxPyBeginAllowThreads();
41696 (arg1)->SetSizerAndFit(arg2,arg3);
41697 wxPyEndAllowThreads(__tstate);
41698 if (PyErr_Occurred()) SWIG_fail;
41699 }
41700 resultobj = SWIG_Py_Void();
41701 return resultobj;
41702 fail:
41703 return NULL;
41704 }
41705
41706
41707 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41708 PyObject *resultobj = 0;
41709 wxWindow *arg1 = (wxWindow *) 0 ;
41710 wxSizer *result = 0 ;
41711 void *argp1 = 0 ;
41712 int res1 = 0 ;
41713 PyObject *swig_obj[1] ;
41714
41715 if (!args) SWIG_fail;
41716 swig_obj[0] = args;
41717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41718 if (!SWIG_IsOK(res1)) {
41719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
41720 }
41721 arg1 = reinterpret_cast< wxWindow * >(argp1);
41722 {
41723 PyThreadState* __tstate = wxPyBeginAllowThreads();
41724 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
41725 wxPyEndAllowThreads(__tstate);
41726 if (PyErr_Occurred()) SWIG_fail;
41727 }
41728 {
41729 resultobj = wxPyMake_wxObject(result, (bool)0);
41730 }
41731 return resultobj;
41732 fail:
41733 return NULL;
41734 }
41735
41736
41737 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41738 PyObject *resultobj = 0;
41739 wxWindow *arg1 = (wxWindow *) 0 ;
41740 wxSizer *arg2 = (wxSizer *) 0 ;
41741 void *argp1 = 0 ;
41742 int res1 = 0 ;
41743 void *argp2 = 0 ;
41744 int res2 = 0 ;
41745 PyObject * obj0 = 0 ;
41746 PyObject * obj1 = 0 ;
41747 char * kwnames[] = {
41748 (char *) "self",(char *) "sizer", NULL
41749 };
41750
41751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
41752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41753 if (!SWIG_IsOK(res1)) {
41754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
41755 }
41756 arg1 = reinterpret_cast< wxWindow * >(argp1);
41757 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
41758 if (!SWIG_IsOK(res2)) {
41759 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
41760 }
41761 arg2 = reinterpret_cast< wxSizer * >(argp2);
41762 {
41763 PyThreadState* __tstate = wxPyBeginAllowThreads();
41764 (arg1)->SetContainingSizer(arg2);
41765 wxPyEndAllowThreads(__tstate);
41766 if (PyErr_Occurred()) SWIG_fail;
41767 }
41768 resultobj = SWIG_Py_Void();
41769 return resultobj;
41770 fail:
41771 return NULL;
41772 }
41773
41774
41775 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41776 PyObject *resultobj = 0;
41777 wxWindow *arg1 = (wxWindow *) 0 ;
41778 wxSizer *result = 0 ;
41779 void *argp1 = 0 ;
41780 int res1 = 0 ;
41781 PyObject *swig_obj[1] ;
41782
41783 if (!args) SWIG_fail;
41784 swig_obj[0] = args;
41785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41786 if (!SWIG_IsOK(res1)) {
41787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
41788 }
41789 arg1 = reinterpret_cast< wxWindow * >(argp1);
41790 {
41791 PyThreadState* __tstate = wxPyBeginAllowThreads();
41792 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
41793 wxPyEndAllowThreads(__tstate);
41794 if (PyErr_Occurred()) SWIG_fail;
41795 }
41796 {
41797 resultobj = wxPyMake_wxObject(result, (bool)0);
41798 }
41799 return resultobj;
41800 fail:
41801 return NULL;
41802 }
41803
41804
41805 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41806 PyObject *resultobj = 0;
41807 wxWindow *arg1 = (wxWindow *) 0 ;
41808 void *argp1 = 0 ;
41809 int res1 = 0 ;
41810 PyObject *swig_obj[1] ;
41811
41812 if (!args) SWIG_fail;
41813 swig_obj[0] = args;
41814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41815 if (!SWIG_IsOK(res1)) {
41816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
41817 }
41818 arg1 = reinterpret_cast< wxWindow * >(argp1);
41819 {
41820 PyThreadState* __tstate = wxPyBeginAllowThreads();
41821 (arg1)->InheritAttributes();
41822 wxPyEndAllowThreads(__tstate);
41823 if (PyErr_Occurred()) SWIG_fail;
41824 }
41825 resultobj = SWIG_Py_Void();
41826 return resultobj;
41827 fail:
41828 return NULL;
41829 }
41830
41831
41832 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41833 PyObject *resultobj = 0;
41834 wxWindow *arg1 = (wxWindow *) 0 ;
41835 bool result;
41836 void *argp1 = 0 ;
41837 int res1 = 0 ;
41838 PyObject *swig_obj[1] ;
41839
41840 if (!args) SWIG_fail;
41841 swig_obj[0] = args;
41842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41843 if (!SWIG_IsOK(res1)) {
41844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
41845 }
41846 arg1 = reinterpret_cast< wxWindow * >(argp1);
41847 {
41848 PyThreadState* __tstate = wxPyBeginAllowThreads();
41849 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
41850 wxPyEndAllowThreads(__tstate);
41851 if (PyErr_Occurred()) SWIG_fail;
41852 }
41853 {
41854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41855 }
41856 return resultobj;
41857 fail:
41858 return NULL;
41859 }
41860
41861
41862 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41863 PyObject *resultobj = 0;
41864 wxWindow *arg1 = (wxWindow *) 0 ;
41865 bool result;
41866 void *argp1 = 0 ;
41867 int res1 = 0 ;
41868 PyObject *swig_obj[1] ;
41869
41870 if (!args) SWIG_fail;
41871 swig_obj[0] = args;
41872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41873 if (!SWIG_IsOK(res1)) {
41874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41875 }
41876 arg1 = reinterpret_cast< wxWindow * >(argp1);
41877 {
41878 PyThreadState* __tstate = wxPyBeginAllowThreads();
41879 result = (bool)(arg1)->CanSetTransparent();
41880 wxPyEndAllowThreads(__tstate);
41881 if (PyErr_Occurred()) SWIG_fail;
41882 }
41883 {
41884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41885 }
41886 return resultobj;
41887 fail:
41888 return NULL;
41889 }
41890
41891
41892 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41893 PyObject *resultobj = 0;
41894 wxWindow *arg1 = (wxWindow *) 0 ;
41895 byte arg2 ;
41896 bool result;
41897 void *argp1 = 0 ;
41898 int res1 = 0 ;
41899 unsigned char val2 ;
41900 int ecode2 = 0 ;
41901 PyObject * obj0 = 0 ;
41902 PyObject * obj1 = 0 ;
41903 char * kwnames[] = {
41904 (char *) "self",(char *) "alpha", NULL
41905 };
41906
41907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
41908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41909 if (!SWIG_IsOK(res1)) {
41910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41911 }
41912 arg1 = reinterpret_cast< wxWindow * >(argp1);
41913 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
41914 if (!SWIG_IsOK(ecode2)) {
41915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
41916 }
41917 arg2 = static_cast< byte >(val2);
41918 {
41919 PyThreadState* __tstate = wxPyBeginAllowThreads();
41920 result = (bool)(arg1)->SetTransparent(arg2);
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 *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41934 PyObject *obj;
41935 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41936 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
41937 return SWIG_Py_Void();
41938 }
41939
41940 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41941 return SWIG_Python_InitShadowInstance(args);
41942 }
41943
41944 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41945 PyObject *resultobj = 0;
41946 long arg1 ;
41947 wxWindow *arg2 = (wxWindow *) NULL ;
41948 wxWindow *result = 0 ;
41949 long val1 ;
41950 int ecode1 = 0 ;
41951 void *argp2 = 0 ;
41952 int res2 = 0 ;
41953 PyObject * obj0 = 0 ;
41954 PyObject * obj1 = 0 ;
41955 char * kwnames[] = {
41956 (char *) "id",(char *) "parent", NULL
41957 };
41958
41959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
41960 ecode1 = SWIG_AsVal_long(obj0, &val1);
41961 if (!SWIG_IsOK(ecode1)) {
41962 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
41963 }
41964 arg1 = static_cast< long >(val1);
41965 if (obj1) {
41966 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41967 if (!SWIG_IsOK(res2)) {
41968 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
41969 }
41970 arg2 = reinterpret_cast< wxWindow * >(argp2);
41971 }
41972 {
41973 if (!wxPyCheckForApp()) SWIG_fail;
41974 PyThreadState* __tstate = wxPyBeginAllowThreads();
41975 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
41976 wxPyEndAllowThreads(__tstate);
41977 if (PyErr_Occurred()) SWIG_fail;
41978 }
41979 {
41980 resultobj = wxPyMake_wxObject(result, 0);
41981 }
41982 return resultobj;
41983 fail:
41984 return NULL;
41985 }
41986
41987
41988 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41989 PyObject *resultobj = 0;
41990 wxString *arg1 = 0 ;
41991 wxWindow *arg2 = (wxWindow *) NULL ;
41992 wxWindow *result = 0 ;
41993 bool temp1 = false ;
41994 void *argp2 = 0 ;
41995 int res2 = 0 ;
41996 PyObject * obj0 = 0 ;
41997 PyObject * obj1 = 0 ;
41998 char * kwnames[] = {
41999 (char *) "name",(char *) "parent", NULL
42000 };
42001
42002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
42003 {
42004 arg1 = wxString_in_helper(obj0);
42005 if (arg1 == NULL) SWIG_fail;
42006 temp1 = true;
42007 }
42008 if (obj1) {
42009 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
42010 if (!SWIG_IsOK(res2)) {
42011 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
42012 }
42013 arg2 = reinterpret_cast< wxWindow * >(argp2);
42014 }
42015 {
42016 if (!wxPyCheckForApp()) SWIG_fail;
42017 PyThreadState* __tstate = wxPyBeginAllowThreads();
42018 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
42019 wxPyEndAllowThreads(__tstate);
42020 if (PyErr_Occurred()) SWIG_fail;
42021 }
42022 {
42023 resultobj = wxPyMake_wxObject(result, 0);
42024 }
42025 {
42026 if (temp1)
42027 delete arg1;
42028 }
42029 return resultobj;
42030 fail:
42031 {
42032 if (temp1)
42033 delete arg1;
42034 }
42035 return NULL;
42036 }
42037
42038
42039 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42040 PyObject *resultobj = 0;
42041 wxString *arg1 = 0 ;
42042 wxWindow *arg2 = (wxWindow *) NULL ;
42043 wxWindow *result = 0 ;
42044 bool temp1 = false ;
42045 void *argp2 = 0 ;
42046 int res2 = 0 ;
42047 PyObject * obj0 = 0 ;
42048 PyObject * obj1 = 0 ;
42049 char * kwnames[] = {
42050 (char *) "label",(char *) "parent", NULL
42051 };
42052
42053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
42054 {
42055 arg1 = wxString_in_helper(obj0);
42056 if (arg1 == NULL) SWIG_fail;
42057 temp1 = true;
42058 }
42059 if (obj1) {
42060 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
42061 if (!SWIG_IsOK(res2)) {
42062 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
42063 }
42064 arg2 = reinterpret_cast< wxWindow * >(argp2);
42065 }
42066 {
42067 if (!wxPyCheckForApp()) SWIG_fail;
42068 PyThreadState* __tstate = wxPyBeginAllowThreads();
42069 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
42070 wxPyEndAllowThreads(__tstate);
42071 if (PyErr_Occurred()) SWIG_fail;
42072 }
42073 {
42074 resultobj = wxPyMake_wxObject(result, 0);
42075 }
42076 {
42077 if (temp1)
42078 delete arg1;
42079 }
42080 return resultobj;
42081 fail:
42082 {
42083 if (temp1)
42084 delete arg1;
42085 }
42086 return NULL;
42087 }
42088
42089
42090 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42091 PyObject *resultobj = 0;
42092 wxWindow *arg1 = (wxWindow *) 0 ;
42093 unsigned long arg2 ;
42094 wxWindow *result = 0 ;
42095 void *argp1 = 0 ;
42096 int res1 = 0 ;
42097 unsigned long val2 ;
42098 int ecode2 = 0 ;
42099 PyObject * obj0 = 0 ;
42100 PyObject * obj1 = 0 ;
42101 char * kwnames[] = {
42102 (char *) "parent",(char *) "_hWnd", NULL
42103 };
42104
42105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
42106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
42107 if (!SWIG_IsOK(res1)) {
42108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
42109 }
42110 arg1 = reinterpret_cast< wxWindow * >(argp1);
42111 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
42112 if (!SWIG_IsOK(ecode2)) {
42113 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
42114 }
42115 arg2 = static_cast< unsigned long >(val2);
42116 {
42117 if (!wxPyCheckForApp()) SWIG_fail;
42118 PyThreadState* __tstate = wxPyBeginAllowThreads();
42119 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
42120 wxPyEndAllowThreads(__tstate);
42121 if (PyErr_Occurred()) SWIG_fail;
42122 }
42123 {
42124 resultobj = wxPyMake_wxObject(result, 0);
42125 }
42126 return resultobj;
42127 fail:
42128 return NULL;
42129 }
42130
42131
42132 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42133 PyObject *resultobj = 0;
42134 PyObject *result = 0 ;
42135
42136 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
42137 {
42138 PyThreadState* __tstate = wxPyBeginAllowThreads();
42139 result = (PyObject *)GetTopLevelWindows();
42140 wxPyEndAllowThreads(__tstate);
42141 if (PyErr_Occurred()) SWIG_fail;
42142 }
42143 resultobj = result;
42144 return resultobj;
42145 fail:
42146 return NULL;
42147 }
42148
42149
42150 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42151 PyObject *resultobj = 0;
42152 wxValidator *result = 0 ;
42153
42154 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
42155 {
42156 PyThreadState* __tstate = wxPyBeginAllowThreads();
42157 result = (wxValidator *)new wxValidator();
42158 wxPyEndAllowThreads(__tstate);
42159 if (PyErr_Occurred()) SWIG_fail;
42160 }
42161 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
42162 return resultobj;
42163 fail:
42164 return NULL;
42165 }
42166
42167
42168 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42169 PyObject *resultobj = 0;
42170 wxValidator *arg1 = (wxValidator *) 0 ;
42171 wxValidator *result = 0 ;
42172 void *argp1 = 0 ;
42173 int res1 = 0 ;
42174 PyObject *swig_obj[1] ;
42175
42176 if (!args) SWIG_fail;
42177 swig_obj[0] = args;
42178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
42179 if (!SWIG_IsOK(res1)) {
42180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
42181 }
42182 arg1 = reinterpret_cast< wxValidator * >(argp1);
42183 {
42184 PyThreadState* __tstate = wxPyBeginAllowThreads();
42185 result = (wxValidator *)(arg1)->Clone();
42186 wxPyEndAllowThreads(__tstate);
42187 if (PyErr_Occurred()) SWIG_fail;
42188 }
42189 {
42190 resultobj = wxPyMake_wxObject(result, 0);
42191 }
42192 return resultobj;
42193 fail:
42194 return NULL;
42195 }
42196
42197
42198 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42199 PyObject *resultobj = 0;
42200 wxValidator *arg1 = (wxValidator *) 0 ;
42201 wxWindow *arg2 = (wxWindow *) 0 ;
42202 bool result;
42203 void *argp1 = 0 ;
42204 int res1 = 0 ;
42205 void *argp2 = 0 ;
42206 int res2 = 0 ;
42207 PyObject * obj0 = 0 ;
42208 PyObject * obj1 = 0 ;
42209 char * kwnames[] = {
42210 (char *) "self",(char *) "parent", NULL
42211 };
42212
42213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
42214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
42215 if (!SWIG_IsOK(res1)) {
42216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
42217 }
42218 arg1 = reinterpret_cast< wxValidator * >(argp1);
42219 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
42220 if (!SWIG_IsOK(res2)) {
42221 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
42222 }
42223 arg2 = reinterpret_cast< wxWindow * >(argp2);
42224 {
42225 PyThreadState* __tstate = wxPyBeginAllowThreads();
42226 result = (bool)(arg1)->Validate(arg2);
42227 wxPyEndAllowThreads(__tstate);
42228 if (PyErr_Occurred()) SWIG_fail;
42229 }
42230 {
42231 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42232 }
42233 return resultobj;
42234 fail:
42235 return NULL;
42236 }
42237
42238
42239 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42240 PyObject *resultobj = 0;
42241 wxValidator *arg1 = (wxValidator *) 0 ;
42242 bool result;
42243 void *argp1 = 0 ;
42244 int res1 = 0 ;
42245 PyObject *swig_obj[1] ;
42246
42247 if (!args) SWIG_fail;
42248 swig_obj[0] = args;
42249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
42250 if (!SWIG_IsOK(res1)) {
42251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
42252 }
42253 arg1 = reinterpret_cast< wxValidator * >(argp1);
42254 {
42255 PyThreadState* __tstate = wxPyBeginAllowThreads();
42256 result = (bool)(arg1)->TransferToWindow();
42257 wxPyEndAllowThreads(__tstate);
42258 if (PyErr_Occurred()) SWIG_fail;
42259 }
42260 {
42261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42262 }
42263 return resultobj;
42264 fail:
42265 return NULL;
42266 }
42267
42268
42269 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42270 PyObject *resultobj = 0;
42271 wxValidator *arg1 = (wxValidator *) 0 ;
42272 bool result;
42273 void *argp1 = 0 ;
42274 int res1 = 0 ;
42275 PyObject *swig_obj[1] ;
42276
42277 if (!args) SWIG_fail;
42278 swig_obj[0] = args;
42279 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
42280 if (!SWIG_IsOK(res1)) {
42281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
42282 }
42283 arg1 = reinterpret_cast< wxValidator * >(argp1);
42284 {
42285 PyThreadState* __tstate = wxPyBeginAllowThreads();
42286 result = (bool)(arg1)->TransferFromWindow();
42287 wxPyEndAllowThreads(__tstate);
42288 if (PyErr_Occurred()) SWIG_fail;
42289 }
42290 {
42291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42292 }
42293 return resultobj;
42294 fail:
42295 return NULL;
42296 }
42297
42298
42299 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42300 PyObject *resultobj = 0;
42301 wxValidator *arg1 = (wxValidator *) 0 ;
42302 wxWindow *result = 0 ;
42303 void *argp1 = 0 ;
42304 int res1 = 0 ;
42305 PyObject *swig_obj[1] ;
42306
42307 if (!args) SWIG_fail;
42308 swig_obj[0] = args;
42309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
42310 if (!SWIG_IsOK(res1)) {
42311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
42312 }
42313 arg1 = reinterpret_cast< wxValidator * >(argp1);
42314 {
42315 PyThreadState* __tstate = wxPyBeginAllowThreads();
42316 result = (wxWindow *)(arg1)->GetWindow();
42317 wxPyEndAllowThreads(__tstate);
42318 if (PyErr_Occurred()) SWIG_fail;
42319 }
42320 {
42321 resultobj = wxPyMake_wxObject(result, 0);
42322 }
42323 return resultobj;
42324 fail:
42325 return NULL;
42326 }
42327
42328
42329 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42330 PyObject *resultobj = 0;
42331 wxValidator *arg1 = (wxValidator *) 0 ;
42332 wxWindow *arg2 = (wxWindow *) 0 ;
42333 void *argp1 = 0 ;
42334 int res1 = 0 ;
42335 void *argp2 = 0 ;
42336 int res2 = 0 ;
42337 PyObject * obj0 = 0 ;
42338 PyObject * obj1 = 0 ;
42339 char * kwnames[] = {
42340 (char *) "self",(char *) "window", NULL
42341 };
42342
42343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
42344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
42345 if (!SWIG_IsOK(res1)) {
42346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
42347 }
42348 arg1 = reinterpret_cast< wxValidator * >(argp1);
42349 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
42350 if (!SWIG_IsOK(res2)) {
42351 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
42352 }
42353 arg2 = reinterpret_cast< wxWindow * >(argp2);
42354 {
42355 PyThreadState* __tstate = wxPyBeginAllowThreads();
42356 (arg1)->SetWindow(arg2);
42357 wxPyEndAllowThreads(__tstate);
42358 if (PyErr_Occurred()) SWIG_fail;
42359 }
42360 resultobj = SWIG_Py_Void();
42361 return resultobj;
42362 fail:
42363 return NULL;
42364 }
42365
42366
42367 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42368 PyObject *resultobj = 0;
42369 bool result;
42370
42371 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
42372 {
42373 PyThreadState* __tstate = wxPyBeginAllowThreads();
42374 result = (bool)wxValidator::IsSilent();
42375 wxPyEndAllowThreads(__tstate);
42376 if (PyErr_Occurred()) SWIG_fail;
42377 }
42378 {
42379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42380 }
42381 return resultobj;
42382 fail:
42383 return NULL;
42384 }
42385
42386
42387 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42388 PyObject *resultobj = 0;
42389 int arg1 = (int) true ;
42390 int val1 ;
42391 int ecode1 = 0 ;
42392 PyObject * obj0 = 0 ;
42393 char * kwnames[] = {
42394 (char *) "doIt", NULL
42395 };
42396
42397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
42398 if (obj0) {
42399 ecode1 = SWIG_AsVal_int(obj0, &val1);
42400 if (!SWIG_IsOK(ecode1)) {
42401 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
42402 }
42403 arg1 = static_cast< int >(val1);
42404 }
42405 {
42406 PyThreadState* __tstate = wxPyBeginAllowThreads();
42407 wxValidator::SetBellOnError(arg1);
42408 wxPyEndAllowThreads(__tstate);
42409 if (PyErr_Occurred()) SWIG_fail;
42410 }
42411 resultobj = SWIG_Py_Void();
42412 return resultobj;
42413 fail:
42414 return NULL;
42415 }
42416
42417
42418 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42419 PyObject *obj;
42420 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42421 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
42422 return SWIG_Py_Void();
42423 }
42424
42425 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42426 return SWIG_Python_InitShadowInstance(args);
42427 }
42428
42429 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42430 PyObject *resultobj = 0;
42431 wxPyValidator *result = 0 ;
42432
42433 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
42434 {
42435 PyThreadState* __tstate = wxPyBeginAllowThreads();
42436 result = (wxPyValidator *)new wxPyValidator();
42437 wxPyEndAllowThreads(__tstate);
42438 if (PyErr_Occurred()) SWIG_fail;
42439 }
42440 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
42441 return resultobj;
42442 fail:
42443 return NULL;
42444 }
42445
42446
42447 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42448 PyObject *resultobj = 0;
42449 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
42450 PyObject *arg2 = (PyObject *) 0 ;
42451 PyObject *arg3 = (PyObject *) 0 ;
42452 int arg4 = (int) 1 ;
42453 void *argp1 = 0 ;
42454 int res1 = 0 ;
42455 int val4 ;
42456 int ecode4 = 0 ;
42457 PyObject * obj0 = 0 ;
42458 PyObject * obj1 = 0 ;
42459 PyObject * obj2 = 0 ;
42460 PyObject * obj3 = 0 ;
42461 char * kwnames[] = {
42462 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
42463 };
42464
42465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
42467 if (!SWIG_IsOK(res1)) {
42468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
42469 }
42470 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
42471 arg2 = obj1;
42472 arg3 = obj2;
42473 if (obj3) {
42474 ecode4 = SWIG_AsVal_int(obj3, &val4);
42475 if (!SWIG_IsOK(ecode4)) {
42476 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
42477 }
42478 arg4 = static_cast< int >(val4);
42479 }
42480 {
42481 PyThreadState* __tstate = wxPyBeginAllowThreads();
42482 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
42483 wxPyEndAllowThreads(__tstate);
42484 if (PyErr_Occurred()) SWIG_fail;
42485 }
42486 resultobj = SWIG_Py_Void();
42487 return resultobj;
42488 fail:
42489 return NULL;
42490 }
42491
42492
42493 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42494 PyObject *obj;
42495 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42496 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
42497 return SWIG_Py_Void();
42498 }
42499
42500 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42501 return SWIG_Python_InitShadowInstance(args);
42502 }
42503
42504 SWIGINTERN int DefaultValidator_set(PyObject *) {
42505 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
42506 return 1;
42507 }
42508
42509
42510 SWIGINTERN PyObject *DefaultValidator_get(void) {
42511 PyObject *pyobj = 0;
42512
42513 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
42514 return pyobj;
42515 }
42516
42517
42518 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42519 PyObject *resultobj = 0;
42520 wxString const &arg1_defvalue = wxPyEmptyString ;
42521 wxString *arg1 = (wxString *) &arg1_defvalue ;
42522 long arg2 = (long) 0 ;
42523 wxMenu *result = 0 ;
42524 bool temp1 = false ;
42525 long val2 ;
42526 int ecode2 = 0 ;
42527 PyObject * obj0 = 0 ;
42528 PyObject * obj1 = 0 ;
42529 char * kwnames[] = {
42530 (char *) "title",(char *) "style", NULL
42531 };
42532
42533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
42534 if (obj0) {
42535 {
42536 arg1 = wxString_in_helper(obj0);
42537 if (arg1 == NULL) SWIG_fail;
42538 temp1 = true;
42539 }
42540 }
42541 if (obj1) {
42542 ecode2 = SWIG_AsVal_long(obj1, &val2);
42543 if (!SWIG_IsOK(ecode2)) {
42544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
42545 }
42546 arg2 = static_cast< long >(val2);
42547 }
42548 {
42549 if (!wxPyCheckForApp()) SWIG_fail;
42550 PyThreadState* __tstate = wxPyBeginAllowThreads();
42551 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
42552 wxPyEndAllowThreads(__tstate);
42553 if (PyErr_Occurred()) SWIG_fail;
42554 }
42555 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
42556 {
42557 if (temp1)
42558 delete arg1;
42559 }
42560 return resultobj;
42561 fail:
42562 {
42563 if (temp1)
42564 delete arg1;
42565 }
42566 return NULL;
42567 }
42568
42569
42570 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42571 PyObject *resultobj = 0;
42572 wxMenu *arg1 = (wxMenu *) 0 ;
42573 int arg2 ;
42574 wxString const &arg3_defvalue = wxPyEmptyString ;
42575 wxString *arg3 = (wxString *) &arg3_defvalue ;
42576 wxString const &arg4_defvalue = wxPyEmptyString ;
42577 wxString *arg4 = (wxString *) &arg4_defvalue ;
42578 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42579 wxMenuItem *result = 0 ;
42580 void *argp1 = 0 ;
42581 int res1 = 0 ;
42582 int val2 ;
42583 int ecode2 = 0 ;
42584 bool temp3 = false ;
42585 bool temp4 = false ;
42586 int val5 ;
42587 int ecode5 = 0 ;
42588 PyObject * obj0 = 0 ;
42589 PyObject * obj1 = 0 ;
42590 PyObject * obj2 = 0 ;
42591 PyObject * obj3 = 0 ;
42592 PyObject * obj4 = 0 ;
42593 char * kwnames[] = {
42594 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42595 };
42596
42597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42599 if (!SWIG_IsOK(res1)) {
42600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
42601 }
42602 arg1 = reinterpret_cast< wxMenu * >(argp1);
42603 ecode2 = SWIG_AsVal_int(obj1, &val2);
42604 if (!SWIG_IsOK(ecode2)) {
42605 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
42606 }
42607 arg2 = static_cast< int >(val2);
42608 if (obj2) {
42609 {
42610 arg3 = wxString_in_helper(obj2);
42611 if (arg3 == NULL) SWIG_fail;
42612 temp3 = true;
42613 }
42614 }
42615 if (obj3) {
42616 {
42617 arg4 = wxString_in_helper(obj3);
42618 if (arg4 == NULL) SWIG_fail;
42619 temp4 = true;
42620 }
42621 }
42622 if (obj4) {
42623 ecode5 = SWIG_AsVal_int(obj4, &val5);
42624 if (!SWIG_IsOK(ecode5)) {
42625 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
42626 }
42627 arg5 = static_cast< wxItemKind >(val5);
42628 }
42629 {
42630 PyThreadState* __tstate = wxPyBeginAllowThreads();
42631 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
42632 wxPyEndAllowThreads(__tstate);
42633 if (PyErr_Occurred()) SWIG_fail;
42634 }
42635 {
42636 resultobj = wxPyMake_wxObject(result, (bool)0);
42637 }
42638 {
42639 if (temp3)
42640 delete arg3;
42641 }
42642 {
42643 if (temp4)
42644 delete arg4;
42645 }
42646 return resultobj;
42647 fail:
42648 {
42649 if (temp3)
42650 delete arg3;
42651 }
42652 {
42653 if (temp4)
42654 delete arg4;
42655 }
42656 return NULL;
42657 }
42658
42659
42660 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42661 PyObject *resultobj = 0;
42662 wxMenu *arg1 = (wxMenu *) 0 ;
42663 wxMenuItem *result = 0 ;
42664 void *argp1 = 0 ;
42665 int res1 = 0 ;
42666 PyObject *swig_obj[1] ;
42667
42668 if (!args) SWIG_fail;
42669 swig_obj[0] = args;
42670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42671 if (!SWIG_IsOK(res1)) {
42672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42673 }
42674 arg1 = reinterpret_cast< wxMenu * >(argp1);
42675 {
42676 PyThreadState* __tstate = wxPyBeginAllowThreads();
42677 result = (wxMenuItem *)(arg1)->AppendSeparator();
42678 wxPyEndAllowThreads(__tstate);
42679 if (PyErr_Occurred()) SWIG_fail;
42680 }
42681 {
42682 resultobj = wxPyMake_wxObject(result, (bool)0);
42683 }
42684 return resultobj;
42685 fail:
42686 return NULL;
42687 }
42688
42689
42690 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42691 PyObject *resultobj = 0;
42692 wxMenu *arg1 = (wxMenu *) 0 ;
42693 int arg2 ;
42694 wxString *arg3 = 0 ;
42695 wxString const &arg4_defvalue = wxPyEmptyString ;
42696 wxString *arg4 = (wxString *) &arg4_defvalue ;
42697 wxMenuItem *result = 0 ;
42698 void *argp1 = 0 ;
42699 int res1 = 0 ;
42700 int val2 ;
42701 int ecode2 = 0 ;
42702 bool temp3 = false ;
42703 bool temp4 = false ;
42704 PyObject * obj0 = 0 ;
42705 PyObject * obj1 = 0 ;
42706 PyObject * obj2 = 0 ;
42707 PyObject * obj3 = 0 ;
42708 char * kwnames[] = {
42709 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42710 };
42711
42712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42714 if (!SWIG_IsOK(res1)) {
42715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42716 }
42717 arg1 = reinterpret_cast< wxMenu * >(argp1);
42718 ecode2 = SWIG_AsVal_int(obj1, &val2);
42719 if (!SWIG_IsOK(ecode2)) {
42720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
42721 }
42722 arg2 = static_cast< int >(val2);
42723 {
42724 arg3 = wxString_in_helper(obj2);
42725 if (arg3 == NULL) SWIG_fail;
42726 temp3 = true;
42727 }
42728 if (obj3) {
42729 {
42730 arg4 = wxString_in_helper(obj3);
42731 if (arg4 == NULL) SWIG_fail;
42732 temp4 = true;
42733 }
42734 }
42735 {
42736 PyThreadState* __tstate = wxPyBeginAllowThreads();
42737 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42738 wxPyEndAllowThreads(__tstate);
42739 if (PyErr_Occurred()) SWIG_fail;
42740 }
42741 {
42742 resultobj = wxPyMake_wxObject(result, (bool)0);
42743 }
42744 {
42745 if (temp3)
42746 delete arg3;
42747 }
42748 {
42749 if (temp4)
42750 delete arg4;
42751 }
42752 return resultobj;
42753 fail:
42754 {
42755 if (temp3)
42756 delete arg3;
42757 }
42758 {
42759 if (temp4)
42760 delete arg4;
42761 }
42762 return NULL;
42763 }
42764
42765
42766 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42767 PyObject *resultobj = 0;
42768 wxMenu *arg1 = (wxMenu *) 0 ;
42769 int arg2 ;
42770 wxString *arg3 = 0 ;
42771 wxString const &arg4_defvalue = wxPyEmptyString ;
42772 wxString *arg4 = (wxString *) &arg4_defvalue ;
42773 wxMenuItem *result = 0 ;
42774 void *argp1 = 0 ;
42775 int res1 = 0 ;
42776 int val2 ;
42777 int ecode2 = 0 ;
42778 bool temp3 = false ;
42779 bool temp4 = false ;
42780 PyObject * obj0 = 0 ;
42781 PyObject * obj1 = 0 ;
42782 PyObject * obj2 = 0 ;
42783 PyObject * obj3 = 0 ;
42784 char * kwnames[] = {
42785 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42786 };
42787
42788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42790 if (!SWIG_IsOK(res1)) {
42791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42792 }
42793 arg1 = reinterpret_cast< wxMenu * >(argp1);
42794 ecode2 = SWIG_AsVal_int(obj1, &val2);
42795 if (!SWIG_IsOK(ecode2)) {
42796 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
42797 }
42798 arg2 = static_cast< int >(val2);
42799 {
42800 arg3 = wxString_in_helper(obj2);
42801 if (arg3 == NULL) SWIG_fail;
42802 temp3 = true;
42803 }
42804 if (obj3) {
42805 {
42806 arg4 = wxString_in_helper(obj3);
42807 if (arg4 == NULL) SWIG_fail;
42808 temp4 = true;
42809 }
42810 }
42811 {
42812 PyThreadState* __tstate = wxPyBeginAllowThreads();
42813 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42814 wxPyEndAllowThreads(__tstate);
42815 if (PyErr_Occurred()) SWIG_fail;
42816 }
42817 {
42818 resultobj = wxPyMake_wxObject(result, (bool)0);
42819 }
42820 {
42821 if (temp3)
42822 delete arg3;
42823 }
42824 {
42825 if (temp4)
42826 delete arg4;
42827 }
42828 return resultobj;
42829 fail:
42830 {
42831 if (temp3)
42832 delete arg3;
42833 }
42834 {
42835 if (temp4)
42836 delete arg4;
42837 }
42838 return NULL;
42839 }
42840
42841
42842 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42843 PyObject *resultobj = 0;
42844 wxMenu *arg1 = (wxMenu *) 0 ;
42845 int arg2 ;
42846 wxString *arg3 = 0 ;
42847 wxMenu *arg4 = (wxMenu *) 0 ;
42848 wxString const &arg5_defvalue = wxPyEmptyString ;
42849 wxString *arg5 = (wxString *) &arg5_defvalue ;
42850 wxMenuItem *result = 0 ;
42851 void *argp1 = 0 ;
42852 int res1 = 0 ;
42853 int val2 ;
42854 int ecode2 = 0 ;
42855 bool temp3 = false ;
42856 void *argp4 = 0 ;
42857 int res4 = 0 ;
42858 bool temp5 = false ;
42859 PyObject * obj0 = 0 ;
42860 PyObject * obj1 = 0 ;
42861 PyObject * obj2 = 0 ;
42862 PyObject * obj3 = 0 ;
42863 PyObject * obj4 = 0 ;
42864 char * kwnames[] = {
42865 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42866 };
42867
42868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42870 if (!SWIG_IsOK(res1)) {
42871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42872 }
42873 arg1 = reinterpret_cast< wxMenu * >(argp1);
42874 ecode2 = SWIG_AsVal_int(obj1, &val2);
42875 if (!SWIG_IsOK(ecode2)) {
42876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
42877 }
42878 arg2 = static_cast< int >(val2);
42879 {
42880 arg3 = wxString_in_helper(obj2);
42881 if (arg3 == NULL) SWIG_fail;
42882 temp3 = true;
42883 }
42884 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
42885 if (!SWIG_IsOK(res4)) {
42886 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
42887 }
42888 arg4 = reinterpret_cast< wxMenu * >(argp4);
42889 if (obj4) {
42890 {
42891 arg5 = wxString_in_helper(obj4);
42892 if (arg5 == NULL) SWIG_fail;
42893 temp5 = true;
42894 }
42895 }
42896 {
42897 PyThreadState* __tstate = wxPyBeginAllowThreads();
42898 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
42899 wxPyEndAllowThreads(__tstate);
42900 if (PyErr_Occurred()) SWIG_fail;
42901 }
42902 {
42903 resultobj = wxPyMake_wxObject(result, (bool)0);
42904 }
42905 {
42906 if (temp3)
42907 delete arg3;
42908 }
42909 {
42910 if (temp5)
42911 delete arg5;
42912 }
42913 return resultobj;
42914 fail:
42915 {
42916 if (temp3)
42917 delete arg3;
42918 }
42919 {
42920 if (temp5)
42921 delete arg5;
42922 }
42923 return NULL;
42924 }
42925
42926
42927 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42928 PyObject *resultobj = 0;
42929 wxMenu *arg1 = (wxMenu *) 0 ;
42930 wxMenu *arg2 = (wxMenu *) 0 ;
42931 wxString *arg3 = 0 ;
42932 wxString const &arg4_defvalue = wxPyEmptyString ;
42933 wxString *arg4 = (wxString *) &arg4_defvalue ;
42934 wxMenuItem *result = 0 ;
42935 void *argp1 = 0 ;
42936 int res1 = 0 ;
42937 void *argp2 = 0 ;
42938 int res2 = 0 ;
42939 bool temp3 = false ;
42940 bool temp4 = false ;
42941 PyObject * obj0 = 0 ;
42942 PyObject * obj1 = 0 ;
42943 PyObject * obj2 = 0 ;
42944 PyObject * obj3 = 0 ;
42945 char * kwnames[] = {
42946 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
42947 };
42948
42949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42951 if (!SWIG_IsOK(res1)) {
42952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42953 }
42954 arg1 = reinterpret_cast< wxMenu * >(argp1);
42955 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42956 if (!SWIG_IsOK(res2)) {
42957 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42958 }
42959 arg2 = reinterpret_cast< wxMenu * >(argp2);
42960 {
42961 arg3 = wxString_in_helper(obj2);
42962 if (arg3 == NULL) SWIG_fail;
42963 temp3 = true;
42964 }
42965 if (obj3) {
42966 {
42967 arg4 = wxString_in_helper(obj3);
42968 if (arg4 == NULL) SWIG_fail;
42969 temp4 = true;
42970 }
42971 }
42972 {
42973 PyThreadState* __tstate = wxPyBeginAllowThreads();
42974 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42975 wxPyEndAllowThreads(__tstate);
42976 if (PyErr_Occurred()) SWIG_fail;
42977 }
42978 {
42979 resultobj = wxPyMake_wxObject(result, (bool)0);
42980 }
42981 {
42982 if (temp3)
42983 delete arg3;
42984 }
42985 {
42986 if (temp4)
42987 delete arg4;
42988 }
42989 return resultobj;
42990 fail:
42991 {
42992 if (temp3)
42993 delete arg3;
42994 }
42995 {
42996 if (temp4)
42997 delete arg4;
42998 }
42999 return NULL;
43000 }
43001
43002
43003 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43004 PyObject *resultobj = 0;
43005 wxMenu *arg1 = (wxMenu *) 0 ;
43006 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43007 wxMenuItem *result = 0 ;
43008 void *argp1 = 0 ;
43009 int res1 = 0 ;
43010 int res2 = 0 ;
43011 PyObject * obj0 = 0 ;
43012 PyObject * obj1 = 0 ;
43013 char * kwnames[] = {
43014 (char *) "self",(char *) "item", NULL
43015 };
43016
43017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
43018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43019 if (!SWIG_IsOK(res1)) {
43020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43021 }
43022 arg1 = reinterpret_cast< wxMenu * >(argp1);
43023 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
43024 if (!SWIG_IsOK(res2)) {
43025 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43026 }
43027 {
43028 PyThreadState* __tstate = wxPyBeginAllowThreads();
43029 result = (wxMenuItem *)(arg1)->Append(arg2);
43030 wxPyEndAllowThreads(__tstate);
43031 if (PyErr_Occurred()) SWIG_fail;
43032 }
43033 {
43034 resultobj = wxPyMake_wxObject(result, (bool)0);
43035 }
43036 return resultobj;
43037 fail:
43038 return NULL;
43039 }
43040
43041
43042 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43043 PyObject *resultobj = 0;
43044 wxMenu *arg1 = (wxMenu *) 0 ;
43045 size_t arg2 ;
43046 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
43047 wxMenuItem *result = 0 ;
43048 void *argp1 = 0 ;
43049 int res1 = 0 ;
43050 size_t val2 ;
43051 int ecode2 = 0 ;
43052 int res3 = 0 ;
43053 PyObject * obj0 = 0 ;
43054 PyObject * obj1 = 0 ;
43055 PyObject * obj2 = 0 ;
43056 char * kwnames[] = {
43057 (char *) "self",(char *) "pos",(char *) "item", NULL
43058 };
43059
43060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43062 if (!SWIG_IsOK(res1)) {
43063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43064 }
43065 arg1 = reinterpret_cast< wxMenu * >(argp1);
43066 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43067 if (!SWIG_IsOK(ecode2)) {
43068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
43069 }
43070 arg2 = static_cast< size_t >(val2);
43071 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
43072 if (!SWIG_IsOK(res3)) {
43073 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
43074 }
43075 {
43076 PyThreadState* __tstate = wxPyBeginAllowThreads();
43077 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
43078 wxPyEndAllowThreads(__tstate);
43079 if (PyErr_Occurred()) SWIG_fail;
43080 }
43081 {
43082 resultobj = wxPyMake_wxObject(result, (bool)0);
43083 }
43084 return resultobj;
43085 fail:
43086 return NULL;
43087 }
43088
43089
43090 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43091 PyObject *resultobj = 0;
43092 wxMenu *arg1 = (wxMenu *) 0 ;
43093 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43094 wxMenuItem *result = 0 ;
43095 void *argp1 = 0 ;
43096 int res1 = 0 ;
43097 int res2 = 0 ;
43098 PyObject * obj0 = 0 ;
43099 PyObject * obj1 = 0 ;
43100 char * kwnames[] = {
43101 (char *) "self",(char *) "item", NULL
43102 };
43103
43104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
43105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43106 if (!SWIG_IsOK(res1)) {
43107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43108 }
43109 arg1 = reinterpret_cast< wxMenu * >(argp1);
43110 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
43111 if (!SWIG_IsOK(res2)) {
43112 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43113 }
43114 {
43115 PyThreadState* __tstate = wxPyBeginAllowThreads();
43116 result = (wxMenuItem *)(arg1)->Prepend(arg2);
43117 wxPyEndAllowThreads(__tstate);
43118 if (PyErr_Occurred()) SWIG_fail;
43119 }
43120 {
43121 resultobj = wxPyMake_wxObject(result, (bool)0);
43122 }
43123 return resultobj;
43124 fail:
43125 return NULL;
43126 }
43127
43128
43129 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43130 PyObject *resultobj = 0;
43131 wxMenu *arg1 = (wxMenu *) 0 ;
43132 void *argp1 = 0 ;
43133 int res1 = 0 ;
43134 PyObject *swig_obj[1] ;
43135
43136 if (!args) SWIG_fail;
43137 swig_obj[0] = args;
43138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43139 if (!SWIG_IsOK(res1)) {
43140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
43141 }
43142 arg1 = reinterpret_cast< wxMenu * >(argp1);
43143 {
43144 PyThreadState* __tstate = wxPyBeginAllowThreads();
43145 (arg1)->Break();
43146 wxPyEndAllowThreads(__tstate);
43147 if (PyErr_Occurred()) SWIG_fail;
43148 }
43149 resultobj = SWIG_Py_Void();
43150 return resultobj;
43151 fail:
43152 return NULL;
43153 }
43154
43155
43156 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43157 PyObject *resultobj = 0;
43158 wxMenu *arg1 = (wxMenu *) 0 ;
43159 size_t arg2 ;
43160 int arg3 ;
43161 wxString const &arg4_defvalue = wxPyEmptyString ;
43162 wxString *arg4 = (wxString *) &arg4_defvalue ;
43163 wxString const &arg5_defvalue = wxPyEmptyString ;
43164 wxString *arg5 = (wxString *) &arg5_defvalue ;
43165 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
43166 wxMenuItem *result = 0 ;
43167 void *argp1 = 0 ;
43168 int res1 = 0 ;
43169 size_t val2 ;
43170 int ecode2 = 0 ;
43171 int val3 ;
43172 int ecode3 = 0 ;
43173 bool temp4 = false ;
43174 bool temp5 = false ;
43175 int val6 ;
43176 int ecode6 = 0 ;
43177 PyObject * obj0 = 0 ;
43178 PyObject * obj1 = 0 ;
43179 PyObject * obj2 = 0 ;
43180 PyObject * obj3 = 0 ;
43181 PyObject * obj4 = 0 ;
43182 PyObject * obj5 = 0 ;
43183 char * kwnames[] = {
43184 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
43185 };
43186
43187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
43188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43189 if (!SWIG_IsOK(res1)) {
43190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
43191 }
43192 arg1 = reinterpret_cast< wxMenu * >(argp1);
43193 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43194 if (!SWIG_IsOK(ecode2)) {
43195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
43196 }
43197 arg2 = static_cast< size_t >(val2);
43198 ecode3 = SWIG_AsVal_int(obj2, &val3);
43199 if (!SWIG_IsOK(ecode3)) {
43200 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
43201 }
43202 arg3 = static_cast< int >(val3);
43203 if (obj3) {
43204 {
43205 arg4 = wxString_in_helper(obj3);
43206 if (arg4 == NULL) SWIG_fail;
43207 temp4 = true;
43208 }
43209 }
43210 if (obj4) {
43211 {
43212 arg5 = wxString_in_helper(obj4);
43213 if (arg5 == NULL) SWIG_fail;
43214 temp5 = true;
43215 }
43216 }
43217 if (obj5) {
43218 ecode6 = SWIG_AsVal_int(obj5, &val6);
43219 if (!SWIG_IsOK(ecode6)) {
43220 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
43221 }
43222 arg6 = static_cast< wxItemKind >(val6);
43223 }
43224 {
43225 PyThreadState* __tstate = wxPyBeginAllowThreads();
43226 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
43227 wxPyEndAllowThreads(__tstate);
43228 if (PyErr_Occurred()) SWIG_fail;
43229 }
43230 {
43231 resultobj = wxPyMake_wxObject(result, (bool)0);
43232 }
43233 {
43234 if (temp4)
43235 delete arg4;
43236 }
43237 {
43238 if (temp5)
43239 delete arg5;
43240 }
43241 return resultobj;
43242 fail:
43243 {
43244 if (temp4)
43245 delete arg4;
43246 }
43247 {
43248 if (temp5)
43249 delete arg5;
43250 }
43251 return NULL;
43252 }
43253
43254
43255 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43256 PyObject *resultobj = 0;
43257 wxMenu *arg1 = (wxMenu *) 0 ;
43258 size_t arg2 ;
43259 wxMenuItem *result = 0 ;
43260 void *argp1 = 0 ;
43261 int res1 = 0 ;
43262 size_t val2 ;
43263 int ecode2 = 0 ;
43264 PyObject * obj0 = 0 ;
43265 PyObject * obj1 = 0 ;
43266 char * kwnames[] = {
43267 (char *) "self",(char *) "pos", NULL
43268 };
43269
43270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
43271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43272 if (!SWIG_IsOK(res1)) {
43273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
43274 }
43275 arg1 = reinterpret_cast< wxMenu * >(argp1);
43276 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43277 if (!SWIG_IsOK(ecode2)) {
43278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
43279 }
43280 arg2 = static_cast< size_t >(val2);
43281 {
43282 PyThreadState* __tstate = wxPyBeginAllowThreads();
43283 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
43284 wxPyEndAllowThreads(__tstate);
43285 if (PyErr_Occurred()) SWIG_fail;
43286 }
43287 {
43288 resultobj = wxPyMake_wxObject(result, (bool)0);
43289 }
43290 return resultobj;
43291 fail:
43292 return NULL;
43293 }
43294
43295
43296 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43297 PyObject *resultobj = 0;
43298 wxMenu *arg1 = (wxMenu *) 0 ;
43299 size_t arg2 ;
43300 int arg3 ;
43301 wxString *arg4 = 0 ;
43302 wxString const &arg5_defvalue = wxPyEmptyString ;
43303 wxString *arg5 = (wxString *) &arg5_defvalue ;
43304 wxMenuItem *result = 0 ;
43305 void *argp1 = 0 ;
43306 int res1 = 0 ;
43307 size_t val2 ;
43308 int ecode2 = 0 ;
43309 int val3 ;
43310 int ecode3 = 0 ;
43311 bool temp4 = false ;
43312 bool temp5 = false ;
43313 PyObject * obj0 = 0 ;
43314 PyObject * obj1 = 0 ;
43315 PyObject * obj2 = 0 ;
43316 PyObject * obj3 = 0 ;
43317 PyObject * obj4 = 0 ;
43318 char * kwnames[] = {
43319 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
43320 };
43321
43322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43324 if (!SWIG_IsOK(res1)) {
43325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43326 }
43327 arg1 = reinterpret_cast< wxMenu * >(argp1);
43328 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43329 if (!SWIG_IsOK(ecode2)) {
43330 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
43331 }
43332 arg2 = static_cast< size_t >(val2);
43333 ecode3 = SWIG_AsVal_int(obj2, &val3);
43334 if (!SWIG_IsOK(ecode3)) {
43335 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
43336 }
43337 arg3 = static_cast< int >(val3);
43338 {
43339 arg4 = wxString_in_helper(obj3);
43340 if (arg4 == NULL) SWIG_fail;
43341 temp4 = true;
43342 }
43343 if (obj4) {
43344 {
43345 arg5 = wxString_in_helper(obj4);
43346 if (arg5 == NULL) SWIG_fail;
43347 temp5 = true;
43348 }
43349 }
43350 {
43351 PyThreadState* __tstate = wxPyBeginAllowThreads();
43352 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
43353 wxPyEndAllowThreads(__tstate);
43354 if (PyErr_Occurred()) SWIG_fail;
43355 }
43356 {
43357 resultobj = wxPyMake_wxObject(result, (bool)0);
43358 }
43359 {
43360 if (temp4)
43361 delete arg4;
43362 }
43363 {
43364 if (temp5)
43365 delete arg5;
43366 }
43367 return resultobj;
43368 fail:
43369 {
43370 if (temp4)
43371 delete arg4;
43372 }
43373 {
43374 if (temp5)
43375 delete arg5;
43376 }
43377 return NULL;
43378 }
43379
43380
43381 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43382 PyObject *resultobj = 0;
43383 wxMenu *arg1 = (wxMenu *) 0 ;
43384 size_t arg2 ;
43385 int arg3 ;
43386 wxString *arg4 = 0 ;
43387 wxString const &arg5_defvalue = wxPyEmptyString ;
43388 wxString *arg5 = (wxString *) &arg5_defvalue ;
43389 wxMenuItem *result = 0 ;
43390 void *argp1 = 0 ;
43391 int res1 = 0 ;
43392 size_t val2 ;
43393 int ecode2 = 0 ;
43394 int val3 ;
43395 int ecode3 = 0 ;
43396 bool temp4 = false ;
43397 bool temp5 = false ;
43398 PyObject * obj0 = 0 ;
43399 PyObject * obj1 = 0 ;
43400 PyObject * obj2 = 0 ;
43401 PyObject * obj3 = 0 ;
43402 PyObject * obj4 = 0 ;
43403 char * kwnames[] = {
43404 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
43405 };
43406
43407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43409 if (!SWIG_IsOK(res1)) {
43410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43411 }
43412 arg1 = reinterpret_cast< wxMenu * >(argp1);
43413 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43414 if (!SWIG_IsOK(ecode2)) {
43415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
43416 }
43417 arg2 = static_cast< size_t >(val2);
43418 ecode3 = SWIG_AsVal_int(obj2, &val3);
43419 if (!SWIG_IsOK(ecode3)) {
43420 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
43421 }
43422 arg3 = static_cast< int >(val3);
43423 {
43424 arg4 = wxString_in_helper(obj3);
43425 if (arg4 == NULL) SWIG_fail;
43426 temp4 = true;
43427 }
43428 if (obj4) {
43429 {
43430 arg5 = wxString_in_helper(obj4);
43431 if (arg5 == NULL) SWIG_fail;
43432 temp5 = true;
43433 }
43434 }
43435 {
43436 PyThreadState* __tstate = wxPyBeginAllowThreads();
43437 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
43438 wxPyEndAllowThreads(__tstate);
43439 if (PyErr_Occurred()) SWIG_fail;
43440 }
43441 {
43442 resultobj = wxPyMake_wxObject(result, (bool)0);
43443 }
43444 {
43445 if (temp4)
43446 delete arg4;
43447 }
43448 {
43449 if (temp5)
43450 delete arg5;
43451 }
43452 return resultobj;
43453 fail:
43454 {
43455 if (temp4)
43456 delete arg4;
43457 }
43458 {
43459 if (temp5)
43460 delete arg5;
43461 }
43462 return NULL;
43463 }
43464
43465
43466 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43467 PyObject *resultobj = 0;
43468 wxMenu *arg1 = (wxMenu *) 0 ;
43469 size_t arg2 ;
43470 int arg3 ;
43471 wxString *arg4 = 0 ;
43472 wxMenu *arg5 = (wxMenu *) 0 ;
43473 wxString const &arg6_defvalue = wxPyEmptyString ;
43474 wxString *arg6 = (wxString *) &arg6_defvalue ;
43475 wxMenuItem *result = 0 ;
43476 void *argp1 = 0 ;
43477 int res1 = 0 ;
43478 size_t val2 ;
43479 int ecode2 = 0 ;
43480 int val3 ;
43481 int ecode3 = 0 ;
43482 bool temp4 = false ;
43483 void *argp5 = 0 ;
43484 int res5 = 0 ;
43485 bool temp6 = false ;
43486 PyObject * obj0 = 0 ;
43487 PyObject * obj1 = 0 ;
43488 PyObject * obj2 = 0 ;
43489 PyObject * obj3 = 0 ;
43490 PyObject * obj4 = 0 ;
43491 PyObject * obj5 = 0 ;
43492 char * kwnames[] = {
43493 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
43494 };
43495
43496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
43497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43498 if (!SWIG_IsOK(res1)) {
43499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
43500 }
43501 arg1 = reinterpret_cast< wxMenu * >(argp1);
43502 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43503 if (!SWIG_IsOK(ecode2)) {
43504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
43505 }
43506 arg2 = static_cast< size_t >(val2);
43507 ecode3 = SWIG_AsVal_int(obj2, &val3);
43508 if (!SWIG_IsOK(ecode3)) {
43509 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
43510 }
43511 arg3 = static_cast< int >(val3);
43512 {
43513 arg4 = wxString_in_helper(obj3);
43514 if (arg4 == NULL) SWIG_fail;
43515 temp4 = true;
43516 }
43517 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
43518 if (!SWIG_IsOK(res5)) {
43519 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
43520 }
43521 arg5 = reinterpret_cast< wxMenu * >(argp5);
43522 if (obj5) {
43523 {
43524 arg6 = wxString_in_helper(obj5);
43525 if (arg6 == NULL) SWIG_fail;
43526 temp6 = true;
43527 }
43528 }
43529 {
43530 PyThreadState* __tstate = wxPyBeginAllowThreads();
43531 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
43532 wxPyEndAllowThreads(__tstate);
43533 if (PyErr_Occurred()) SWIG_fail;
43534 }
43535 {
43536 resultobj = wxPyMake_wxObject(result, (bool)0);
43537 }
43538 {
43539 if (temp4)
43540 delete arg4;
43541 }
43542 {
43543 if (temp6)
43544 delete arg6;
43545 }
43546 return resultobj;
43547 fail:
43548 {
43549 if (temp4)
43550 delete arg4;
43551 }
43552 {
43553 if (temp6)
43554 delete arg6;
43555 }
43556 return NULL;
43557 }
43558
43559
43560 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43561 PyObject *resultobj = 0;
43562 wxMenu *arg1 = (wxMenu *) 0 ;
43563 int arg2 ;
43564 wxString const &arg3_defvalue = wxPyEmptyString ;
43565 wxString *arg3 = (wxString *) &arg3_defvalue ;
43566 wxString const &arg4_defvalue = wxPyEmptyString ;
43567 wxString *arg4 = (wxString *) &arg4_defvalue ;
43568 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
43569 wxMenuItem *result = 0 ;
43570 void *argp1 = 0 ;
43571 int res1 = 0 ;
43572 int val2 ;
43573 int ecode2 = 0 ;
43574 bool temp3 = false ;
43575 bool temp4 = false ;
43576 int val5 ;
43577 int ecode5 = 0 ;
43578 PyObject * obj0 = 0 ;
43579 PyObject * obj1 = 0 ;
43580 PyObject * obj2 = 0 ;
43581 PyObject * obj3 = 0 ;
43582 PyObject * obj4 = 0 ;
43583 char * kwnames[] = {
43584 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
43585 };
43586
43587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43589 if (!SWIG_IsOK(res1)) {
43590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
43591 }
43592 arg1 = reinterpret_cast< wxMenu * >(argp1);
43593 ecode2 = SWIG_AsVal_int(obj1, &val2);
43594 if (!SWIG_IsOK(ecode2)) {
43595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
43596 }
43597 arg2 = static_cast< int >(val2);
43598 if (obj2) {
43599 {
43600 arg3 = wxString_in_helper(obj2);
43601 if (arg3 == NULL) SWIG_fail;
43602 temp3 = true;
43603 }
43604 }
43605 if (obj3) {
43606 {
43607 arg4 = wxString_in_helper(obj3);
43608 if (arg4 == NULL) SWIG_fail;
43609 temp4 = true;
43610 }
43611 }
43612 if (obj4) {
43613 ecode5 = SWIG_AsVal_int(obj4, &val5);
43614 if (!SWIG_IsOK(ecode5)) {
43615 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
43616 }
43617 arg5 = static_cast< wxItemKind >(val5);
43618 }
43619 {
43620 PyThreadState* __tstate = wxPyBeginAllowThreads();
43621 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
43622 wxPyEndAllowThreads(__tstate);
43623 if (PyErr_Occurred()) SWIG_fail;
43624 }
43625 {
43626 resultobj = wxPyMake_wxObject(result, (bool)0);
43627 }
43628 {
43629 if (temp3)
43630 delete arg3;
43631 }
43632 {
43633 if (temp4)
43634 delete arg4;
43635 }
43636 return resultobj;
43637 fail:
43638 {
43639 if (temp3)
43640 delete arg3;
43641 }
43642 {
43643 if (temp4)
43644 delete arg4;
43645 }
43646 return NULL;
43647 }
43648
43649
43650 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43651 PyObject *resultobj = 0;
43652 wxMenu *arg1 = (wxMenu *) 0 ;
43653 wxMenuItem *result = 0 ;
43654 void *argp1 = 0 ;
43655 int res1 = 0 ;
43656 PyObject *swig_obj[1] ;
43657
43658 if (!args) SWIG_fail;
43659 swig_obj[0] = args;
43660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43661 if (!SWIG_IsOK(res1)) {
43662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
43663 }
43664 arg1 = reinterpret_cast< wxMenu * >(argp1);
43665 {
43666 PyThreadState* __tstate = wxPyBeginAllowThreads();
43667 result = (wxMenuItem *)(arg1)->PrependSeparator();
43668 wxPyEndAllowThreads(__tstate);
43669 if (PyErr_Occurred()) SWIG_fail;
43670 }
43671 {
43672 resultobj = wxPyMake_wxObject(result, (bool)0);
43673 }
43674 return resultobj;
43675 fail:
43676 return NULL;
43677 }
43678
43679
43680 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43681 PyObject *resultobj = 0;
43682 wxMenu *arg1 = (wxMenu *) 0 ;
43683 int arg2 ;
43684 wxString *arg3 = 0 ;
43685 wxString const &arg4_defvalue = wxPyEmptyString ;
43686 wxString *arg4 = (wxString *) &arg4_defvalue ;
43687 wxMenuItem *result = 0 ;
43688 void *argp1 = 0 ;
43689 int res1 = 0 ;
43690 int val2 ;
43691 int ecode2 = 0 ;
43692 bool temp3 = false ;
43693 bool temp4 = false ;
43694 PyObject * obj0 = 0 ;
43695 PyObject * obj1 = 0 ;
43696 PyObject * obj2 = 0 ;
43697 PyObject * obj3 = 0 ;
43698 char * kwnames[] = {
43699 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
43700 };
43701
43702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43704 if (!SWIG_IsOK(res1)) {
43705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43706 }
43707 arg1 = reinterpret_cast< wxMenu * >(argp1);
43708 ecode2 = SWIG_AsVal_int(obj1, &val2);
43709 if (!SWIG_IsOK(ecode2)) {
43710 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
43711 }
43712 arg2 = static_cast< int >(val2);
43713 {
43714 arg3 = wxString_in_helper(obj2);
43715 if (arg3 == NULL) SWIG_fail;
43716 temp3 = true;
43717 }
43718 if (obj3) {
43719 {
43720 arg4 = wxString_in_helper(obj3);
43721 if (arg4 == NULL) SWIG_fail;
43722 temp4 = true;
43723 }
43724 }
43725 {
43726 PyThreadState* __tstate = wxPyBeginAllowThreads();
43727 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
43728 wxPyEndAllowThreads(__tstate);
43729 if (PyErr_Occurred()) SWIG_fail;
43730 }
43731 {
43732 resultobj = wxPyMake_wxObject(result, (bool)0);
43733 }
43734 {
43735 if (temp3)
43736 delete arg3;
43737 }
43738 {
43739 if (temp4)
43740 delete arg4;
43741 }
43742 return resultobj;
43743 fail:
43744 {
43745 if (temp3)
43746 delete arg3;
43747 }
43748 {
43749 if (temp4)
43750 delete arg4;
43751 }
43752 return NULL;
43753 }
43754
43755
43756 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43757 PyObject *resultobj = 0;
43758 wxMenu *arg1 = (wxMenu *) 0 ;
43759 int arg2 ;
43760 wxString *arg3 = 0 ;
43761 wxString const &arg4_defvalue = wxPyEmptyString ;
43762 wxString *arg4 = (wxString *) &arg4_defvalue ;
43763 wxMenuItem *result = 0 ;
43764 void *argp1 = 0 ;
43765 int res1 = 0 ;
43766 int val2 ;
43767 int ecode2 = 0 ;
43768 bool temp3 = false ;
43769 bool temp4 = false ;
43770 PyObject * obj0 = 0 ;
43771 PyObject * obj1 = 0 ;
43772 PyObject * obj2 = 0 ;
43773 PyObject * obj3 = 0 ;
43774 char * kwnames[] = {
43775 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
43776 };
43777
43778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43780 if (!SWIG_IsOK(res1)) {
43781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43782 }
43783 arg1 = reinterpret_cast< wxMenu * >(argp1);
43784 ecode2 = SWIG_AsVal_int(obj1, &val2);
43785 if (!SWIG_IsOK(ecode2)) {
43786 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
43787 }
43788 arg2 = static_cast< int >(val2);
43789 {
43790 arg3 = wxString_in_helper(obj2);
43791 if (arg3 == NULL) SWIG_fail;
43792 temp3 = true;
43793 }
43794 if (obj3) {
43795 {
43796 arg4 = wxString_in_helper(obj3);
43797 if (arg4 == NULL) SWIG_fail;
43798 temp4 = true;
43799 }
43800 }
43801 {
43802 PyThreadState* __tstate = wxPyBeginAllowThreads();
43803 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
43804 wxPyEndAllowThreads(__tstate);
43805 if (PyErr_Occurred()) SWIG_fail;
43806 }
43807 {
43808 resultobj = wxPyMake_wxObject(result, (bool)0);
43809 }
43810 {
43811 if (temp3)
43812 delete arg3;
43813 }
43814 {
43815 if (temp4)
43816 delete arg4;
43817 }
43818 return resultobj;
43819 fail:
43820 {
43821 if (temp3)
43822 delete arg3;
43823 }
43824 {
43825 if (temp4)
43826 delete arg4;
43827 }
43828 return NULL;
43829 }
43830
43831
43832 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43833 PyObject *resultobj = 0;
43834 wxMenu *arg1 = (wxMenu *) 0 ;
43835 int arg2 ;
43836 wxString *arg3 = 0 ;
43837 wxMenu *arg4 = (wxMenu *) 0 ;
43838 wxString const &arg5_defvalue = wxPyEmptyString ;
43839 wxString *arg5 = (wxString *) &arg5_defvalue ;
43840 wxMenuItem *result = 0 ;
43841 void *argp1 = 0 ;
43842 int res1 = 0 ;
43843 int val2 ;
43844 int ecode2 = 0 ;
43845 bool temp3 = false ;
43846 void *argp4 = 0 ;
43847 int res4 = 0 ;
43848 bool temp5 = false ;
43849 PyObject * obj0 = 0 ;
43850 PyObject * obj1 = 0 ;
43851 PyObject * obj2 = 0 ;
43852 PyObject * obj3 = 0 ;
43853 PyObject * obj4 = 0 ;
43854 char * kwnames[] = {
43855 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
43856 };
43857
43858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43860 if (!SWIG_IsOK(res1)) {
43861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
43862 }
43863 arg1 = reinterpret_cast< wxMenu * >(argp1);
43864 ecode2 = SWIG_AsVal_int(obj1, &val2);
43865 if (!SWIG_IsOK(ecode2)) {
43866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
43867 }
43868 arg2 = static_cast< int >(val2);
43869 {
43870 arg3 = wxString_in_helper(obj2);
43871 if (arg3 == NULL) SWIG_fail;
43872 temp3 = true;
43873 }
43874 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
43875 if (!SWIG_IsOK(res4)) {
43876 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
43877 }
43878 arg4 = reinterpret_cast< wxMenu * >(argp4);
43879 if (obj4) {
43880 {
43881 arg5 = wxString_in_helper(obj4);
43882 if (arg5 == NULL) SWIG_fail;
43883 temp5 = true;
43884 }
43885 }
43886 {
43887 PyThreadState* __tstate = wxPyBeginAllowThreads();
43888 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
43889 wxPyEndAllowThreads(__tstate);
43890 if (PyErr_Occurred()) SWIG_fail;
43891 }
43892 {
43893 resultobj = wxPyMake_wxObject(result, (bool)0);
43894 }
43895 {
43896 if (temp3)
43897 delete arg3;
43898 }
43899 {
43900 if (temp5)
43901 delete arg5;
43902 }
43903 return resultobj;
43904 fail:
43905 {
43906 if (temp3)
43907 delete arg3;
43908 }
43909 {
43910 if (temp5)
43911 delete arg5;
43912 }
43913 return NULL;
43914 }
43915
43916
43917 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43918 PyObject *resultobj = 0;
43919 wxMenu *arg1 = (wxMenu *) 0 ;
43920 int arg2 ;
43921 wxMenuItem *result = 0 ;
43922 void *argp1 = 0 ;
43923 int res1 = 0 ;
43924 int val2 ;
43925 int ecode2 = 0 ;
43926 PyObject * obj0 = 0 ;
43927 PyObject * obj1 = 0 ;
43928 char * kwnames[] = {
43929 (char *) "self",(char *) "id", NULL
43930 };
43931
43932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
43933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43934 if (!SWIG_IsOK(res1)) {
43935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
43936 }
43937 arg1 = reinterpret_cast< wxMenu * >(argp1);
43938 ecode2 = SWIG_AsVal_int(obj1, &val2);
43939 if (!SWIG_IsOK(ecode2)) {
43940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
43941 }
43942 arg2 = static_cast< int >(val2);
43943 {
43944 PyThreadState* __tstate = wxPyBeginAllowThreads();
43945 result = (wxMenuItem *)(arg1)->Remove(arg2);
43946 wxPyEndAllowThreads(__tstate);
43947 if (PyErr_Occurred()) SWIG_fail;
43948 }
43949 {
43950 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43951 }
43952 return resultobj;
43953 fail:
43954 return NULL;
43955 }
43956
43957
43958 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43959 PyObject *resultobj = 0;
43960 wxMenu *arg1 = (wxMenu *) 0 ;
43961 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43962 wxMenuItem *result = 0 ;
43963 void *argp1 = 0 ;
43964 int res1 = 0 ;
43965 void *argp2 = 0 ;
43966 int res2 = 0 ;
43967 PyObject * obj0 = 0 ;
43968 PyObject * obj1 = 0 ;
43969 char * kwnames[] = {
43970 (char *) "self",(char *) "item", NULL
43971 };
43972
43973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",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_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43977 }
43978 arg1 = reinterpret_cast< wxMenu * >(argp1);
43979 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43980 if (!SWIG_IsOK(res2)) {
43981 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43982 }
43983 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
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_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44000 PyObject *resultobj = 0;
44001 wxMenu *arg1 = (wxMenu *) 0 ;
44002 int arg2 ;
44003 bool result;
44004 void *argp1 = 0 ;
44005 int res1 = 0 ;
44006 int val2 ;
44007 int ecode2 = 0 ;
44008 PyObject * obj0 = 0 ;
44009 PyObject * obj1 = 0 ;
44010 char * kwnames[] = {
44011 (char *) "self",(char *) "id", NULL
44012 };
44013
44014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",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_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
44018 }
44019 arg1 = reinterpret_cast< wxMenu * >(argp1);
44020 ecode2 = SWIG_AsVal_int(obj1, &val2);
44021 if (!SWIG_IsOK(ecode2)) {
44022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
44023 }
44024 arg2 = static_cast< int >(val2);
44025 {
44026 PyThreadState* __tstate = wxPyBeginAllowThreads();
44027 result = (bool)(arg1)->Delete(arg2);
44028 wxPyEndAllowThreads(__tstate);
44029 if (PyErr_Occurred()) SWIG_fail;
44030 }
44031 {
44032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44033 }
44034 return resultobj;
44035 fail:
44036 return NULL;
44037 }
44038
44039
44040 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44041 PyObject *resultobj = 0;
44042 wxMenu *arg1 = (wxMenu *) 0 ;
44043 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
44044 bool result;
44045 void *argp1 = 0 ;
44046 int res1 = 0 ;
44047 void *argp2 = 0 ;
44048 int res2 = 0 ;
44049 PyObject * obj0 = 0 ;
44050 PyObject * obj1 = 0 ;
44051 char * kwnames[] = {
44052 (char *) "self",(char *) "item", NULL
44053 };
44054
44055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",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_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
44059 }
44060 arg1 = reinterpret_cast< wxMenu * >(argp1);
44061 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44062 if (!SWIG_IsOK(res2)) {
44063 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
44064 }
44065 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
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_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44082 PyObject *resultobj = 0;
44083 wxMenu *arg1 = (wxMenu *) 0 ;
44084 void *argp1 = 0 ;
44085 int res1 = 0 ;
44086 PyObject *swig_obj[1] ;
44087
44088 if (!args) SWIG_fail;
44089 swig_obj[0] = args;
44090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44091 if (!SWIG_IsOK(res1)) {
44092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
44093 }
44094 arg1 = reinterpret_cast< wxMenu * >(argp1);
44095 {
44096 PyThreadState* __tstate = wxPyBeginAllowThreads();
44097 wxMenu_Destroy(arg1);
44098 wxPyEndAllowThreads(__tstate);
44099 if (PyErr_Occurred()) SWIG_fail;
44100 }
44101 resultobj = SWIG_Py_Void();
44102 return resultobj;
44103 fail:
44104 return NULL;
44105 }
44106
44107
44108 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44109 PyObject *resultobj = 0;
44110 wxMenu *arg1 = (wxMenu *) 0 ;
44111 int arg2 ;
44112 bool result;
44113 void *argp1 = 0 ;
44114 int res1 = 0 ;
44115 int val2 ;
44116 int ecode2 = 0 ;
44117 PyObject * obj0 = 0 ;
44118 PyObject * obj1 = 0 ;
44119 char * kwnames[] = {
44120 (char *) "self",(char *) "id", NULL
44121 };
44122
44123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
44124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44125 if (!SWIG_IsOK(res1)) {
44126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
44127 }
44128 arg1 = reinterpret_cast< wxMenu * >(argp1);
44129 ecode2 = SWIG_AsVal_int(obj1, &val2);
44130 if (!SWIG_IsOK(ecode2)) {
44131 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
44132 }
44133 arg2 = static_cast< int >(val2);
44134 {
44135 PyThreadState* __tstate = wxPyBeginAllowThreads();
44136 result = (bool)(arg1)->Destroy(arg2);
44137 wxPyEndAllowThreads(__tstate);
44138 if (PyErr_Occurred()) SWIG_fail;
44139 }
44140 {
44141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44142 }
44143 return resultobj;
44144 fail:
44145 return NULL;
44146 }
44147
44148
44149 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44150 PyObject *resultobj = 0;
44151 wxMenu *arg1 = (wxMenu *) 0 ;
44152 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
44153 bool result;
44154 void *argp1 = 0 ;
44155 int res1 = 0 ;
44156 void *argp2 = 0 ;
44157 int res2 = 0 ;
44158 PyObject * obj0 = 0 ;
44159 PyObject * obj1 = 0 ;
44160 char * kwnames[] = {
44161 (char *) "self",(char *) "item", NULL
44162 };
44163
44164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",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_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
44168 }
44169 arg1 = reinterpret_cast< wxMenu * >(argp1);
44170 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44171 if (!SWIG_IsOK(res2)) {
44172 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
44173 }
44174 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
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_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44191 PyObject *resultobj = 0;
44192 wxMenu *arg1 = (wxMenu *) 0 ;
44193 size_t result;
44194 void *argp1 = 0 ;
44195 int res1 = 0 ;
44196 PyObject *swig_obj[1] ;
44197
44198 if (!args) SWIG_fail;
44199 swig_obj[0] = args;
44200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44201 if (!SWIG_IsOK(res1)) {
44202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
44203 }
44204 arg1 = reinterpret_cast< wxMenu * >(argp1);
44205 {
44206 PyThreadState* __tstate = wxPyBeginAllowThreads();
44207 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
44208 wxPyEndAllowThreads(__tstate);
44209 if (PyErr_Occurred()) SWIG_fail;
44210 }
44211 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
44212 return resultobj;
44213 fail:
44214 return NULL;
44215 }
44216
44217
44218 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44219 PyObject *resultobj = 0;
44220 wxMenu *arg1 = (wxMenu *) 0 ;
44221 PyObject *result = 0 ;
44222 void *argp1 = 0 ;
44223 int res1 = 0 ;
44224 PyObject *swig_obj[1] ;
44225
44226 if (!args) SWIG_fail;
44227 swig_obj[0] = args;
44228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44229 if (!SWIG_IsOK(res1)) {
44230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
44231 }
44232 arg1 = reinterpret_cast< wxMenu * >(argp1);
44233 {
44234 PyThreadState* __tstate = wxPyBeginAllowThreads();
44235 result = (PyObject *)wxMenu_GetMenuItems(arg1);
44236 wxPyEndAllowThreads(__tstate);
44237 if (PyErr_Occurred()) SWIG_fail;
44238 }
44239 resultobj = result;
44240 return resultobj;
44241 fail:
44242 return NULL;
44243 }
44244
44245
44246 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44247 PyObject *resultobj = 0;
44248 wxMenu *arg1 = (wxMenu *) 0 ;
44249 wxString *arg2 = 0 ;
44250 int result;
44251 void *argp1 = 0 ;
44252 int res1 = 0 ;
44253 bool temp2 = false ;
44254 PyObject * obj0 = 0 ;
44255 PyObject * obj1 = 0 ;
44256 char * kwnames[] = {
44257 (char *) "self",(char *) "item", NULL
44258 };
44259
44260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
44261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44262 if (!SWIG_IsOK(res1)) {
44263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
44264 }
44265 arg1 = reinterpret_cast< wxMenu * >(argp1);
44266 {
44267 arg2 = wxString_in_helper(obj1);
44268 if (arg2 == NULL) SWIG_fail;
44269 temp2 = true;
44270 }
44271 {
44272 PyThreadState* __tstate = wxPyBeginAllowThreads();
44273 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
44274 wxPyEndAllowThreads(__tstate);
44275 if (PyErr_Occurred()) SWIG_fail;
44276 }
44277 resultobj = SWIG_From_int(static_cast< int >(result));
44278 {
44279 if (temp2)
44280 delete arg2;
44281 }
44282 return resultobj;
44283 fail:
44284 {
44285 if (temp2)
44286 delete arg2;
44287 }
44288 return NULL;
44289 }
44290
44291
44292 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44293 PyObject *resultobj = 0;
44294 wxMenu *arg1 = (wxMenu *) 0 ;
44295 int arg2 ;
44296 wxMenuItem *result = 0 ;
44297 void *argp1 = 0 ;
44298 int res1 = 0 ;
44299 int val2 ;
44300 int ecode2 = 0 ;
44301 PyObject * obj0 = 0 ;
44302 PyObject * obj1 = 0 ;
44303 char * kwnames[] = {
44304 (char *) "self",(char *) "id", NULL
44305 };
44306
44307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
44308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44309 if (!SWIG_IsOK(res1)) {
44310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
44311 }
44312 arg1 = reinterpret_cast< wxMenu * >(argp1);
44313 ecode2 = SWIG_AsVal_int(obj1, &val2);
44314 if (!SWIG_IsOK(ecode2)) {
44315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
44316 }
44317 arg2 = static_cast< int >(val2);
44318 {
44319 PyThreadState* __tstate = wxPyBeginAllowThreads();
44320 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
44321 wxPyEndAllowThreads(__tstate);
44322 if (PyErr_Occurred()) SWIG_fail;
44323 }
44324 {
44325 resultobj = wxPyMake_wxObject(result, (bool)0);
44326 }
44327 return resultobj;
44328 fail:
44329 return NULL;
44330 }
44331
44332
44333 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44334 PyObject *resultobj = 0;
44335 wxMenu *arg1 = (wxMenu *) 0 ;
44336 size_t arg2 ;
44337 wxMenuItem *result = 0 ;
44338 void *argp1 = 0 ;
44339 int res1 = 0 ;
44340 size_t val2 ;
44341 int ecode2 = 0 ;
44342 PyObject * obj0 = 0 ;
44343 PyObject * obj1 = 0 ;
44344 char * kwnames[] = {
44345 (char *) "self",(char *) "position", NULL
44346 };
44347
44348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",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_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
44352 }
44353 arg1 = reinterpret_cast< wxMenu * >(argp1);
44354 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44355 if (!SWIG_IsOK(ecode2)) {
44356 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
44357 }
44358 arg2 = static_cast< size_t >(val2);
44359 {
44360 PyThreadState* __tstate = wxPyBeginAllowThreads();
44361 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(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_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44375 PyObject *resultobj = 0;
44376 wxMenu *arg1 = (wxMenu *) 0 ;
44377 int arg2 ;
44378 bool arg3 ;
44379 void *argp1 = 0 ;
44380 int res1 = 0 ;
44381 int val2 ;
44382 int ecode2 = 0 ;
44383 bool val3 ;
44384 int ecode3 = 0 ;
44385 PyObject * obj0 = 0 ;
44386 PyObject * obj1 = 0 ;
44387 PyObject * obj2 = 0 ;
44388 char * kwnames[] = {
44389 (char *) "self",(char *) "id",(char *) "enable", NULL
44390 };
44391
44392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44394 if (!SWIG_IsOK(res1)) {
44395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
44396 }
44397 arg1 = reinterpret_cast< wxMenu * >(argp1);
44398 ecode2 = SWIG_AsVal_int(obj1, &val2);
44399 if (!SWIG_IsOK(ecode2)) {
44400 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
44401 }
44402 arg2 = static_cast< int >(val2);
44403 ecode3 = SWIG_AsVal_bool(obj2, &val3);
44404 if (!SWIG_IsOK(ecode3)) {
44405 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
44406 }
44407 arg3 = static_cast< bool >(val3);
44408 {
44409 PyThreadState* __tstate = wxPyBeginAllowThreads();
44410 (arg1)->Enable(arg2,arg3);
44411 wxPyEndAllowThreads(__tstate);
44412 if (PyErr_Occurred()) SWIG_fail;
44413 }
44414 resultobj = SWIG_Py_Void();
44415 return resultobj;
44416 fail:
44417 return NULL;
44418 }
44419
44420
44421 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44422 PyObject *resultobj = 0;
44423 wxMenu *arg1 = (wxMenu *) 0 ;
44424 int arg2 ;
44425 bool result;
44426 void *argp1 = 0 ;
44427 int res1 = 0 ;
44428 int val2 ;
44429 int ecode2 = 0 ;
44430 PyObject * obj0 = 0 ;
44431 PyObject * obj1 = 0 ;
44432 char * kwnames[] = {
44433 (char *) "self",(char *) "id", NULL
44434 };
44435
44436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
44437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44438 if (!SWIG_IsOK(res1)) {
44439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
44440 }
44441 arg1 = reinterpret_cast< wxMenu * >(argp1);
44442 ecode2 = SWIG_AsVal_int(obj1, &val2);
44443 if (!SWIG_IsOK(ecode2)) {
44444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
44445 }
44446 arg2 = static_cast< int >(val2);
44447 {
44448 PyThreadState* __tstate = wxPyBeginAllowThreads();
44449 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
44450 wxPyEndAllowThreads(__tstate);
44451 if (PyErr_Occurred()) SWIG_fail;
44452 }
44453 {
44454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44455 }
44456 return resultobj;
44457 fail:
44458 return NULL;
44459 }
44460
44461
44462 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44463 PyObject *resultobj = 0;
44464 wxMenu *arg1 = (wxMenu *) 0 ;
44465 int arg2 ;
44466 bool arg3 ;
44467 void *argp1 = 0 ;
44468 int res1 = 0 ;
44469 int val2 ;
44470 int ecode2 = 0 ;
44471 bool val3 ;
44472 int ecode3 = 0 ;
44473 PyObject * obj0 = 0 ;
44474 PyObject * obj1 = 0 ;
44475 PyObject * obj2 = 0 ;
44476 char * kwnames[] = {
44477 (char *) "self",(char *) "id",(char *) "check", NULL
44478 };
44479
44480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44482 if (!SWIG_IsOK(res1)) {
44483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
44484 }
44485 arg1 = reinterpret_cast< wxMenu * >(argp1);
44486 ecode2 = SWIG_AsVal_int(obj1, &val2);
44487 if (!SWIG_IsOK(ecode2)) {
44488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
44489 }
44490 arg2 = static_cast< int >(val2);
44491 ecode3 = SWIG_AsVal_bool(obj2, &val3);
44492 if (!SWIG_IsOK(ecode3)) {
44493 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
44494 }
44495 arg3 = static_cast< bool >(val3);
44496 {
44497 PyThreadState* __tstate = wxPyBeginAllowThreads();
44498 (arg1)->Check(arg2,arg3);
44499 wxPyEndAllowThreads(__tstate);
44500 if (PyErr_Occurred()) SWIG_fail;
44501 }
44502 resultobj = SWIG_Py_Void();
44503 return resultobj;
44504 fail:
44505 return NULL;
44506 }
44507
44508
44509 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44510 PyObject *resultobj = 0;
44511 wxMenu *arg1 = (wxMenu *) 0 ;
44512 int arg2 ;
44513 bool result;
44514 void *argp1 = 0 ;
44515 int res1 = 0 ;
44516 int val2 ;
44517 int ecode2 = 0 ;
44518 PyObject * obj0 = 0 ;
44519 PyObject * obj1 = 0 ;
44520 char * kwnames[] = {
44521 (char *) "self",(char *) "id", NULL
44522 };
44523
44524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
44525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44526 if (!SWIG_IsOK(res1)) {
44527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
44528 }
44529 arg1 = reinterpret_cast< wxMenu * >(argp1);
44530 ecode2 = SWIG_AsVal_int(obj1, &val2);
44531 if (!SWIG_IsOK(ecode2)) {
44532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
44533 }
44534 arg2 = static_cast< int >(val2);
44535 {
44536 PyThreadState* __tstate = wxPyBeginAllowThreads();
44537 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
44538 wxPyEndAllowThreads(__tstate);
44539 if (PyErr_Occurred()) SWIG_fail;
44540 }
44541 {
44542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44543 }
44544 return resultobj;
44545 fail:
44546 return NULL;
44547 }
44548
44549
44550 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44551 PyObject *resultobj = 0;
44552 wxMenu *arg1 = (wxMenu *) 0 ;
44553 int arg2 ;
44554 wxString *arg3 = 0 ;
44555 void *argp1 = 0 ;
44556 int res1 = 0 ;
44557 int val2 ;
44558 int ecode2 = 0 ;
44559 bool temp3 = false ;
44560 PyObject * obj0 = 0 ;
44561 PyObject * obj1 = 0 ;
44562 PyObject * obj2 = 0 ;
44563 char * kwnames[] = {
44564 (char *) "self",(char *) "id",(char *) "label", NULL
44565 };
44566
44567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44569 if (!SWIG_IsOK(res1)) {
44570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
44571 }
44572 arg1 = reinterpret_cast< wxMenu * >(argp1);
44573 ecode2 = SWIG_AsVal_int(obj1, &val2);
44574 if (!SWIG_IsOK(ecode2)) {
44575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
44576 }
44577 arg2 = static_cast< int >(val2);
44578 {
44579 arg3 = wxString_in_helper(obj2);
44580 if (arg3 == NULL) SWIG_fail;
44581 temp3 = true;
44582 }
44583 {
44584 PyThreadState* __tstate = wxPyBeginAllowThreads();
44585 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
44586 wxPyEndAllowThreads(__tstate);
44587 if (PyErr_Occurred()) SWIG_fail;
44588 }
44589 resultobj = SWIG_Py_Void();
44590 {
44591 if (temp3)
44592 delete arg3;
44593 }
44594 return resultobj;
44595 fail:
44596 {
44597 if (temp3)
44598 delete arg3;
44599 }
44600 return NULL;
44601 }
44602
44603
44604 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44605 PyObject *resultobj = 0;
44606 wxMenu *arg1 = (wxMenu *) 0 ;
44607 int arg2 ;
44608 wxString result;
44609 void *argp1 = 0 ;
44610 int res1 = 0 ;
44611 int val2 ;
44612 int ecode2 = 0 ;
44613 PyObject * obj0 = 0 ;
44614 PyObject * obj1 = 0 ;
44615 char * kwnames[] = {
44616 (char *) "self",(char *) "id", NULL
44617 };
44618
44619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
44620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44621 if (!SWIG_IsOK(res1)) {
44622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
44623 }
44624 arg1 = reinterpret_cast< wxMenu * >(argp1);
44625 ecode2 = SWIG_AsVal_int(obj1, &val2);
44626 if (!SWIG_IsOK(ecode2)) {
44627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
44628 }
44629 arg2 = static_cast< int >(val2);
44630 {
44631 PyThreadState* __tstate = wxPyBeginAllowThreads();
44632 result = ((wxMenu const *)arg1)->GetLabel(arg2);
44633 wxPyEndAllowThreads(__tstate);
44634 if (PyErr_Occurred()) SWIG_fail;
44635 }
44636 {
44637 #if wxUSE_UNICODE
44638 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44639 #else
44640 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44641 #endif
44642 }
44643 return resultobj;
44644 fail:
44645 return NULL;
44646 }
44647
44648
44649 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44650 PyObject *resultobj = 0;
44651 wxMenu *arg1 = (wxMenu *) 0 ;
44652 int arg2 ;
44653 wxString *arg3 = 0 ;
44654 void *argp1 = 0 ;
44655 int res1 = 0 ;
44656 int val2 ;
44657 int ecode2 = 0 ;
44658 bool temp3 = false ;
44659 PyObject * obj0 = 0 ;
44660 PyObject * obj1 = 0 ;
44661 PyObject * obj2 = 0 ;
44662 char * kwnames[] = {
44663 (char *) "self",(char *) "id",(char *) "helpString", NULL
44664 };
44665
44666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44668 if (!SWIG_IsOK(res1)) {
44669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
44670 }
44671 arg1 = reinterpret_cast< wxMenu * >(argp1);
44672 ecode2 = SWIG_AsVal_int(obj1, &val2);
44673 if (!SWIG_IsOK(ecode2)) {
44674 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
44675 }
44676 arg2 = static_cast< int >(val2);
44677 {
44678 arg3 = wxString_in_helper(obj2);
44679 if (arg3 == NULL) SWIG_fail;
44680 temp3 = true;
44681 }
44682 {
44683 PyThreadState* __tstate = wxPyBeginAllowThreads();
44684 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
44685 wxPyEndAllowThreads(__tstate);
44686 if (PyErr_Occurred()) SWIG_fail;
44687 }
44688 resultobj = SWIG_Py_Void();
44689 {
44690 if (temp3)
44691 delete arg3;
44692 }
44693 return resultobj;
44694 fail:
44695 {
44696 if (temp3)
44697 delete arg3;
44698 }
44699 return NULL;
44700 }
44701
44702
44703 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44704 PyObject *resultobj = 0;
44705 wxMenu *arg1 = (wxMenu *) 0 ;
44706 int arg2 ;
44707 wxString result;
44708 void *argp1 = 0 ;
44709 int res1 = 0 ;
44710 int val2 ;
44711 int ecode2 = 0 ;
44712 PyObject * obj0 = 0 ;
44713 PyObject * obj1 = 0 ;
44714 char * kwnames[] = {
44715 (char *) "self",(char *) "id", NULL
44716 };
44717
44718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
44719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44720 if (!SWIG_IsOK(res1)) {
44721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
44722 }
44723 arg1 = reinterpret_cast< wxMenu * >(argp1);
44724 ecode2 = SWIG_AsVal_int(obj1, &val2);
44725 if (!SWIG_IsOK(ecode2)) {
44726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
44727 }
44728 arg2 = static_cast< int >(val2);
44729 {
44730 PyThreadState* __tstate = wxPyBeginAllowThreads();
44731 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
44732 wxPyEndAllowThreads(__tstate);
44733 if (PyErr_Occurred()) SWIG_fail;
44734 }
44735 {
44736 #if wxUSE_UNICODE
44737 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44738 #else
44739 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44740 #endif
44741 }
44742 return resultobj;
44743 fail:
44744 return NULL;
44745 }
44746
44747
44748 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44749 PyObject *resultobj = 0;
44750 wxMenu *arg1 = (wxMenu *) 0 ;
44751 wxString *arg2 = 0 ;
44752 void *argp1 = 0 ;
44753 int res1 = 0 ;
44754 bool temp2 = false ;
44755 PyObject * obj0 = 0 ;
44756 PyObject * obj1 = 0 ;
44757 char * kwnames[] = {
44758 (char *) "self",(char *) "title", NULL
44759 };
44760
44761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
44762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44763 if (!SWIG_IsOK(res1)) {
44764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
44765 }
44766 arg1 = reinterpret_cast< wxMenu * >(argp1);
44767 {
44768 arg2 = wxString_in_helper(obj1);
44769 if (arg2 == NULL) SWIG_fail;
44770 temp2 = true;
44771 }
44772 {
44773 PyThreadState* __tstate = wxPyBeginAllowThreads();
44774 (arg1)->SetTitle((wxString const &)*arg2);
44775 wxPyEndAllowThreads(__tstate);
44776 if (PyErr_Occurred()) SWIG_fail;
44777 }
44778 resultobj = SWIG_Py_Void();
44779 {
44780 if (temp2)
44781 delete arg2;
44782 }
44783 return resultobj;
44784 fail:
44785 {
44786 if (temp2)
44787 delete arg2;
44788 }
44789 return NULL;
44790 }
44791
44792
44793 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44794 PyObject *resultobj = 0;
44795 wxMenu *arg1 = (wxMenu *) 0 ;
44796 wxString result;
44797 void *argp1 = 0 ;
44798 int res1 = 0 ;
44799 PyObject *swig_obj[1] ;
44800
44801 if (!args) SWIG_fail;
44802 swig_obj[0] = args;
44803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44804 if (!SWIG_IsOK(res1)) {
44805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44806 }
44807 arg1 = reinterpret_cast< wxMenu * >(argp1);
44808 {
44809 PyThreadState* __tstate = wxPyBeginAllowThreads();
44810 result = ((wxMenu const *)arg1)->GetTitle();
44811 wxPyEndAllowThreads(__tstate);
44812 if (PyErr_Occurred()) SWIG_fail;
44813 }
44814 {
44815 #if wxUSE_UNICODE
44816 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44817 #else
44818 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44819 #endif
44820 }
44821 return resultobj;
44822 fail:
44823 return NULL;
44824 }
44825
44826
44827 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44828 PyObject *resultobj = 0;
44829 wxMenu *arg1 = (wxMenu *) 0 ;
44830 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
44831 void *argp1 = 0 ;
44832 int res1 = 0 ;
44833 void *argp2 = 0 ;
44834 int res2 = 0 ;
44835 PyObject * obj0 = 0 ;
44836 PyObject * obj1 = 0 ;
44837 char * kwnames[] = {
44838 (char *) "self",(char *) "handler", NULL
44839 };
44840
44841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
44842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44843 if (!SWIG_IsOK(res1)) {
44844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
44845 }
44846 arg1 = reinterpret_cast< wxMenu * >(argp1);
44847 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44848 if (!SWIG_IsOK(res2)) {
44849 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44850 }
44851 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44852 {
44853 PyThreadState* __tstate = wxPyBeginAllowThreads();
44854 (arg1)->SetEventHandler(arg2);
44855 wxPyEndAllowThreads(__tstate);
44856 if (PyErr_Occurred()) SWIG_fail;
44857 }
44858 resultobj = SWIG_Py_Void();
44859 return resultobj;
44860 fail:
44861 return NULL;
44862 }
44863
44864
44865 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44866 PyObject *resultobj = 0;
44867 wxMenu *arg1 = (wxMenu *) 0 ;
44868 wxEvtHandler *result = 0 ;
44869 void *argp1 = 0 ;
44870 int res1 = 0 ;
44871 PyObject *swig_obj[1] ;
44872
44873 if (!args) SWIG_fail;
44874 swig_obj[0] = args;
44875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44876 if (!SWIG_IsOK(res1)) {
44877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
44878 }
44879 arg1 = reinterpret_cast< wxMenu * >(argp1);
44880 {
44881 PyThreadState* __tstate = wxPyBeginAllowThreads();
44882 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
44883 wxPyEndAllowThreads(__tstate);
44884 if (PyErr_Occurred()) SWIG_fail;
44885 }
44886 {
44887 resultobj = wxPyMake_wxObject(result, 0);
44888 }
44889 return resultobj;
44890 fail:
44891 return NULL;
44892 }
44893
44894
44895 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44896 PyObject *resultobj = 0;
44897 wxMenu *arg1 = (wxMenu *) 0 ;
44898 wxWindow *arg2 = (wxWindow *) 0 ;
44899 void *argp1 = 0 ;
44900 int res1 = 0 ;
44901 void *argp2 = 0 ;
44902 int res2 = 0 ;
44903 PyObject * obj0 = 0 ;
44904 PyObject * obj1 = 0 ;
44905 char * kwnames[] = {
44906 (char *) "self",(char *) "win", NULL
44907 };
44908
44909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
44910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44911 if (!SWIG_IsOK(res1)) {
44912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
44913 }
44914 arg1 = reinterpret_cast< wxMenu * >(argp1);
44915 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44916 if (!SWIG_IsOK(res2)) {
44917 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
44918 }
44919 arg2 = reinterpret_cast< wxWindow * >(argp2);
44920 {
44921 PyThreadState* __tstate = wxPyBeginAllowThreads();
44922 (arg1)->SetInvokingWindow(arg2);
44923 wxPyEndAllowThreads(__tstate);
44924 if (PyErr_Occurred()) SWIG_fail;
44925 }
44926 resultobj = SWIG_Py_Void();
44927 return resultobj;
44928 fail:
44929 return NULL;
44930 }
44931
44932
44933 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44934 PyObject *resultobj = 0;
44935 wxMenu *arg1 = (wxMenu *) 0 ;
44936 wxWindow *result = 0 ;
44937 void *argp1 = 0 ;
44938 int res1 = 0 ;
44939 PyObject *swig_obj[1] ;
44940
44941 if (!args) SWIG_fail;
44942 swig_obj[0] = args;
44943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44944 if (!SWIG_IsOK(res1)) {
44945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
44946 }
44947 arg1 = reinterpret_cast< wxMenu * >(argp1);
44948 {
44949 PyThreadState* __tstate = wxPyBeginAllowThreads();
44950 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
44951 wxPyEndAllowThreads(__tstate);
44952 if (PyErr_Occurred()) SWIG_fail;
44953 }
44954 {
44955 resultobj = wxPyMake_wxObject(result, 0);
44956 }
44957 return resultobj;
44958 fail:
44959 return NULL;
44960 }
44961
44962
44963 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44964 PyObject *resultobj = 0;
44965 wxMenu *arg1 = (wxMenu *) 0 ;
44966 long result;
44967 void *argp1 = 0 ;
44968 int res1 = 0 ;
44969 PyObject *swig_obj[1] ;
44970
44971 if (!args) SWIG_fail;
44972 swig_obj[0] = args;
44973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44974 if (!SWIG_IsOK(res1)) {
44975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44976 }
44977 arg1 = reinterpret_cast< wxMenu * >(argp1);
44978 {
44979 PyThreadState* __tstate = wxPyBeginAllowThreads();
44980 result = (long)((wxMenu const *)arg1)->GetStyle();
44981 wxPyEndAllowThreads(__tstate);
44982 if (PyErr_Occurred()) SWIG_fail;
44983 }
44984 resultobj = SWIG_From_long(static_cast< long >(result));
44985 return resultobj;
44986 fail:
44987 return NULL;
44988 }
44989
44990
44991 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44992 PyObject *resultobj = 0;
44993 wxMenu *arg1 = (wxMenu *) 0 ;
44994 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
44995 void *argp1 = 0 ;
44996 int res1 = 0 ;
44997 void *argp2 = 0 ;
44998 int res2 = 0 ;
44999 PyObject * obj0 = 0 ;
45000 PyObject * obj1 = 0 ;
45001 char * kwnames[] = {
45002 (char *) "self",(char *) "source", NULL
45003 };
45004
45005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
45006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45007 if (!SWIG_IsOK(res1)) {
45008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
45009 }
45010 arg1 = reinterpret_cast< wxMenu * >(argp1);
45011 if (obj1) {
45012 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
45013 if (!SWIG_IsOK(res2)) {
45014 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
45015 }
45016 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
45017 }
45018 {
45019 PyThreadState* __tstate = wxPyBeginAllowThreads();
45020 (arg1)->UpdateUI(arg2);
45021 wxPyEndAllowThreads(__tstate);
45022 if (PyErr_Occurred()) SWIG_fail;
45023 }
45024 resultobj = SWIG_Py_Void();
45025 return resultobj;
45026 fail:
45027 return NULL;
45028 }
45029
45030
45031 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45032 PyObject *resultobj = 0;
45033 wxMenu *arg1 = (wxMenu *) 0 ;
45034 wxMenuBar *result = 0 ;
45035 void *argp1 = 0 ;
45036 int res1 = 0 ;
45037 PyObject *swig_obj[1] ;
45038
45039 if (!args) SWIG_fail;
45040 swig_obj[0] = args;
45041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45042 if (!SWIG_IsOK(res1)) {
45043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
45044 }
45045 arg1 = reinterpret_cast< wxMenu * >(argp1);
45046 {
45047 PyThreadState* __tstate = wxPyBeginAllowThreads();
45048 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
45049 wxPyEndAllowThreads(__tstate);
45050 if (PyErr_Occurred()) SWIG_fail;
45051 }
45052 {
45053 resultobj = wxPyMake_wxObject(result, (bool)0);
45054 }
45055 return resultobj;
45056 fail:
45057 return NULL;
45058 }
45059
45060
45061 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45062 PyObject *resultobj = 0;
45063 wxMenu *arg1 = (wxMenu *) 0 ;
45064 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
45065 void *argp1 = 0 ;
45066 int res1 = 0 ;
45067 void *argp2 = 0 ;
45068 int res2 = 0 ;
45069 PyObject * obj0 = 0 ;
45070 PyObject * obj1 = 0 ;
45071 char * kwnames[] = {
45072 (char *) "self",(char *) "menubar", NULL
45073 };
45074
45075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
45076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45077 if (!SWIG_IsOK(res1)) {
45078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
45079 }
45080 arg1 = reinterpret_cast< wxMenu * >(argp1);
45081 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
45082 if (!SWIG_IsOK(res2)) {
45083 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
45084 }
45085 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
45086 {
45087 PyThreadState* __tstate = wxPyBeginAllowThreads();
45088 (arg1)->Attach(arg2);
45089 wxPyEndAllowThreads(__tstate);
45090 if (PyErr_Occurred()) SWIG_fail;
45091 }
45092 resultobj = SWIG_Py_Void();
45093 return resultobj;
45094 fail:
45095 return NULL;
45096 }
45097
45098
45099 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45100 PyObject *resultobj = 0;
45101 wxMenu *arg1 = (wxMenu *) 0 ;
45102 void *argp1 = 0 ;
45103 int res1 = 0 ;
45104 PyObject *swig_obj[1] ;
45105
45106 if (!args) SWIG_fail;
45107 swig_obj[0] = args;
45108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45109 if (!SWIG_IsOK(res1)) {
45110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
45111 }
45112 arg1 = reinterpret_cast< wxMenu * >(argp1);
45113 {
45114 PyThreadState* __tstate = wxPyBeginAllowThreads();
45115 (arg1)->Detach();
45116 wxPyEndAllowThreads(__tstate);
45117 if (PyErr_Occurred()) SWIG_fail;
45118 }
45119 resultobj = SWIG_Py_Void();
45120 return resultobj;
45121 fail:
45122 return NULL;
45123 }
45124
45125
45126 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45127 PyObject *resultobj = 0;
45128 wxMenu *arg1 = (wxMenu *) 0 ;
45129 bool result;
45130 void *argp1 = 0 ;
45131 int res1 = 0 ;
45132 PyObject *swig_obj[1] ;
45133
45134 if (!args) SWIG_fail;
45135 swig_obj[0] = args;
45136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45137 if (!SWIG_IsOK(res1)) {
45138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
45139 }
45140 arg1 = reinterpret_cast< wxMenu * >(argp1);
45141 {
45142 PyThreadState* __tstate = wxPyBeginAllowThreads();
45143 result = (bool)((wxMenu const *)arg1)->IsAttached();
45144 wxPyEndAllowThreads(__tstate);
45145 if (PyErr_Occurred()) SWIG_fail;
45146 }
45147 {
45148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45149 }
45150 return resultobj;
45151 fail:
45152 return NULL;
45153 }
45154
45155
45156 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45157 PyObject *resultobj = 0;
45158 wxMenu *arg1 = (wxMenu *) 0 ;
45159 wxMenu *arg2 = (wxMenu *) 0 ;
45160 void *argp1 = 0 ;
45161 int res1 = 0 ;
45162 void *argp2 = 0 ;
45163 int res2 = 0 ;
45164 PyObject * obj0 = 0 ;
45165 PyObject * obj1 = 0 ;
45166 char * kwnames[] = {
45167 (char *) "self",(char *) "parent", NULL
45168 };
45169
45170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
45171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45172 if (!SWIG_IsOK(res1)) {
45173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
45174 }
45175 arg1 = reinterpret_cast< wxMenu * >(argp1);
45176 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
45177 if (!SWIG_IsOK(res2)) {
45178 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
45179 }
45180 arg2 = reinterpret_cast< wxMenu * >(argp2);
45181 {
45182 PyThreadState* __tstate = wxPyBeginAllowThreads();
45183 (arg1)->SetParent(arg2);
45184 wxPyEndAllowThreads(__tstate);
45185 if (PyErr_Occurred()) SWIG_fail;
45186 }
45187 resultobj = SWIG_Py_Void();
45188 return resultobj;
45189 fail:
45190 return NULL;
45191 }
45192
45193
45194 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45195 PyObject *resultobj = 0;
45196 wxMenu *arg1 = (wxMenu *) 0 ;
45197 wxMenu *result = 0 ;
45198 void *argp1 = 0 ;
45199 int res1 = 0 ;
45200 PyObject *swig_obj[1] ;
45201
45202 if (!args) SWIG_fail;
45203 swig_obj[0] = args;
45204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45205 if (!SWIG_IsOK(res1)) {
45206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
45207 }
45208 arg1 = reinterpret_cast< wxMenu * >(argp1);
45209 {
45210 PyThreadState* __tstate = wxPyBeginAllowThreads();
45211 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
45212 wxPyEndAllowThreads(__tstate);
45213 if (PyErr_Occurred()) SWIG_fail;
45214 }
45215 {
45216 resultobj = wxPyMake_wxObject(result, 0);
45217 }
45218 return resultobj;
45219 fail:
45220 return NULL;
45221 }
45222
45223
45224 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45225 PyObject *obj;
45226 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45227 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
45228 return SWIG_Py_Void();
45229 }
45230
45231 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45232 return SWIG_Python_InitShadowInstance(args);
45233 }
45234
45235 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45236 PyObject *resultobj = 0;
45237 long arg1 = (long) 0 ;
45238 wxMenuBar *result = 0 ;
45239 long val1 ;
45240 int ecode1 = 0 ;
45241 PyObject * obj0 = 0 ;
45242 char * kwnames[] = {
45243 (char *) "style", NULL
45244 };
45245
45246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
45247 if (obj0) {
45248 ecode1 = SWIG_AsVal_long(obj0, &val1);
45249 if (!SWIG_IsOK(ecode1)) {
45250 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
45251 }
45252 arg1 = static_cast< long >(val1);
45253 }
45254 {
45255 if (!wxPyCheckForApp()) SWIG_fail;
45256 PyThreadState* __tstate = wxPyBeginAllowThreads();
45257 result = (wxMenuBar *)new wxMenuBar(arg1);
45258 wxPyEndAllowThreads(__tstate);
45259 if (PyErr_Occurred()) SWIG_fail;
45260 }
45261 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
45262 return resultobj;
45263 fail:
45264 return NULL;
45265 }
45266
45267
45268 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45269 PyObject *resultobj = 0;
45270 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45271 wxMenu *arg2 = (wxMenu *) 0 ;
45272 wxString *arg3 = 0 ;
45273 bool result;
45274 void *argp1 = 0 ;
45275 int res1 = 0 ;
45276 void *argp2 = 0 ;
45277 int res2 = 0 ;
45278 bool temp3 = false ;
45279 PyObject * obj0 = 0 ;
45280 PyObject * obj1 = 0 ;
45281 PyObject * obj2 = 0 ;
45282 char * kwnames[] = {
45283 (char *) "self",(char *) "menu",(char *) "title", NULL
45284 };
45285
45286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45288 if (!SWIG_IsOK(res1)) {
45289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45290 }
45291 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45292 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
45293 if (!SWIG_IsOK(res2)) {
45294 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
45295 }
45296 arg2 = reinterpret_cast< wxMenu * >(argp2);
45297 {
45298 arg3 = wxString_in_helper(obj2);
45299 if (arg3 == NULL) SWIG_fail;
45300 temp3 = true;
45301 }
45302 {
45303 PyThreadState* __tstate = wxPyBeginAllowThreads();
45304 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
45305 wxPyEndAllowThreads(__tstate);
45306 if (PyErr_Occurred()) SWIG_fail;
45307 }
45308 {
45309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45310 }
45311 {
45312 if (temp3)
45313 delete arg3;
45314 }
45315 return resultobj;
45316 fail:
45317 {
45318 if (temp3)
45319 delete arg3;
45320 }
45321 return NULL;
45322 }
45323
45324
45325 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45326 PyObject *resultobj = 0;
45327 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45328 size_t arg2 ;
45329 wxMenu *arg3 = (wxMenu *) 0 ;
45330 wxString *arg4 = 0 ;
45331 bool result;
45332 void *argp1 = 0 ;
45333 int res1 = 0 ;
45334 size_t val2 ;
45335 int ecode2 = 0 ;
45336 void *argp3 = 0 ;
45337 int res3 = 0 ;
45338 bool temp4 = false ;
45339 PyObject * obj0 = 0 ;
45340 PyObject * obj1 = 0 ;
45341 PyObject * obj2 = 0 ;
45342 PyObject * obj3 = 0 ;
45343 char * kwnames[] = {
45344 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
45345 };
45346
45347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
45348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45349 if (!SWIG_IsOK(res1)) {
45350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45351 }
45352 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45353 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45354 if (!SWIG_IsOK(ecode2)) {
45355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
45356 }
45357 arg2 = static_cast< size_t >(val2);
45358 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
45359 if (!SWIG_IsOK(res3)) {
45360 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
45361 }
45362 arg3 = reinterpret_cast< wxMenu * >(argp3);
45363 {
45364 arg4 = wxString_in_helper(obj3);
45365 if (arg4 == NULL) SWIG_fail;
45366 temp4 = true;
45367 }
45368 {
45369 PyThreadState* __tstate = wxPyBeginAllowThreads();
45370 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
45371 wxPyEndAllowThreads(__tstate);
45372 if (PyErr_Occurred()) SWIG_fail;
45373 }
45374 {
45375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45376 }
45377 {
45378 if (temp4)
45379 delete arg4;
45380 }
45381 return resultobj;
45382 fail:
45383 {
45384 if (temp4)
45385 delete arg4;
45386 }
45387 return NULL;
45388 }
45389
45390
45391 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45392 PyObject *resultobj = 0;
45393 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45394 size_t result;
45395 void *argp1 = 0 ;
45396 int res1 = 0 ;
45397 PyObject *swig_obj[1] ;
45398
45399 if (!args) SWIG_fail;
45400 swig_obj[0] = args;
45401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45402 if (!SWIG_IsOK(res1)) {
45403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45404 }
45405 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45406 {
45407 PyThreadState* __tstate = wxPyBeginAllowThreads();
45408 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
45409 wxPyEndAllowThreads(__tstate);
45410 if (PyErr_Occurred()) SWIG_fail;
45411 }
45412 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
45413 return resultobj;
45414 fail:
45415 return NULL;
45416 }
45417
45418
45419 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45420 PyObject *resultobj = 0;
45421 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45422 size_t arg2 ;
45423 wxMenu *result = 0 ;
45424 void *argp1 = 0 ;
45425 int res1 = 0 ;
45426 size_t val2 ;
45427 int ecode2 = 0 ;
45428 PyObject * obj0 = 0 ;
45429 PyObject * obj1 = 0 ;
45430 char * kwnames[] = {
45431 (char *) "self",(char *) "pos", NULL
45432 };
45433
45434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45436 if (!SWIG_IsOK(res1)) {
45437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45438 }
45439 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45440 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45441 if (!SWIG_IsOK(ecode2)) {
45442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
45443 }
45444 arg2 = static_cast< size_t >(val2);
45445 {
45446 PyThreadState* __tstate = wxPyBeginAllowThreads();
45447 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
45448 wxPyEndAllowThreads(__tstate);
45449 if (PyErr_Occurred()) SWIG_fail;
45450 }
45451 {
45452 resultobj = wxPyMake_wxObject(result, 0);
45453 }
45454 return resultobj;
45455 fail:
45456 return NULL;
45457 }
45458
45459
45460 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45461 PyObject *resultobj = 0;
45462 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45463 size_t arg2 ;
45464 wxMenu *arg3 = (wxMenu *) 0 ;
45465 wxString *arg4 = 0 ;
45466 wxMenu *result = 0 ;
45467 void *argp1 = 0 ;
45468 int res1 = 0 ;
45469 size_t val2 ;
45470 int ecode2 = 0 ;
45471 void *argp3 = 0 ;
45472 int res3 = 0 ;
45473 bool temp4 = false ;
45474 PyObject * obj0 = 0 ;
45475 PyObject * obj1 = 0 ;
45476 PyObject * obj2 = 0 ;
45477 PyObject * obj3 = 0 ;
45478 char * kwnames[] = {
45479 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
45480 };
45481
45482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
45483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45484 if (!SWIG_IsOK(res1)) {
45485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45486 }
45487 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45488 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45489 if (!SWIG_IsOK(ecode2)) {
45490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
45491 }
45492 arg2 = static_cast< size_t >(val2);
45493 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
45494 if (!SWIG_IsOK(res3)) {
45495 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
45496 }
45497 arg3 = reinterpret_cast< wxMenu * >(argp3);
45498 {
45499 arg4 = wxString_in_helper(obj3);
45500 if (arg4 == NULL) SWIG_fail;
45501 temp4 = true;
45502 }
45503 {
45504 PyThreadState* __tstate = wxPyBeginAllowThreads();
45505 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
45506 wxPyEndAllowThreads(__tstate);
45507 if (PyErr_Occurred()) SWIG_fail;
45508 }
45509 {
45510 resultobj = wxPyMake_wxObject(result, 0);
45511 }
45512 {
45513 if (temp4)
45514 delete arg4;
45515 }
45516 return resultobj;
45517 fail:
45518 {
45519 if (temp4)
45520 delete arg4;
45521 }
45522 return NULL;
45523 }
45524
45525
45526 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45527 PyObject *resultobj = 0;
45528 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45529 size_t arg2 ;
45530 wxMenu *result = 0 ;
45531 void *argp1 = 0 ;
45532 int res1 = 0 ;
45533 size_t val2 ;
45534 int ecode2 = 0 ;
45535 PyObject * obj0 = 0 ;
45536 PyObject * obj1 = 0 ;
45537 char * kwnames[] = {
45538 (char *) "self",(char *) "pos", NULL
45539 };
45540
45541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
45542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45543 if (!SWIG_IsOK(res1)) {
45544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45545 }
45546 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45547 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45548 if (!SWIG_IsOK(ecode2)) {
45549 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
45550 }
45551 arg2 = static_cast< size_t >(val2);
45552 {
45553 PyThreadState* __tstate = wxPyBeginAllowThreads();
45554 result = (wxMenu *)(arg1)->Remove(arg2);
45555 wxPyEndAllowThreads(__tstate);
45556 if (PyErr_Occurred()) SWIG_fail;
45557 }
45558 {
45559 resultobj = wxPyMake_wxObject(result, 0);
45560 }
45561 return resultobj;
45562 fail:
45563 return NULL;
45564 }
45565
45566
45567 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45568 PyObject *resultobj = 0;
45569 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45570 size_t arg2 ;
45571 bool arg3 ;
45572 void *argp1 = 0 ;
45573 int res1 = 0 ;
45574 size_t val2 ;
45575 int ecode2 = 0 ;
45576 bool val3 ;
45577 int ecode3 = 0 ;
45578 PyObject * obj0 = 0 ;
45579 PyObject * obj1 = 0 ;
45580 PyObject * obj2 = 0 ;
45581 char * kwnames[] = {
45582 (char *) "self",(char *) "pos",(char *) "enable", NULL
45583 };
45584
45585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45587 if (!SWIG_IsOK(res1)) {
45588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45589 }
45590 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45591 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45592 if (!SWIG_IsOK(ecode2)) {
45593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
45594 }
45595 arg2 = static_cast< size_t >(val2);
45596 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45597 if (!SWIG_IsOK(ecode3)) {
45598 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
45599 }
45600 arg3 = static_cast< bool >(val3);
45601 {
45602 PyThreadState* __tstate = wxPyBeginAllowThreads();
45603 (arg1)->EnableTop(arg2,arg3);
45604 wxPyEndAllowThreads(__tstate);
45605 if (PyErr_Occurred()) SWIG_fail;
45606 }
45607 resultobj = SWIG_Py_Void();
45608 return resultobj;
45609 fail:
45610 return NULL;
45611 }
45612
45613
45614 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45615 PyObject *resultobj = 0;
45616 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45617 size_t arg2 ;
45618 bool result;
45619 void *argp1 = 0 ;
45620 int res1 = 0 ;
45621 size_t val2 ;
45622 int ecode2 = 0 ;
45623 PyObject * obj0 = 0 ;
45624 PyObject * obj1 = 0 ;
45625 char * kwnames[] = {
45626 (char *) "self",(char *) "pos", NULL
45627 };
45628
45629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
45630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45631 if (!SWIG_IsOK(res1)) {
45632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45633 }
45634 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45635 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45636 if (!SWIG_IsOK(ecode2)) {
45637 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
45638 }
45639 arg2 = static_cast< size_t >(val2);
45640 {
45641 PyThreadState* __tstate = wxPyBeginAllowThreads();
45642 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
45643 wxPyEndAllowThreads(__tstate);
45644 if (PyErr_Occurred()) SWIG_fail;
45645 }
45646 {
45647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45648 }
45649 return resultobj;
45650 fail:
45651 return NULL;
45652 }
45653
45654
45655 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45656 PyObject *resultobj = 0;
45657 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45658 size_t arg2 ;
45659 wxString *arg3 = 0 ;
45660 void *argp1 = 0 ;
45661 int res1 = 0 ;
45662 size_t val2 ;
45663 int ecode2 = 0 ;
45664 bool temp3 = false ;
45665 PyObject * obj0 = 0 ;
45666 PyObject * obj1 = 0 ;
45667 PyObject * obj2 = 0 ;
45668 char * kwnames[] = {
45669 (char *) "self",(char *) "pos",(char *) "label", NULL
45670 };
45671
45672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45674 if (!SWIG_IsOK(res1)) {
45675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45676 }
45677 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45678 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45679 if (!SWIG_IsOK(ecode2)) {
45680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
45681 }
45682 arg2 = static_cast< size_t >(val2);
45683 {
45684 arg3 = wxString_in_helper(obj2);
45685 if (arg3 == NULL) SWIG_fail;
45686 temp3 = true;
45687 }
45688 {
45689 PyThreadState* __tstate = wxPyBeginAllowThreads();
45690 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
45691 wxPyEndAllowThreads(__tstate);
45692 if (PyErr_Occurred()) SWIG_fail;
45693 }
45694 resultobj = SWIG_Py_Void();
45695 {
45696 if (temp3)
45697 delete arg3;
45698 }
45699 return resultobj;
45700 fail:
45701 {
45702 if (temp3)
45703 delete arg3;
45704 }
45705 return NULL;
45706 }
45707
45708
45709 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45710 PyObject *resultobj = 0;
45711 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45712 size_t arg2 ;
45713 wxString result;
45714 void *argp1 = 0 ;
45715 int res1 = 0 ;
45716 size_t val2 ;
45717 int ecode2 = 0 ;
45718 PyObject * obj0 = 0 ;
45719 PyObject * obj1 = 0 ;
45720 char * kwnames[] = {
45721 (char *) "self",(char *) "pos", NULL
45722 };
45723
45724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
45725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45726 if (!SWIG_IsOK(res1)) {
45727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45728 }
45729 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45730 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45731 if (!SWIG_IsOK(ecode2)) {
45732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
45733 }
45734 arg2 = static_cast< size_t >(val2);
45735 {
45736 PyThreadState* __tstate = wxPyBeginAllowThreads();
45737 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
45738 wxPyEndAllowThreads(__tstate);
45739 if (PyErr_Occurred()) SWIG_fail;
45740 }
45741 {
45742 #if wxUSE_UNICODE
45743 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45744 #else
45745 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45746 #endif
45747 }
45748 return resultobj;
45749 fail:
45750 return NULL;
45751 }
45752
45753
45754 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45755 PyObject *resultobj = 0;
45756 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45757 wxString *arg2 = 0 ;
45758 wxString *arg3 = 0 ;
45759 int result;
45760 void *argp1 = 0 ;
45761 int res1 = 0 ;
45762 bool temp2 = false ;
45763 bool temp3 = false ;
45764 PyObject * obj0 = 0 ;
45765 PyObject * obj1 = 0 ;
45766 PyObject * obj2 = 0 ;
45767 char * kwnames[] = {
45768 (char *) "self",(char *) "menu",(char *) "item", NULL
45769 };
45770
45771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45773 if (!SWIG_IsOK(res1)) {
45774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45775 }
45776 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45777 {
45778 arg2 = wxString_in_helper(obj1);
45779 if (arg2 == NULL) SWIG_fail;
45780 temp2 = true;
45781 }
45782 {
45783 arg3 = wxString_in_helper(obj2);
45784 if (arg3 == NULL) SWIG_fail;
45785 temp3 = true;
45786 }
45787 {
45788 PyThreadState* __tstate = wxPyBeginAllowThreads();
45789 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
45790 wxPyEndAllowThreads(__tstate);
45791 if (PyErr_Occurred()) SWIG_fail;
45792 }
45793 resultobj = SWIG_From_int(static_cast< int >(result));
45794 {
45795 if (temp2)
45796 delete arg2;
45797 }
45798 {
45799 if (temp3)
45800 delete arg3;
45801 }
45802 return resultobj;
45803 fail:
45804 {
45805 if (temp2)
45806 delete arg2;
45807 }
45808 {
45809 if (temp3)
45810 delete arg3;
45811 }
45812 return NULL;
45813 }
45814
45815
45816 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45817 PyObject *resultobj = 0;
45818 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45819 int arg2 ;
45820 wxMenuItem *result = 0 ;
45821 void *argp1 = 0 ;
45822 int res1 = 0 ;
45823 int val2 ;
45824 int ecode2 = 0 ;
45825 PyObject * obj0 = 0 ;
45826 PyObject * obj1 = 0 ;
45827 char * kwnames[] = {
45828 (char *) "self",(char *) "id", NULL
45829 };
45830
45831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
45832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45833 if (!SWIG_IsOK(res1)) {
45834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45835 }
45836 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45837 ecode2 = SWIG_AsVal_int(obj1, &val2);
45838 if (!SWIG_IsOK(ecode2)) {
45839 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
45840 }
45841 arg2 = static_cast< int >(val2);
45842 {
45843 PyThreadState* __tstate = wxPyBeginAllowThreads();
45844 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
45845 wxPyEndAllowThreads(__tstate);
45846 if (PyErr_Occurred()) SWIG_fail;
45847 }
45848 {
45849 resultobj = wxPyMake_wxObject(result, (bool)0);
45850 }
45851 return resultobj;
45852 fail:
45853 return NULL;
45854 }
45855
45856
45857 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45858 PyObject *resultobj = 0;
45859 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45860 wxString *arg2 = 0 ;
45861 int result;
45862 void *argp1 = 0 ;
45863 int res1 = 0 ;
45864 bool temp2 = false ;
45865 PyObject * obj0 = 0 ;
45866 PyObject * obj1 = 0 ;
45867 char * kwnames[] = {
45868 (char *) "self",(char *) "title", NULL
45869 };
45870
45871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45873 if (!SWIG_IsOK(res1)) {
45874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45875 }
45876 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45877 {
45878 arg2 = wxString_in_helper(obj1);
45879 if (arg2 == NULL) SWIG_fail;
45880 temp2 = true;
45881 }
45882 {
45883 PyThreadState* __tstate = wxPyBeginAllowThreads();
45884 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
45885 wxPyEndAllowThreads(__tstate);
45886 if (PyErr_Occurred()) SWIG_fail;
45887 }
45888 resultobj = SWIG_From_int(static_cast< int >(result));
45889 {
45890 if (temp2)
45891 delete arg2;
45892 }
45893 return resultobj;
45894 fail:
45895 {
45896 if (temp2)
45897 delete arg2;
45898 }
45899 return NULL;
45900 }
45901
45902
45903 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45904 PyObject *resultobj = 0;
45905 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45906 int arg2 ;
45907 bool arg3 ;
45908 void *argp1 = 0 ;
45909 int res1 = 0 ;
45910 int val2 ;
45911 int ecode2 = 0 ;
45912 bool val3 ;
45913 int ecode3 = 0 ;
45914 PyObject * obj0 = 0 ;
45915 PyObject * obj1 = 0 ;
45916 PyObject * obj2 = 0 ;
45917 char * kwnames[] = {
45918 (char *) "self",(char *) "id",(char *) "enable", NULL
45919 };
45920
45921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45923 if (!SWIG_IsOK(res1)) {
45924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45925 }
45926 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45927 ecode2 = SWIG_AsVal_int(obj1, &val2);
45928 if (!SWIG_IsOK(ecode2)) {
45929 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
45930 }
45931 arg2 = static_cast< int >(val2);
45932 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45933 if (!SWIG_IsOK(ecode3)) {
45934 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
45935 }
45936 arg3 = static_cast< bool >(val3);
45937 {
45938 PyThreadState* __tstate = wxPyBeginAllowThreads();
45939 (arg1)->Enable(arg2,arg3);
45940 wxPyEndAllowThreads(__tstate);
45941 if (PyErr_Occurred()) SWIG_fail;
45942 }
45943 resultobj = SWIG_Py_Void();
45944 return resultobj;
45945 fail:
45946 return NULL;
45947 }
45948
45949
45950 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45951 PyObject *resultobj = 0;
45952 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45953 int arg2 ;
45954 bool arg3 ;
45955 void *argp1 = 0 ;
45956 int res1 = 0 ;
45957 int val2 ;
45958 int ecode2 = 0 ;
45959 bool val3 ;
45960 int ecode3 = 0 ;
45961 PyObject * obj0 = 0 ;
45962 PyObject * obj1 = 0 ;
45963 PyObject * obj2 = 0 ;
45964 char * kwnames[] = {
45965 (char *) "self",(char *) "id",(char *) "check", NULL
45966 };
45967
45968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45970 if (!SWIG_IsOK(res1)) {
45971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45972 }
45973 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45974 ecode2 = SWIG_AsVal_int(obj1, &val2);
45975 if (!SWIG_IsOK(ecode2)) {
45976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
45977 }
45978 arg2 = static_cast< int >(val2);
45979 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45980 if (!SWIG_IsOK(ecode3)) {
45981 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
45982 }
45983 arg3 = static_cast< bool >(val3);
45984 {
45985 PyThreadState* __tstate = wxPyBeginAllowThreads();
45986 (arg1)->Check(arg2,arg3);
45987 wxPyEndAllowThreads(__tstate);
45988 if (PyErr_Occurred()) SWIG_fail;
45989 }
45990 resultobj = SWIG_Py_Void();
45991 return resultobj;
45992 fail:
45993 return NULL;
45994 }
45995
45996
45997 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45998 PyObject *resultobj = 0;
45999 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46000 int arg2 ;
46001 bool result;
46002 void *argp1 = 0 ;
46003 int res1 = 0 ;
46004 int val2 ;
46005 int ecode2 = 0 ;
46006 PyObject * obj0 = 0 ;
46007 PyObject * obj1 = 0 ;
46008 char * kwnames[] = {
46009 (char *) "self",(char *) "id", NULL
46010 };
46011
46012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
46013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46014 if (!SWIG_IsOK(res1)) {
46015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
46016 }
46017 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46018 ecode2 = SWIG_AsVal_int(obj1, &val2);
46019 if (!SWIG_IsOK(ecode2)) {
46020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
46021 }
46022 arg2 = static_cast< int >(val2);
46023 {
46024 PyThreadState* __tstate = wxPyBeginAllowThreads();
46025 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
46026 wxPyEndAllowThreads(__tstate);
46027 if (PyErr_Occurred()) SWIG_fail;
46028 }
46029 {
46030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46031 }
46032 return resultobj;
46033 fail:
46034 return NULL;
46035 }
46036
46037
46038 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(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_IsEnabled",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_IsEnabled" "', 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_IsEnabled" "', expected argument " "2"" of type '" "int""'");
46062 }
46063 arg2 = static_cast< int >(val2);
46064 {
46065 PyThreadState* __tstate = wxPyBeginAllowThreads();
46066 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(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_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46080 PyObject *resultobj = 0;
46081 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46082 int arg2 ;
46083 wxString *arg3 = 0 ;
46084 void *argp1 = 0 ;
46085 int res1 = 0 ;
46086 int val2 ;
46087 int ecode2 = 0 ;
46088 bool temp3 = false ;
46089 PyObject * obj0 = 0 ;
46090 PyObject * obj1 = 0 ;
46091 PyObject * obj2 = 0 ;
46092 char * kwnames[] = {
46093 (char *) "self",(char *) "id",(char *) "label", NULL
46094 };
46095
46096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46098 if (!SWIG_IsOK(res1)) {
46099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
46100 }
46101 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46102 ecode2 = SWIG_AsVal_int(obj1, &val2);
46103 if (!SWIG_IsOK(ecode2)) {
46104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
46105 }
46106 arg2 = static_cast< int >(val2);
46107 {
46108 arg3 = wxString_in_helper(obj2);
46109 if (arg3 == NULL) SWIG_fail;
46110 temp3 = true;
46111 }
46112 {
46113 PyThreadState* __tstate = wxPyBeginAllowThreads();
46114 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
46115 wxPyEndAllowThreads(__tstate);
46116 if (PyErr_Occurred()) SWIG_fail;
46117 }
46118 resultobj = SWIG_Py_Void();
46119 {
46120 if (temp3)
46121 delete arg3;
46122 }
46123 return resultobj;
46124 fail:
46125 {
46126 if (temp3)
46127 delete arg3;
46128 }
46129 return NULL;
46130 }
46131
46132
46133 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46134 PyObject *resultobj = 0;
46135 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46136 int arg2 ;
46137 wxString result;
46138 void *argp1 = 0 ;
46139 int res1 = 0 ;
46140 int val2 ;
46141 int ecode2 = 0 ;
46142 PyObject * obj0 = 0 ;
46143 PyObject * obj1 = 0 ;
46144 char * kwnames[] = {
46145 (char *) "self",(char *) "id", NULL
46146 };
46147
46148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
46149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46150 if (!SWIG_IsOK(res1)) {
46151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
46152 }
46153 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46154 ecode2 = SWIG_AsVal_int(obj1, &val2);
46155 if (!SWIG_IsOK(ecode2)) {
46156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
46157 }
46158 arg2 = static_cast< int >(val2);
46159 {
46160 PyThreadState* __tstate = wxPyBeginAllowThreads();
46161 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
46162 wxPyEndAllowThreads(__tstate);
46163 if (PyErr_Occurred()) SWIG_fail;
46164 }
46165 {
46166 #if wxUSE_UNICODE
46167 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46168 #else
46169 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46170 #endif
46171 }
46172 return resultobj;
46173 fail:
46174 return NULL;
46175 }
46176
46177
46178 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46179 PyObject *resultobj = 0;
46180 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46181 int arg2 ;
46182 wxString *arg3 = 0 ;
46183 void *argp1 = 0 ;
46184 int res1 = 0 ;
46185 int val2 ;
46186 int ecode2 = 0 ;
46187 bool temp3 = false ;
46188 PyObject * obj0 = 0 ;
46189 PyObject * obj1 = 0 ;
46190 PyObject * obj2 = 0 ;
46191 char * kwnames[] = {
46192 (char *) "self",(char *) "id",(char *) "helpString", NULL
46193 };
46194
46195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46197 if (!SWIG_IsOK(res1)) {
46198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
46199 }
46200 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46201 ecode2 = SWIG_AsVal_int(obj1, &val2);
46202 if (!SWIG_IsOK(ecode2)) {
46203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
46204 }
46205 arg2 = static_cast< int >(val2);
46206 {
46207 arg3 = wxString_in_helper(obj2);
46208 if (arg3 == NULL) SWIG_fail;
46209 temp3 = true;
46210 }
46211 {
46212 PyThreadState* __tstate = wxPyBeginAllowThreads();
46213 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
46214 wxPyEndAllowThreads(__tstate);
46215 if (PyErr_Occurred()) SWIG_fail;
46216 }
46217 resultobj = SWIG_Py_Void();
46218 {
46219 if (temp3)
46220 delete arg3;
46221 }
46222 return resultobj;
46223 fail:
46224 {
46225 if (temp3)
46226 delete arg3;
46227 }
46228 return NULL;
46229 }
46230
46231
46232 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46233 PyObject *resultobj = 0;
46234 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46235 int arg2 ;
46236 wxString result;
46237 void *argp1 = 0 ;
46238 int res1 = 0 ;
46239 int val2 ;
46240 int ecode2 = 0 ;
46241 PyObject * obj0 = 0 ;
46242 PyObject * obj1 = 0 ;
46243 char * kwnames[] = {
46244 (char *) "self",(char *) "id", NULL
46245 };
46246
46247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
46248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46249 if (!SWIG_IsOK(res1)) {
46250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
46251 }
46252 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46253 ecode2 = SWIG_AsVal_int(obj1, &val2);
46254 if (!SWIG_IsOK(ecode2)) {
46255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
46256 }
46257 arg2 = static_cast< int >(val2);
46258 {
46259 PyThreadState* __tstate = wxPyBeginAllowThreads();
46260 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
46261 wxPyEndAllowThreads(__tstate);
46262 if (PyErr_Occurred()) SWIG_fail;
46263 }
46264 {
46265 #if wxUSE_UNICODE
46266 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46267 #else
46268 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46269 #endif
46270 }
46271 return resultobj;
46272 fail:
46273 return NULL;
46274 }
46275
46276
46277 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46278 PyObject *resultobj = 0;
46279 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46280 wxFrame *result = 0 ;
46281 void *argp1 = 0 ;
46282 int res1 = 0 ;
46283 PyObject *swig_obj[1] ;
46284
46285 if (!args) SWIG_fail;
46286 swig_obj[0] = args;
46287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46288 if (!SWIG_IsOK(res1)) {
46289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
46290 }
46291 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46292 {
46293 PyThreadState* __tstate = wxPyBeginAllowThreads();
46294 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
46295 wxPyEndAllowThreads(__tstate);
46296 if (PyErr_Occurred()) SWIG_fail;
46297 }
46298 {
46299 resultobj = wxPyMake_wxObject(result, (bool)0);
46300 }
46301 return resultobj;
46302 fail:
46303 return NULL;
46304 }
46305
46306
46307 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46308 PyObject *resultobj = 0;
46309 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46310 bool result;
46311 void *argp1 = 0 ;
46312 int res1 = 0 ;
46313 PyObject *swig_obj[1] ;
46314
46315 if (!args) SWIG_fail;
46316 swig_obj[0] = args;
46317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46318 if (!SWIG_IsOK(res1)) {
46319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
46320 }
46321 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46322 {
46323 PyThreadState* __tstate = wxPyBeginAllowThreads();
46324 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
46325 wxPyEndAllowThreads(__tstate);
46326 if (PyErr_Occurred()) SWIG_fail;
46327 }
46328 {
46329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46330 }
46331 return resultobj;
46332 fail:
46333 return NULL;
46334 }
46335
46336
46337 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46338 PyObject *resultobj = 0;
46339 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46340 wxFrame *arg2 = (wxFrame *) 0 ;
46341 void *argp1 = 0 ;
46342 int res1 = 0 ;
46343 void *argp2 = 0 ;
46344 int res2 = 0 ;
46345 PyObject * obj0 = 0 ;
46346 PyObject * obj1 = 0 ;
46347 char * kwnames[] = {
46348 (char *) "self",(char *) "frame", NULL
46349 };
46350
46351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
46352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46353 if (!SWIG_IsOK(res1)) {
46354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
46355 }
46356 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46357 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
46358 if (!SWIG_IsOK(res2)) {
46359 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
46360 }
46361 arg2 = reinterpret_cast< wxFrame * >(argp2);
46362 {
46363 PyThreadState* __tstate = wxPyBeginAllowThreads();
46364 (arg1)->Attach(arg2);
46365 wxPyEndAllowThreads(__tstate);
46366 if (PyErr_Occurred()) SWIG_fail;
46367 }
46368 resultobj = SWIG_Py_Void();
46369 return resultobj;
46370 fail:
46371 return NULL;
46372 }
46373
46374
46375 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46376 PyObject *resultobj = 0;
46377 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46378 void *argp1 = 0 ;
46379 int res1 = 0 ;
46380 PyObject *swig_obj[1] ;
46381
46382 if (!args) SWIG_fail;
46383 swig_obj[0] = args;
46384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46385 if (!SWIG_IsOK(res1)) {
46386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
46387 }
46388 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46389 {
46390 PyThreadState* __tstate = wxPyBeginAllowThreads();
46391 (arg1)->Detach();
46392 wxPyEndAllowThreads(__tstate);
46393 if (PyErr_Occurred()) SWIG_fail;
46394 }
46395 resultobj = SWIG_Py_Void();
46396 return resultobj;
46397 fail:
46398 return NULL;
46399 }
46400
46401
46402 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46403 PyObject *resultobj = 0;
46404 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46405 void *argp1 = 0 ;
46406 int res1 = 0 ;
46407 PyObject *swig_obj[1] ;
46408
46409 if (!args) SWIG_fail;
46410 swig_obj[0] = args;
46411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46412 if (!SWIG_IsOK(res1)) {
46413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
46414 }
46415 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46416 {
46417 PyThreadState* __tstate = wxPyBeginAllowThreads();
46418 (arg1)->UpdateMenus();
46419 wxPyEndAllowThreads(__tstate);
46420 if (PyErr_Occurred()) SWIG_fail;
46421 }
46422 resultobj = SWIG_Py_Void();
46423 return resultobj;
46424 fail:
46425 return NULL;
46426 }
46427
46428
46429 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46430 PyObject *resultobj = 0;
46431 bool arg1 ;
46432 bool val1 ;
46433 int ecode1 = 0 ;
46434 PyObject * obj0 = 0 ;
46435 char * kwnames[] = {
46436 (char *) "enable", NULL
46437 };
46438
46439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
46440 ecode1 = SWIG_AsVal_bool(obj0, &val1);
46441 if (!SWIG_IsOK(ecode1)) {
46442 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
46443 }
46444 arg1 = static_cast< bool >(val1);
46445 {
46446 PyThreadState* __tstate = wxPyBeginAllowThreads();
46447 wxMenuBar::SetAutoWindowMenu(arg1);
46448 wxPyEndAllowThreads(__tstate);
46449 if (PyErr_Occurred()) SWIG_fail;
46450 }
46451 resultobj = SWIG_Py_Void();
46452 return resultobj;
46453 fail:
46454 return NULL;
46455 }
46456
46457
46458 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46459 PyObject *resultobj = 0;
46460 bool result;
46461
46462 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
46463 {
46464 PyThreadState* __tstate = wxPyBeginAllowThreads();
46465 result = (bool)wxMenuBar::GetAutoWindowMenu();
46466 wxPyEndAllowThreads(__tstate);
46467 if (PyErr_Occurred()) SWIG_fail;
46468 }
46469 {
46470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46471 }
46472 return resultobj;
46473 fail:
46474 return NULL;
46475 }
46476
46477
46478 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46479 PyObject *obj;
46480 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46481 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
46482 return SWIG_Py_Void();
46483 }
46484
46485 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46486 return SWIG_Python_InitShadowInstance(args);
46487 }
46488
46489 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46490 PyObject *resultobj = 0;
46491 wxMenu *arg1 = (wxMenu *) NULL ;
46492 int arg2 = (int) wxID_SEPARATOR ;
46493 wxString const &arg3_defvalue = wxPyEmptyString ;
46494 wxString *arg3 = (wxString *) &arg3_defvalue ;
46495 wxString const &arg4_defvalue = wxPyEmptyString ;
46496 wxString *arg4 = (wxString *) &arg4_defvalue ;
46497 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
46498 wxMenu *arg6 = (wxMenu *) NULL ;
46499 wxMenuItem *result = 0 ;
46500 void *argp1 = 0 ;
46501 int res1 = 0 ;
46502 int val2 ;
46503 int ecode2 = 0 ;
46504 bool temp3 = false ;
46505 bool temp4 = false ;
46506 int val5 ;
46507 int ecode5 = 0 ;
46508 void *argp6 = 0 ;
46509 int res6 = 0 ;
46510 PyObject * obj0 = 0 ;
46511 PyObject * obj1 = 0 ;
46512 PyObject * obj2 = 0 ;
46513 PyObject * obj3 = 0 ;
46514 PyObject * obj4 = 0 ;
46515 PyObject * obj5 = 0 ;
46516 char * kwnames[] = {
46517 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
46518 };
46519
46520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46521 if (obj0) {
46522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
46523 if (!SWIG_IsOK(res1)) {
46524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
46525 }
46526 arg1 = reinterpret_cast< wxMenu * >(argp1);
46527 }
46528 if (obj1) {
46529 ecode2 = SWIG_AsVal_int(obj1, &val2);
46530 if (!SWIG_IsOK(ecode2)) {
46531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
46532 }
46533 arg2 = static_cast< int >(val2);
46534 }
46535 if (obj2) {
46536 {
46537 arg3 = wxString_in_helper(obj2);
46538 if (arg3 == NULL) SWIG_fail;
46539 temp3 = true;
46540 }
46541 }
46542 if (obj3) {
46543 {
46544 arg4 = wxString_in_helper(obj3);
46545 if (arg4 == NULL) SWIG_fail;
46546 temp4 = true;
46547 }
46548 }
46549 if (obj4) {
46550 ecode5 = SWIG_AsVal_int(obj4, &val5);
46551 if (!SWIG_IsOK(ecode5)) {
46552 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
46553 }
46554 arg5 = static_cast< wxItemKind >(val5);
46555 }
46556 if (obj5) {
46557 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
46558 if (!SWIG_IsOK(res6)) {
46559 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
46560 }
46561 arg6 = reinterpret_cast< wxMenu * >(argp6);
46562 }
46563 {
46564 PyThreadState* __tstate = wxPyBeginAllowThreads();
46565 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
46566 wxPyEndAllowThreads(__tstate);
46567 if (PyErr_Occurred()) SWIG_fail;
46568 }
46569 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_NEW | 0 );
46570 {
46571 if (temp3)
46572 delete arg3;
46573 }
46574 {
46575 if (temp4)
46576 delete arg4;
46577 }
46578 return resultobj;
46579 fail:
46580 {
46581 if (temp3)
46582 delete arg3;
46583 }
46584 {
46585 if (temp4)
46586 delete arg4;
46587 }
46588 return NULL;
46589 }
46590
46591
46592 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46593 PyObject *resultobj = 0;
46594 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46595 void *argp1 = 0 ;
46596 int res1 = 0 ;
46597 PyObject *swig_obj[1] ;
46598
46599 if (!args) SWIG_fail;
46600 swig_obj[0] = args;
46601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
46602 if (!SWIG_IsOK(res1)) {
46603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46604 }
46605 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46606 {
46607 PyThreadState* __tstate = wxPyBeginAllowThreads();
46608 delete arg1;
46609
46610 wxPyEndAllowThreads(__tstate);
46611 if (PyErr_Occurred()) SWIG_fail;
46612 }
46613 resultobj = SWIG_Py_Void();
46614 return resultobj;
46615 fail:
46616 return NULL;
46617 }
46618
46619
46620 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46621 PyObject *resultobj = 0;
46622 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46623 wxMenu *result = 0 ;
46624 void *argp1 = 0 ;
46625 int res1 = 0 ;
46626 PyObject *swig_obj[1] ;
46627
46628 if (!args) SWIG_fail;
46629 swig_obj[0] = args;
46630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46631 if (!SWIG_IsOK(res1)) {
46632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46633 }
46634 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46635 {
46636 PyThreadState* __tstate = wxPyBeginAllowThreads();
46637 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
46638 wxPyEndAllowThreads(__tstate);
46639 if (PyErr_Occurred()) SWIG_fail;
46640 }
46641 {
46642 resultobj = wxPyMake_wxObject(result, 0);
46643 }
46644 return resultobj;
46645 fail:
46646 return NULL;
46647 }
46648
46649
46650 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46651 PyObject *resultobj = 0;
46652 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46653 wxMenu *arg2 = (wxMenu *) 0 ;
46654 void *argp1 = 0 ;
46655 int res1 = 0 ;
46656 void *argp2 = 0 ;
46657 int res2 = 0 ;
46658 PyObject * obj0 = 0 ;
46659 PyObject * obj1 = 0 ;
46660 char * kwnames[] = {
46661 (char *) "self",(char *) "menu", NULL
46662 };
46663
46664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
46665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46666 if (!SWIG_IsOK(res1)) {
46667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46668 }
46669 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46670 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
46671 if (!SWIG_IsOK(res2)) {
46672 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
46673 }
46674 arg2 = reinterpret_cast< wxMenu * >(argp2);
46675 {
46676 PyThreadState* __tstate = wxPyBeginAllowThreads();
46677 (arg1)->SetMenu(arg2);
46678 wxPyEndAllowThreads(__tstate);
46679 if (PyErr_Occurred()) SWIG_fail;
46680 }
46681 resultobj = SWIG_Py_Void();
46682 return resultobj;
46683 fail:
46684 return NULL;
46685 }
46686
46687
46688 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46689 PyObject *resultobj = 0;
46690 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46691 int arg2 ;
46692 void *argp1 = 0 ;
46693 int res1 = 0 ;
46694 int val2 ;
46695 int ecode2 = 0 ;
46696 PyObject * obj0 = 0 ;
46697 PyObject * obj1 = 0 ;
46698 char * kwnames[] = {
46699 (char *) "self",(char *) "id", NULL
46700 };
46701
46702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
46703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46704 if (!SWIG_IsOK(res1)) {
46705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46706 }
46707 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46708 ecode2 = SWIG_AsVal_int(obj1, &val2);
46709 if (!SWIG_IsOK(ecode2)) {
46710 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
46711 }
46712 arg2 = static_cast< int >(val2);
46713 {
46714 PyThreadState* __tstate = wxPyBeginAllowThreads();
46715 (arg1)->SetId(arg2);
46716 wxPyEndAllowThreads(__tstate);
46717 if (PyErr_Occurred()) SWIG_fail;
46718 }
46719 resultobj = SWIG_Py_Void();
46720 return resultobj;
46721 fail:
46722 return NULL;
46723 }
46724
46725
46726 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46727 PyObject *resultobj = 0;
46728 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46729 int result;
46730 void *argp1 = 0 ;
46731 int res1 = 0 ;
46732 PyObject *swig_obj[1] ;
46733
46734 if (!args) SWIG_fail;
46735 swig_obj[0] = args;
46736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46737 if (!SWIG_IsOK(res1)) {
46738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46739 }
46740 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46741 {
46742 PyThreadState* __tstate = wxPyBeginAllowThreads();
46743 result = (int)((wxMenuItem const *)arg1)->GetId();
46744 wxPyEndAllowThreads(__tstate);
46745 if (PyErr_Occurred()) SWIG_fail;
46746 }
46747 resultobj = SWIG_From_int(static_cast< int >(result));
46748 return resultobj;
46749 fail:
46750 return NULL;
46751 }
46752
46753
46754 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46755 PyObject *resultobj = 0;
46756 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46757 bool result;
46758 void *argp1 = 0 ;
46759 int res1 = 0 ;
46760 PyObject *swig_obj[1] ;
46761
46762 if (!args) SWIG_fail;
46763 swig_obj[0] = args;
46764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46765 if (!SWIG_IsOK(res1)) {
46766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46767 }
46768 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46769 {
46770 PyThreadState* __tstate = wxPyBeginAllowThreads();
46771 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
46772 wxPyEndAllowThreads(__tstate);
46773 if (PyErr_Occurred()) SWIG_fail;
46774 }
46775 {
46776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46777 }
46778 return resultobj;
46779 fail:
46780 return NULL;
46781 }
46782
46783
46784 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46785 PyObject *resultobj = 0;
46786 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46787 wxString *arg2 = 0 ;
46788 void *argp1 = 0 ;
46789 int res1 = 0 ;
46790 bool temp2 = false ;
46791 PyObject * obj0 = 0 ;
46792 PyObject * obj1 = 0 ;
46793 char * kwnames[] = {
46794 (char *) "self",(char *) "str", NULL
46795 };
46796
46797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
46798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46799 if (!SWIG_IsOK(res1)) {
46800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46801 }
46802 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46803 {
46804 arg2 = wxString_in_helper(obj1);
46805 if (arg2 == NULL) SWIG_fail;
46806 temp2 = true;
46807 }
46808 {
46809 PyThreadState* __tstate = wxPyBeginAllowThreads();
46810 (arg1)->SetText((wxString const &)*arg2);
46811 wxPyEndAllowThreads(__tstate);
46812 if (PyErr_Occurred()) SWIG_fail;
46813 }
46814 resultobj = SWIG_Py_Void();
46815 {
46816 if (temp2)
46817 delete arg2;
46818 }
46819 return resultobj;
46820 fail:
46821 {
46822 if (temp2)
46823 delete arg2;
46824 }
46825 return NULL;
46826 }
46827
46828
46829 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46830 PyObject *resultobj = 0;
46831 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46832 wxString result;
46833 void *argp1 = 0 ;
46834 int res1 = 0 ;
46835 PyObject *swig_obj[1] ;
46836
46837 if (!args) SWIG_fail;
46838 swig_obj[0] = args;
46839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46840 if (!SWIG_IsOK(res1)) {
46841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46842 }
46843 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46844 {
46845 PyThreadState* __tstate = wxPyBeginAllowThreads();
46846 result = ((wxMenuItem const *)arg1)->GetLabel();
46847 wxPyEndAllowThreads(__tstate);
46848 if (PyErr_Occurred()) SWIG_fail;
46849 }
46850 {
46851 #if wxUSE_UNICODE
46852 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46853 #else
46854 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46855 #endif
46856 }
46857 return resultobj;
46858 fail:
46859 return NULL;
46860 }
46861
46862
46863 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46864 PyObject *resultobj = 0;
46865 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46866 wxString *result = 0 ;
46867 void *argp1 = 0 ;
46868 int res1 = 0 ;
46869 PyObject *swig_obj[1] ;
46870
46871 if (!args) SWIG_fail;
46872 swig_obj[0] = args;
46873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46874 if (!SWIG_IsOK(res1)) {
46875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46876 }
46877 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46878 {
46879 PyThreadState* __tstate = wxPyBeginAllowThreads();
46880 {
46881 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
46882 result = (wxString *) &_result_ref;
46883 }
46884 wxPyEndAllowThreads(__tstate);
46885 if (PyErr_Occurred()) SWIG_fail;
46886 }
46887 {
46888 #if wxUSE_UNICODE
46889 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46890 #else
46891 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46892 #endif
46893 }
46894 return resultobj;
46895 fail:
46896 return NULL;
46897 }
46898
46899
46900 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46901 PyObject *resultobj = 0;
46902 wxString *arg1 = 0 ;
46903 wxString result;
46904 bool temp1 = false ;
46905 PyObject * obj0 = 0 ;
46906 char * kwnames[] = {
46907 (char *) "text", NULL
46908 };
46909
46910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
46911 {
46912 arg1 = wxString_in_helper(obj0);
46913 if (arg1 == NULL) SWIG_fail;
46914 temp1 = true;
46915 }
46916 {
46917 PyThreadState* __tstate = wxPyBeginAllowThreads();
46918 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
46919 wxPyEndAllowThreads(__tstate);
46920 if (PyErr_Occurred()) SWIG_fail;
46921 }
46922 {
46923 #if wxUSE_UNICODE
46924 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46925 #else
46926 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46927 #endif
46928 }
46929 {
46930 if (temp1)
46931 delete arg1;
46932 }
46933 return resultobj;
46934 fail:
46935 {
46936 if (temp1)
46937 delete arg1;
46938 }
46939 return NULL;
46940 }
46941
46942
46943 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46944 PyObject *resultobj = 0;
46945 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46946 wxItemKind result;
46947 void *argp1 = 0 ;
46948 int res1 = 0 ;
46949 PyObject *swig_obj[1] ;
46950
46951 if (!args) SWIG_fail;
46952 swig_obj[0] = args;
46953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46954 if (!SWIG_IsOK(res1)) {
46955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46956 }
46957 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46958 {
46959 PyThreadState* __tstate = wxPyBeginAllowThreads();
46960 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
46961 wxPyEndAllowThreads(__tstate);
46962 if (PyErr_Occurred()) SWIG_fail;
46963 }
46964 resultobj = SWIG_From_int(static_cast< int >(result));
46965 return resultobj;
46966 fail:
46967 return NULL;
46968 }
46969
46970
46971 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46972 PyObject *resultobj = 0;
46973 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46974 wxItemKind arg2 ;
46975 void *argp1 = 0 ;
46976 int res1 = 0 ;
46977 int val2 ;
46978 int ecode2 = 0 ;
46979 PyObject * obj0 = 0 ;
46980 PyObject * obj1 = 0 ;
46981 char * kwnames[] = {
46982 (char *) "self",(char *) "kind", NULL
46983 };
46984
46985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
46986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46987 if (!SWIG_IsOK(res1)) {
46988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46989 }
46990 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46991 ecode2 = SWIG_AsVal_int(obj1, &val2);
46992 if (!SWIG_IsOK(ecode2)) {
46993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
46994 }
46995 arg2 = static_cast< wxItemKind >(val2);
46996 {
46997 PyThreadState* __tstate = wxPyBeginAllowThreads();
46998 (arg1)->SetKind(arg2);
46999 wxPyEndAllowThreads(__tstate);
47000 if (PyErr_Occurred()) SWIG_fail;
47001 }
47002 resultobj = SWIG_Py_Void();
47003 return resultobj;
47004 fail:
47005 return NULL;
47006 }
47007
47008
47009 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47010 PyObject *resultobj = 0;
47011 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47012 bool arg2 ;
47013 void *argp1 = 0 ;
47014 int res1 = 0 ;
47015 bool val2 ;
47016 int ecode2 = 0 ;
47017 PyObject * obj0 = 0 ;
47018 PyObject * obj1 = 0 ;
47019 char * kwnames[] = {
47020 (char *) "self",(char *) "checkable", NULL
47021 };
47022
47023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
47024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47025 if (!SWIG_IsOK(res1)) {
47026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47027 }
47028 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47029 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47030 if (!SWIG_IsOK(ecode2)) {
47031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
47032 }
47033 arg2 = static_cast< bool >(val2);
47034 {
47035 PyThreadState* __tstate = wxPyBeginAllowThreads();
47036 (arg1)->SetCheckable(arg2);
47037 wxPyEndAllowThreads(__tstate);
47038 if (PyErr_Occurred()) SWIG_fail;
47039 }
47040 resultobj = SWIG_Py_Void();
47041 return resultobj;
47042 fail:
47043 return NULL;
47044 }
47045
47046
47047 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47048 PyObject *resultobj = 0;
47049 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47050 bool result;
47051 void *argp1 = 0 ;
47052 int res1 = 0 ;
47053 PyObject *swig_obj[1] ;
47054
47055 if (!args) SWIG_fail;
47056 swig_obj[0] = args;
47057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47058 if (!SWIG_IsOK(res1)) {
47059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47060 }
47061 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47062 {
47063 PyThreadState* __tstate = wxPyBeginAllowThreads();
47064 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
47065 wxPyEndAllowThreads(__tstate);
47066 if (PyErr_Occurred()) SWIG_fail;
47067 }
47068 {
47069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47070 }
47071 return resultobj;
47072 fail:
47073 return NULL;
47074 }
47075
47076
47077 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47078 PyObject *resultobj = 0;
47079 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47080 bool result;
47081 void *argp1 = 0 ;
47082 int res1 = 0 ;
47083 PyObject *swig_obj[1] ;
47084
47085 if (!args) SWIG_fail;
47086 swig_obj[0] = args;
47087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47088 if (!SWIG_IsOK(res1)) {
47089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47090 }
47091 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47092 {
47093 PyThreadState* __tstate = wxPyBeginAllowThreads();
47094 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
47095 wxPyEndAllowThreads(__tstate);
47096 if (PyErr_Occurred()) SWIG_fail;
47097 }
47098 {
47099 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47100 }
47101 return resultobj;
47102 fail:
47103 return NULL;
47104 }
47105
47106
47107 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47108 PyObject *resultobj = 0;
47109 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47110 wxMenu *arg2 = (wxMenu *) 0 ;
47111 void *argp1 = 0 ;
47112 int res1 = 0 ;
47113 void *argp2 = 0 ;
47114 int res2 = 0 ;
47115 PyObject * obj0 = 0 ;
47116 PyObject * obj1 = 0 ;
47117 char * kwnames[] = {
47118 (char *) "self",(char *) "menu", NULL
47119 };
47120
47121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
47122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47123 if (!SWIG_IsOK(res1)) {
47124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47125 }
47126 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47127 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
47128 if (!SWIG_IsOK(res2)) {
47129 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
47130 }
47131 arg2 = reinterpret_cast< wxMenu * >(argp2);
47132 {
47133 PyThreadState* __tstate = wxPyBeginAllowThreads();
47134 (arg1)->SetSubMenu(arg2);
47135 wxPyEndAllowThreads(__tstate);
47136 if (PyErr_Occurred()) SWIG_fail;
47137 }
47138 resultobj = SWIG_Py_Void();
47139 return resultobj;
47140 fail:
47141 return NULL;
47142 }
47143
47144
47145 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47146 PyObject *resultobj = 0;
47147 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47148 wxMenu *result = 0 ;
47149 void *argp1 = 0 ;
47150 int res1 = 0 ;
47151 PyObject *swig_obj[1] ;
47152
47153 if (!args) SWIG_fail;
47154 swig_obj[0] = args;
47155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47156 if (!SWIG_IsOK(res1)) {
47157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47158 }
47159 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47160 {
47161 PyThreadState* __tstate = wxPyBeginAllowThreads();
47162 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
47163 wxPyEndAllowThreads(__tstate);
47164 if (PyErr_Occurred()) SWIG_fail;
47165 }
47166 {
47167 resultobj = wxPyMake_wxObject(result, 0);
47168 }
47169 return resultobj;
47170 fail:
47171 return NULL;
47172 }
47173
47174
47175 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47176 PyObject *resultobj = 0;
47177 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47178 bool arg2 = (bool) true ;
47179 void *argp1 = 0 ;
47180 int res1 = 0 ;
47181 bool val2 ;
47182 int ecode2 = 0 ;
47183 PyObject * obj0 = 0 ;
47184 PyObject * obj1 = 0 ;
47185 char * kwnames[] = {
47186 (char *) "self",(char *) "enable", NULL
47187 };
47188
47189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
47190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47191 if (!SWIG_IsOK(res1)) {
47192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47193 }
47194 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47195 if (obj1) {
47196 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47197 if (!SWIG_IsOK(ecode2)) {
47198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
47199 }
47200 arg2 = static_cast< bool >(val2);
47201 }
47202 {
47203 PyThreadState* __tstate = wxPyBeginAllowThreads();
47204 (arg1)->Enable(arg2);
47205 wxPyEndAllowThreads(__tstate);
47206 if (PyErr_Occurred()) SWIG_fail;
47207 }
47208 resultobj = SWIG_Py_Void();
47209 return resultobj;
47210 fail:
47211 return NULL;
47212 }
47213
47214
47215 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47216 PyObject *resultobj = 0;
47217 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47218 bool result;
47219 void *argp1 = 0 ;
47220 int res1 = 0 ;
47221 PyObject *swig_obj[1] ;
47222
47223 if (!args) SWIG_fail;
47224 swig_obj[0] = args;
47225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47226 if (!SWIG_IsOK(res1)) {
47227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47228 }
47229 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47230 {
47231 PyThreadState* __tstate = wxPyBeginAllowThreads();
47232 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
47233 wxPyEndAllowThreads(__tstate);
47234 if (PyErr_Occurred()) SWIG_fail;
47235 }
47236 {
47237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47238 }
47239 return resultobj;
47240 fail:
47241 return NULL;
47242 }
47243
47244
47245 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47246 PyObject *resultobj = 0;
47247 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47248 bool arg2 = (bool) true ;
47249 void *argp1 = 0 ;
47250 int res1 = 0 ;
47251 bool val2 ;
47252 int ecode2 = 0 ;
47253 PyObject * obj0 = 0 ;
47254 PyObject * obj1 = 0 ;
47255 char * kwnames[] = {
47256 (char *) "self",(char *) "check", NULL
47257 };
47258
47259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
47260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47261 if (!SWIG_IsOK(res1)) {
47262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47263 }
47264 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47265 if (obj1) {
47266 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47267 if (!SWIG_IsOK(ecode2)) {
47268 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
47269 }
47270 arg2 = static_cast< bool >(val2);
47271 }
47272 {
47273 PyThreadState* __tstate = wxPyBeginAllowThreads();
47274 (arg1)->Check(arg2);
47275 wxPyEndAllowThreads(__tstate);
47276 if (PyErr_Occurred()) SWIG_fail;
47277 }
47278 resultobj = SWIG_Py_Void();
47279 return resultobj;
47280 fail:
47281 return NULL;
47282 }
47283
47284
47285 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47286 PyObject *resultobj = 0;
47287 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47288 bool result;
47289 void *argp1 = 0 ;
47290 int res1 = 0 ;
47291 PyObject *swig_obj[1] ;
47292
47293 if (!args) SWIG_fail;
47294 swig_obj[0] = args;
47295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47296 if (!SWIG_IsOK(res1)) {
47297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47298 }
47299 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47300 {
47301 PyThreadState* __tstate = wxPyBeginAllowThreads();
47302 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
47303 wxPyEndAllowThreads(__tstate);
47304 if (PyErr_Occurred()) SWIG_fail;
47305 }
47306 {
47307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47308 }
47309 return resultobj;
47310 fail:
47311 return NULL;
47312 }
47313
47314
47315 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47316 PyObject *resultobj = 0;
47317 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47318 void *argp1 = 0 ;
47319 int res1 = 0 ;
47320 PyObject *swig_obj[1] ;
47321
47322 if (!args) SWIG_fail;
47323 swig_obj[0] = args;
47324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47325 if (!SWIG_IsOK(res1)) {
47326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47327 }
47328 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47329 {
47330 PyThreadState* __tstate = wxPyBeginAllowThreads();
47331 (arg1)->Toggle();
47332 wxPyEndAllowThreads(__tstate);
47333 if (PyErr_Occurred()) SWIG_fail;
47334 }
47335 resultobj = SWIG_Py_Void();
47336 return resultobj;
47337 fail:
47338 return NULL;
47339 }
47340
47341
47342 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47343 PyObject *resultobj = 0;
47344 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47345 wxString *arg2 = 0 ;
47346 void *argp1 = 0 ;
47347 int res1 = 0 ;
47348 bool temp2 = false ;
47349 PyObject * obj0 = 0 ;
47350 PyObject * obj1 = 0 ;
47351 char * kwnames[] = {
47352 (char *) "self",(char *) "str", NULL
47353 };
47354
47355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
47356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47357 if (!SWIG_IsOK(res1)) {
47358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47359 }
47360 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47361 {
47362 arg2 = wxString_in_helper(obj1);
47363 if (arg2 == NULL) SWIG_fail;
47364 temp2 = true;
47365 }
47366 {
47367 PyThreadState* __tstate = wxPyBeginAllowThreads();
47368 (arg1)->SetHelp((wxString const &)*arg2);
47369 wxPyEndAllowThreads(__tstate);
47370 if (PyErr_Occurred()) SWIG_fail;
47371 }
47372 resultobj = SWIG_Py_Void();
47373 {
47374 if (temp2)
47375 delete arg2;
47376 }
47377 return resultobj;
47378 fail:
47379 {
47380 if (temp2)
47381 delete arg2;
47382 }
47383 return NULL;
47384 }
47385
47386
47387 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47388 PyObject *resultobj = 0;
47389 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47390 wxString *result = 0 ;
47391 void *argp1 = 0 ;
47392 int res1 = 0 ;
47393 PyObject *swig_obj[1] ;
47394
47395 if (!args) SWIG_fail;
47396 swig_obj[0] = args;
47397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47398 if (!SWIG_IsOK(res1)) {
47399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47400 }
47401 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47402 {
47403 PyThreadState* __tstate = wxPyBeginAllowThreads();
47404 {
47405 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
47406 result = (wxString *) &_result_ref;
47407 }
47408 wxPyEndAllowThreads(__tstate);
47409 if (PyErr_Occurred()) SWIG_fail;
47410 }
47411 {
47412 #if wxUSE_UNICODE
47413 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
47414 #else
47415 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
47416 #endif
47417 }
47418 return resultobj;
47419 fail:
47420 return NULL;
47421 }
47422
47423
47424 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47425 PyObject *resultobj = 0;
47426 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47427 wxAcceleratorEntry *result = 0 ;
47428 void *argp1 = 0 ;
47429 int res1 = 0 ;
47430 PyObject *swig_obj[1] ;
47431
47432 if (!args) SWIG_fail;
47433 swig_obj[0] = args;
47434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47435 if (!SWIG_IsOK(res1)) {
47436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47437 }
47438 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47439 {
47440 PyThreadState* __tstate = wxPyBeginAllowThreads();
47441 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
47442 wxPyEndAllowThreads(__tstate);
47443 if (PyErr_Occurred()) SWIG_fail;
47444 }
47445 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
47446 return resultobj;
47447 fail:
47448 return NULL;
47449 }
47450
47451
47452 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47453 PyObject *resultobj = 0;
47454 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47455 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
47456 void *argp1 = 0 ;
47457 int res1 = 0 ;
47458 void *argp2 = 0 ;
47459 int res2 = 0 ;
47460 PyObject * obj0 = 0 ;
47461 PyObject * obj1 = 0 ;
47462 char * kwnames[] = {
47463 (char *) "self",(char *) "accel", NULL
47464 };
47465
47466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
47467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47468 if (!SWIG_IsOK(res1)) {
47469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47470 }
47471 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47472 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
47473 if (!SWIG_IsOK(res2)) {
47474 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
47475 }
47476 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
47477 {
47478 PyThreadState* __tstate = wxPyBeginAllowThreads();
47479 (arg1)->SetAccel(arg2);
47480 wxPyEndAllowThreads(__tstate);
47481 if (PyErr_Occurred()) SWIG_fail;
47482 }
47483 resultobj = SWIG_Py_Void();
47484 return resultobj;
47485 fail:
47486 return NULL;
47487 }
47488
47489
47490 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47491 PyObject *resultobj = 0;
47492 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47493 wxBitmap *arg2 = 0 ;
47494 void *argp1 = 0 ;
47495 int res1 = 0 ;
47496 void *argp2 = 0 ;
47497 int res2 = 0 ;
47498 PyObject * obj0 = 0 ;
47499 PyObject * obj1 = 0 ;
47500 char * kwnames[] = {
47501 (char *) "self",(char *) "bitmap", NULL
47502 };
47503
47504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
47505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47506 if (!SWIG_IsOK(res1)) {
47507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47508 }
47509 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47510 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47511 if (!SWIG_IsOK(res2)) {
47512 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47513 }
47514 if (!argp2) {
47515 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47516 }
47517 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47518 {
47519 PyThreadState* __tstate = wxPyBeginAllowThreads();
47520 (arg1)->SetBitmap((wxBitmap const &)*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_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47532 PyObject *resultobj = 0;
47533 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47534 wxBitmap *result = 0 ;
47535 void *argp1 = 0 ;
47536 int res1 = 0 ;
47537 PyObject *swig_obj[1] ;
47538
47539 if (!args) SWIG_fail;
47540 swig_obj[0] = args;
47541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47542 if (!SWIG_IsOK(res1)) {
47543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47544 }
47545 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47546 {
47547 PyThreadState* __tstate = wxPyBeginAllowThreads();
47548 {
47549 wxBitmap const &_result_ref = (arg1)->GetBitmap();
47550 result = (wxBitmap *) &_result_ref;
47551 }
47552 wxPyEndAllowThreads(__tstate);
47553 if (PyErr_Occurred()) SWIG_fail;
47554 }
47555 {
47556 wxBitmap* resultptr = new wxBitmap(*result);
47557 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
47558 }
47559 return resultobj;
47560 fail:
47561 return NULL;
47562 }
47563
47564
47565 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47566 PyObject *resultobj = 0;
47567 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47568 wxFont *arg2 = 0 ;
47569 void *argp1 = 0 ;
47570 int res1 = 0 ;
47571 void *argp2 = 0 ;
47572 int res2 = 0 ;
47573 PyObject * obj0 = 0 ;
47574 PyObject * obj1 = 0 ;
47575 char * kwnames[] = {
47576 (char *) "self",(char *) "font", NULL
47577 };
47578
47579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
47580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47581 if (!SWIG_IsOK(res1)) {
47582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47583 }
47584 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47585 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
47586 if (!SWIG_IsOK(res2)) {
47587 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
47588 }
47589 if (!argp2) {
47590 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
47591 }
47592 arg2 = reinterpret_cast< wxFont * >(argp2);
47593 {
47594 PyThreadState* __tstate = wxPyBeginAllowThreads();
47595 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
47596 wxPyEndAllowThreads(__tstate);
47597 if (PyErr_Occurred()) SWIG_fail;
47598 }
47599 resultobj = SWIG_Py_Void();
47600 return resultobj;
47601 fail:
47602 return NULL;
47603 }
47604
47605
47606 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47607 PyObject *resultobj = 0;
47608 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47609 wxFont result;
47610 void *argp1 = 0 ;
47611 int res1 = 0 ;
47612 PyObject *swig_obj[1] ;
47613
47614 if (!args) SWIG_fail;
47615 swig_obj[0] = args;
47616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47617 if (!SWIG_IsOK(res1)) {
47618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47619 }
47620 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47621 {
47622 PyThreadState* __tstate = wxPyBeginAllowThreads();
47623 result = wxMenuItem_GetFont(arg1);
47624 wxPyEndAllowThreads(__tstate);
47625 if (PyErr_Occurred()) SWIG_fail;
47626 }
47627 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
47628 return resultobj;
47629 fail:
47630 return NULL;
47631 }
47632
47633
47634 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47635 PyObject *resultobj = 0;
47636 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47637 wxColour *arg2 = 0 ;
47638 void *argp1 = 0 ;
47639 int res1 = 0 ;
47640 wxColour temp2 ;
47641 PyObject * obj0 = 0 ;
47642 PyObject * obj1 = 0 ;
47643 char * kwnames[] = {
47644 (char *) "self",(char *) "colText", NULL
47645 };
47646
47647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
47648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47649 if (!SWIG_IsOK(res1)) {
47650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47651 }
47652 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47653 {
47654 arg2 = &temp2;
47655 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
47656 }
47657 {
47658 PyThreadState* __tstate = wxPyBeginAllowThreads();
47659 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
47660 wxPyEndAllowThreads(__tstate);
47661 if (PyErr_Occurred()) SWIG_fail;
47662 }
47663 resultobj = SWIG_Py_Void();
47664 return resultobj;
47665 fail:
47666 return NULL;
47667 }
47668
47669
47670 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47671 PyObject *resultobj = 0;
47672 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47673 wxColour result;
47674 void *argp1 = 0 ;
47675 int res1 = 0 ;
47676 PyObject *swig_obj[1] ;
47677
47678 if (!args) SWIG_fail;
47679 swig_obj[0] = args;
47680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47681 if (!SWIG_IsOK(res1)) {
47682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47683 }
47684 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47685 {
47686 PyThreadState* __tstate = wxPyBeginAllowThreads();
47687 result = wxMenuItem_GetTextColour(arg1);
47688 wxPyEndAllowThreads(__tstate);
47689 if (PyErr_Occurred()) SWIG_fail;
47690 }
47691 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
47692 return resultobj;
47693 fail:
47694 return NULL;
47695 }
47696
47697
47698 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47699 PyObject *resultobj = 0;
47700 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47701 wxColour *arg2 = 0 ;
47702 void *argp1 = 0 ;
47703 int res1 = 0 ;
47704 wxColour temp2 ;
47705 PyObject * obj0 = 0 ;
47706 PyObject * obj1 = 0 ;
47707 char * kwnames[] = {
47708 (char *) "self",(char *) "colBack", NULL
47709 };
47710
47711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
47712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47713 if (!SWIG_IsOK(res1)) {
47714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47715 }
47716 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47717 {
47718 arg2 = &temp2;
47719 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
47720 }
47721 {
47722 PyThreadState* __tstate = wxPyBeginAllowThreads();
47723 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
47724 wxPyEndAllowThreads(__tstate);
47725 if (PyErr_Occurred()) SWIG_fail;
47726 }
47727 resultobj = SWIG_Py_Void();
47728 return resultobj;
47729 fail:
47730 return NULL;
47731 }
47732
47733
47734 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47735 PyObject *resultobj = 0;
47736 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47737 wxColour result;
47738 void *argp1 = 0 ;
47739 int res1 = 0 ;
47740 PyObject *swig_obj[1] ;
47741
47742 if (!args) SWIG_fail;
47743 swig_obj[0] = args;
47744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47745 if (!SWIG_IsOK(res1)) {
47746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47747 }
47748 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47749 {
47750 PyThreadState* __tstate = wxPyBeginAllowThreads();
47751 result = wxMenuItem_GetBackgroundColour(arg1);
47752 wxPyEndAllowThreads(__tstate);
47753 if (PyErr_Occurred()) SWIG_fail;
47754 }
47755 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
47756 return resultobj;
47757 fail:
47758 return NULL;
47759 }
47760
47761
47762 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47763 PyObject *resultobj = 0;
47764 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47765 wxBitmap *arg2 = 0 ;
47766 wxBitmap const &arg3_defvalue = wxNullBitmap ;
47767 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
47768 void *argp1 = 0 ;
47769 int res1 = 0 ;
47770 void *argp2 = 0 ;
47771 int res2 = 0 ;
47772 void *argp3 = 0 ;
47773 int res3 = 0 ;
47774 PyObject * obj0 = 0 ;
47775 PyObject * obj1 = 0 ;
47776 PyObject * obj2 = 0 ;
47777 char * kwnames[] = {
47778 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
47779 };
47780
47781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47783 if (!SWIG_IsOK(res1)) {
47784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47785 }
47786 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47787 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47788 if (!SWIG_IsOK(res2)) {
47789 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47790 }
47791 if (!argp2) {
47792 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47793 }
47794 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47795 if (obj2) {
47796 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
47797 if (!SWIG_IsOK(res3)) {
47798 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
47799 }
47800 if (!argp3) {
47801 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
47802 }
47803 arg3 = reinterpret_cast< wxBitmap * >(argp3);
47804 }
47805 {
47806 PyThreadState* __tstate = wxPyBeginAllowThreads();
47807 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
47808 wxPyEndAllowThreads(__tstate);
47809 if (PyErr_Occurred()) SWIG_fail;
47810 }
47811 resultobj = SWIG_Py_Void();
47812 return resultobj;
47813 fail:
47814 return NULL;
47815 }
47816
47817
47818 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47819 PyObject *resultobj = 0;
47820 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47821 wxBitmap *arg2 = 0 ;
47822 void *argp1 = 0 ;
47823 int res1 = 0 ;
47824 void *argp2 = 0 ;
47825 int res2 = 0 ;
47826 PyObject * obj0 = 0 ;
47827 PyObject * obj1 = 0 ;
47828 char * kwnames[] = {
47829 (char *) "self",(char *) "bmpDisabled", NULL
47830 };
47831
47832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
47833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47834 if (!SWIG_IsOK(res1)) {
47835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47836 }
47837 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47838 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47839 if (!SWIG_IsOK(res2)) {
47840 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47841 }
47842 if (!argp2) {
47843 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47844 }
47845 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47846 {
47847 PyThreadState* __tstate = wxPyBeginAllowThreads();
47848 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
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_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47860 PyObject *resultobj = 0;
47861 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47862 wxBitmap *result = 0 ;
47863 void *argp1 = 0 ;
47864 int res1 = 0 ;
47865 PyObject *swig_obj[1] ;
47866
47867 if (!args) SWIG_fail;
47868 swig_obj[0] = args;
47869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47870 if (!SWIG_IsOK(res1)) {
47871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47872 }
47873 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47874 {
47875 PyThreadState* __tstate = wxPyBeginAllowThreads();
47876 {
47877 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
47878 result = (wxBitmap *) &_result_ref;
47879 }
47880 wxPyEndAllowThreads(__tstate);
47881 if (PyErr_Occurred()) SWIG_fail;
47882 }
47883 {
47884 wxBitmap* resultptr = new wxBitmap(*result);
47885 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
47886 }
47887 return resultobj;
47888 fail:
47889 return NULL;
47890 }
47891
47892
47893 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47894 PyObject *resultobj = 0;
47895 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47896 int arg2 ;
47897 void *argp1 = 0 ;
47898 int res1 = 0 ;
47899 int val2 ;
47900 int ecode2 = 0 ;
47901 PyObject * obj0 = 0 ;
47902 PyObject * obj1 = 0 ;
47903 char * kwnames[] = {
47904 (char *) "self",(char *) "nWidth", NULL
47905 };
47906
47907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
47908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47909 if (!SWIG_IsOK(res1)) {
47910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47911 }
47912 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47913 ecode2 = SWIG_AsVal_int(obj1, &val2);
47914 if (!SWIG_IsOK(ecode2)) {
47915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
47916 }
47917 arg2 = static_cast< int >(val2);
47918 {
47919 PyThreadState* __tstate = wxPyBeginAllowThreads();
47920 wxMenuItem_SetMarginWidth(arg1,arg2);
47921 wxPyEndAllowThreads(__tstate);
47922 if (PyErr_Occurred()) SWIG_fail;
47923 }
47924 resultobj = SWIG_Py_Void();
47925 return resultobj;
47926 fail:
47927 return NULL;
47928 }
47929
47930
47931 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47932 PyObject *resultobj = 0;
47933 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47934 int result;
47935 void *argp1 = 0 ;
47936 int res1 = 0 ;
47937 PyObject *swig_obj[1] ;
47938
47939 if (!args) SWIG_fail;
47940 swig_obj[0] = args;
47941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47942 if (!SWIG_IsOK(res1)) {
47943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47944 }
47945 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47946 {
47947 PyThreadState* __tstate = wxPyBeginAllowThreads();
47948 result = (int)wxMenuItem_GetMarginWidth(arg1);
47949 wxPyEndAllowThreads(__tstate);
47950 if (PyErr_Occurred()) SWIG_fail;
47951 }
47952 resultobj = SWIG_From_int(static_cast< int >(result));
47953 return resultobj;
47954 fail:
47955 return NULL;
47956 }
47957
47958
47959 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47960 PyObject *resultobj = 0;
47961 int result;
47962
47963 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
47964 {
47965 PyThreadState* __tstate = wxPyBeginAllowThreads();
47966 result = (int)wxMenuItem_GetDefaultMarginWidth();
47967 wxPyEndAllowThreads(__tstate);
47968 if (PyErr_Occurred()) SWIG_fail;
47969 }
47970 resultobj = SWIG_From_int(static_cast< int >(result));
47971 return resultobj;
47972 fail:
47973 return NULL;
47974 }
47975
47976
47977 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47978 PyObject *resultobj = 0;
47979 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47980 bool result;
47981 void *argp1 = 0 ;
47982 int res1 = 0 ;
47983 PyObject *swig_obj[1] ;
47984
47985 if (!args) SWIG_fail;
47986 swig_obj[0] = args;
47987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47988 if (!SWIG_IsOK(res1)) {
47989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47990 }
47991 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47992 {
47993 PyThreadState* __tstate = wxPyBeginAllowThreads();
47994 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
47995 wxPyEndAllowThreads(__tstate);
47996 if (PyErr_Occurred()) SWIG_fail;
47997 }
47998 {
47999 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48000 }
48001 return resultobj;
48002 fail:
48003 return NULL;
48004 }
48005
48006
48007 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48008 PyObject *resultobj = 0;
48009 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
48010 bool arg2 = (bool) true ;
48011 void *argp1 = 0 ;
48012 int res1 = 0 ;
48013 bool val2 ;
48014 int ecode2 = 0 ;
48015 PyObject * obj0 = 0 ;
48016 PyObject * obj1 = 0 ;
48017 char * kwnames[] = {
48018 (char *) "self",(char *) "ownerDrawn", NULL
48019 };
48020
48021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
48022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
48023 if (!SWIG_IsOK(res1)) {
48024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
48025 }
48026 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
48027 if (obj1) {
48028 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48029 if (!SWIG_IsOK(ecode2)) {
48030 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
48031 }
48032 arg2 = static_cast< bool >(val2);
48033 }
48034 {
48035 PyThreadState* __tstate = wxPyBeginAllowThreads();
48036 wxMenuItem_SetOwnerDrawn(arg1,arg2);
48037 wxPyEndAllowThreads(__tstate);
48038 if (PyErr_Occurred()) SWIG_fail;
48039 }
48040 resultobj = SWIG_Py_Void();
48041 return resultobj;
48042 fail:
48043 return NULL;
48044 }
48045
48046
48047 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48048 PyObject *resultobj = 0;
48049 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
48050 void *argp1 = 0 ;
48051 int res1 = 0 ;
48052 PyObject *swig_obj[1] ;
48053
48054 if (!args) SWIG_fail;
48055 swig_obj[0] = args;
48056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
48057 if (!SWIG_IsOK(res1)) {
48058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
48059 }
48060 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
48061 {
48062 PyThreadState* __tstate = wxPyBeginAllowThreads();
48063 wxMenuItem_ResetOwnerDrawn(arg1);
48064 wxPyEndAllowThreads(__tstate);
48065 if (PyErr_Occurred()) SWIG_fail;
48066 }
48067 resultobj = SWIG_Py_Void();
48068 return resultobj;
48069 fail:
48070 return NULL;
48071 }
48072
48073
48074 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48075 PyObject *obj;
48076 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48077 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
48078 return SWIG_Py_Void();
48079 }
48080
48081 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48082 return SWIG_Python_InitShadowInstance(args);
48083 }
48084
48085 SWIGINTERN int ControlNameStr_set(PyObject *) {
48086 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
48087 return 1;
48088 }
48089
48090
48091 SWIGINTERN PyObject *ControlNameStr_get(void) {
48092 PyObject *pyobj = 0;
48093
48094 {
48095 #if wxUSE_UNICODE
48096 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
48097 #else
48098 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
48099 #endif
48100 }
48101 return pyobj;
48102 }
48103
48104
48105 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48106 PyObject *resultobj = 0;
48107 wxWindow *arg1 = (wxWindow *) 0 ;
48108 int arg2 = (int) -1 ;
48109 wxPoint const &arg3_defvalue = wxDefaultPosition ;
48110 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
48111 wxSize const &arg4_defvalue = wxDefaultSize ;
48112 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
48113 long arg5 = (long) 0 ;
48114 wxValidator const &arg6_defvalue = wxDefaultValidator ;
48115 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
48116 wxString const &arg7_defvalue = wxPyControlNameStr ;
48117 wxString *arg7 = (wxString *) &arg7_defvalue ;
48118 wxControl *result = 0 ;
48119 void *argp1 = 0 ;
48120 int res1 = 0 ;
48121 int val2 ;
48122 int ecode2 = 0 ;
48123 wxPoint temp3 ;
48124 wxSize temp4 ;
48125 long val5 ;
48126 int ecode5 = 0 ;
48127 void *argp6 = 0 ;
48128 int res6 = 0 ;
48129 bool temp7 = false ;
48130 PyObject * obj0 = 0 ;
48131 PyObject * obj1 = 0 ;
48132 PyObject * obj2 = 0 ;
48133 PyObject * obj3 = 0 ;
48134 PyObject * obj4 = 0 ;
48135 PyObject * obj5 = 0 ;
48136 PyObject * obj6 = 0 ;
48137 char * kwnames[] = {
48138 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
48139 };
48140
48141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
48142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
48143 if (!SWIG_IsOK(res1)) {
48144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
48145 }
48146 arg1 = reinterpret_cast< wxWindow * >(argp1);
48147 if (obj1) {
48148 ecode2 = SWIG_AsVal_int(obj1, &val2);
48149 if (!SWIG_IsOK(ecode2)) {
48150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
48151 }
48152 arg2 = static_cast< int >(val2);
48153 }
48154 if (obj2) {
48155 {
48156 arg3 = &temp3;
48157 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
48158 }
48159 }
48160 if (obj3) {
48161 {
48162 arg4 = &temp4;
48163 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
48164 }
48165 }
48166 if (obj4) {
48167 ecode5 = SWIG_AsVal_long(obj4, &val5);
48168 if (!SWIG_IsOK(ecode5)) {
48169 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
48170 }
48171 arg5 = static_cast< long >(val5);
48172 }
48173 if (obj5) {
48174 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
48175 if (!SWIG_IsOK(res6)) {
48176 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
48177 }
48178 if (!argp6) {
48179 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
48180 }
48181 arg6 = reinterpret_cast< wxValidator * >(argp6);
48182 }
48183 if (obj6) {
48184 {
48185 arg7 = wxString_in_helper(obj6);
48186 if (arg7 == NULL) SWIG_fail;
48187 temp7 = true;
48188 }
48189 }
48190 {
48191 if (!wxPyCheckForApp()) SWIG_fail;
48192 PyThreadState* __tstate = wxPyBeginAllowThreads();
48193 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
48194 wxPyEndAllowThreads(__tstate);
48195 if (PyErr_Occurred()) SWIG_fail;
48196 }
48197 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
48198 {
48199 if (temp7)
48200 delete arg7;
48201 }
48202 return resultobj;
48203 fail:
48204 {
48205 if (temp7)
48206 delete arg7;
48207 }
48208 return NULL;
48209 }
48210
48211
48212 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48213 PyObject *resultobj = 0;
48214 wxControl *result = 0 ;
48215
48216 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
48217 {
48218 if (!wxPyCheckForApp()) SWIG_fail;
48219 PyThreadState* __tstate = wxPyBeginAllowThreads();
48220 result = (wxControl *)new wxControl();
48221 wxPyEndAllowThreads(__tstate);
48222 if (PyErr_Occurred()) SWIG_fail;
48223 }
48224 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
48225 return resultobj;
48226 fail:
48227 return NULL;
48228 }
48229
48230
48231 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48232 PyObject *resultobj = 0;
48233 wxControl *arg1 = (wxControl *) 0 ;
48234 wxWindow *arg2 = (wxWindow *) 0 ;
48235 int arg3 = (int) -1 ;
48236 wxPoint const &arg4_defvalue = wxDefaultPosition ;
48237 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
48238 wxSize const &arg5_defvalue = wxDefaultSize ;
48239 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
48240 long arg6 = (long) 0 ;
48241 wxValidator const &arg7_defvalue = wxDefaultValidator ;
48242 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
48243 wxString const &arg8_defvalue = wxPyControlNameStr ;
48244 wxString *arg8 = (wxString *) &arg8_defvalue ;
48245 bool result;
48246 void *argp1 = 0 ;
48247 int res1 = 0 ;
48248 void *argp2 = 0 ;
48249 int res2 = 0 ;
48250 int val3 ;
48251 int ecode3 = 0 ;
48252 wxPoint temp4 ;
48253 wxSize temp5 ;
48254 long val6 ;
48255 int ecode6 = 0 ;
48256 void *argp7 = 0 ;
48257 int res7 = 0 ;
48258 bool temp8 = false ;
48259 PyObject * obj0 = 0 ;
48260 PyObject * obj1 = 0 ;
48261 PyObject * obj2 = 0 ;
48262 PyObject * obj3 = 0 ;
48263 PyObject * obj4 = 0 ;
48264 PyObject * obj5 = 0 ;
48265 PyObject * obj6 = 0 ;
48266 PyObject * obj7 = 0 ;
48267 char * kwnames[] = {
48268 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
48269 };
48270
48271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
48272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
48273 if (!SWIG_IsOK(res1)) {
48274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
48275 }
48276 arg1 = reinterpret_cast< wxControl * >(argp1);
48277 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48278 if (!SWIG_IsOK(res2)) {
48279 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
48280 }
48281 arg2 = reinterpret_cast< wxWindow * >(argp2);
48282 if (obj2) {
48283 ecode3 = SWIG_AsVal_int(obj2, &val3);
48284 if (!SWIG_IsOK(ecode3)) {
48285 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
48286 }
48287 arg3 = static_cast< int >(val3);
48288 }
48289 if (obj3) {
48290 {
48291 arg4 = &temp4;
48292 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
48293 }
48294 }
48295 if (obj4) {
48296 {
48297 arg5 = &temp5;
48298 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
48299 }
48300 }
48301 if (obj5) {
48302 ecode6 = SWIG_AsVal_long(obj5, &val6);
48303 if (!SWIG_IsOK(ecode6)) {
48304 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
48305 }
48306 arg6 = static_cast< long >(val6);
48307 }
48308 if (obj6) {
48309 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
48310 if (!SWIG_IsOK(res7)) {
48311 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
48312 }
48313 if (!argp7) {
48314 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
48315 }
48316 arg7 = reinterpret_cast< wxValidator * >(argp7);
48317 }
48318 if (obj7) {
48319 {
48320 arg8 = wxString_in_helper(obj7);
48321 if (arg8 == NULL) SWIG_fail;
48322 temp8 = true;
48323 }
48324 }
48325 {
48326 PyThreadState* __tstate = wxPyBeginAllowThreads();
48327 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
48328 wxPyEndAllowThreads(__tstate);
48329 if (PyErr_Occurred()) SWIG_fail;
48330 }
48331 {
48332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48333 }
48334 {
48335 if (temp8)
48336 delete arg8;
48337 }
48338 return resultobj;
48339 fail:
48340 {
48341 if (temp8)
48342 delete arg8;
48343 }
48344 return NULL;
48345 }
48346
48347
48348 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48349 PyObject *resultobj = 0;
48350 wxControl *arg1 = (wxControl *) 0 ;
48351 int result;
48352 void *argp1 = 0 ;
48353 int res1 = 0 ;
48354 PyObject *swig_obj[1] ;
48355
48356 if (!args) SWIG_fail;
48357 swig_obj[0] = args;
48358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
48359 if (!SWIG_IsOK(res1)) {
48360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
48361 }
48362 arg1 = reinterpret_cast< wxControl * >(argp1);
48363 {
48364 PyThreadState* __tstate = wxPyBeginAllowThreads();
48365 result = (int)((wxControl const *)arg1)->GetAlignment();
48366 wxPyEndAllowThreads(__tstate);
48367 if (PyErr_Occurred()) SWIG_fail;
48368 }
48369 resultobj = SWIG_From_int(static_cast< int >(result));
48370 return resultobj;
48371 fail:
48372 return NULL;
48373 }
48374
48375
48376 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48377 PyObject *resultobj = 0;
48378 wxControl *arg1 = (wxControl *) 0 ;
48379 wxString result;
48380 void *argp1 = 0 ;
48381 int res1 = 0 ;
48382 PyObject *swig_obj[1] ;
48383
48384 if (!args) SWIG_fail;
48385 swig_obj[0] = args;
48386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
48387 if (!SWIG_IsOK(res1)) {
48388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
48389 }
48390 arg1 = reinterpret_cast< wxControl * >(argp1);
48391 {
48392 PyThreadState* __tstate = wxPyBeginAllowThreads();
48393 result = ((wxControl const *)arg1)->GetLabelText();
48394 wxPyEndAllowThreads(__tstate);
48395 if (PyErr_Occurred()) SWIG_fail;
48396 }
48397 {
48398 #if wxUSE_UNICODE
48399 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48400 #else
48401 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48402 #endif
48403 }
48404 return resultobj;
48405 fail:
48406 return NULL;
48407 }
48408
48409
48410 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48411 PyObject *resultobj = 0;
48412 wxControl *arg1 = (wxControl *) 0 ;
48413 wxCommandEvent *arg2 = 0 ;
48414 void *argp1 = 0 ;
48415 int res1 = 0 ;
48416 void *argp2 = 0 ;
48417 int res2 = 0 ;
48418 PyObject * obj0 = 0 ;
48419 PyObject * obj1 = 0 ;
48420 char * kwnames[] = {
48421 (char *) "self",(char *) "event", NULL
48422 };
48423
48424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
48425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
48426 if (!SWIG_IsOK(res1)) {
48427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
48428 }
48429 arg1 = reinterpret_cast< wxControl * >(argp1);
48430 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
48431 if (!SWIG_IsOK(res2)) {
48432 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
48433 }
48434 if (!argp2) {
48435 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
48436 }
48437 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
48438 {
48439 PyThreadState* __tstate = wxPyBeginAllowThreads();
48440 (arg1)->Command(*arg2);
48441 wxPyEndAllowThreads(__tstate);
48442 if (PyErr_Occurred()) SWIG_fail;
48443 }
48444 resultobj = SWIG_Py_Void();
48445 return resultobj;
48446 fail:
48447 return NULL;
48448 }
48449
48450
48451 SWIGINTERN PyObject *_wrap_Control_RemoveMnemonics(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48452 PyObject *resultobj = 0;
48453 wxString *arg1 = 0 ;
48454 wxString result;
48455 bool temp1 = false ;
48456 PyObject * obj0 = 0 ;
48457 char * kwnames[] = {
48458 (char *) "str", NULL
48459 };
48460
48461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_RemoveMnemonics",kwnames,&obj0)) SWIG_fail;
48462 {
48463 arg1 = wxString_in_helper(obj0);
48464 if (arg1 == NULL) SWIG_fail;
48465 temp1 = true;
48466 }
48467 {
48468 PyThreadState* __tstate = wxPyBeginAllowThreads();
48469 result = wxControl::RemoveMnemonics((wxString const &)*arg1);
48470 wxPyEndAllowThreads(__tstate);
48471 if (PyErr_Occurred()) SWIG_fail;
48472 }
48473 {
48474 #if wxUSE_UNICODE
48475 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48476 #else
48477 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48478 #endif
48479 }
48480 {
48481 if (temp1)
48482 delete arg1;
48483 }
48484 return resultobj;
48485 fail:
48486 {
48487 if (temp1)
48488 delete arg1;
48489 }
48490 return NULL;
48491 }
48492
48493
48494 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48495 PyObject *resultobj = 0;
48496 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
48497 SwigValueWrapper<wxVisualAttributes > result;
48498 int val1 ;
48499 int ecode1 = 0 ;
48500 PyObject * obj0 = 0 ;
48501 char * kwnames[] = {
48502 (char *) "variant", NULL
48503 };
48504
48505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
48506 if (obj0) {
48507 ecode1 = SWIG_AsVal_int(obj0, &val1);
48508 if (!SWIG_IsOK(ecode1)) {
48509 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
48510 }
48511 arg1 = static_cast< wxWindowVariant >(val1);
48512 }
48513 {
48514 if (!wxPyCheckForApp()) SWIG_fail;
48515 PyThreadState* __tstate = wxPyBeginAllowThreads();
48516 result = wxControl::GetClassDefaultAttributes(arg1);
48517 wxPyEndAllowThreads(__tstate);
48518 if (PyErr_Occurred()) SWIG_fail;
48519 }
48520 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
48521 return resultobj;
48522 fail:
48523 return NULL;
48524 }
48525
48526
48527 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48528 PyObject *obj;
48529 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48530 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
48531 return SWIG_Py_Void();
48532 }
48533
48534 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48535 return SWIG_Python_InitShadowInstance(args);
48536 }
48537
48538 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48539 PyObject *resultobj = 0;
48540 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48541 wxString *arg2 = 0 ;
48542 PyObject *arg3 = (PyObject *) NULL ;
48543 int result;
48544 void *argp1 = 0 ;
48545 int res1 = 0 ;
48546 bool temp2 = false ;
48547 PyObject * obj0 = 0 ;
48548 PyObject * obj1 = 0 ;
48549 PyObject * obj2 = 0 ;
48550 char * kwnames[] = {
48551 (char *) "self",(char *) "item",(char *) "clientData", NULL
48552 };
48553
48554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48556 if (!SWIG_IsOK(res1)) {
48557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48558 }
48559 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48560 {
48561 arg2 = wxString_in_helper(obj1);
48562 if (arg2 == NULL) SWIG_fail;
48563 temp2 = true;
48564 }
48565 if (obj2) {
48566 arg3 = obj2;
48567 }
48568 {
48569 PyThreadState* __tstate = wxPyBeginAllowThreads();
48570 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
48571 wxPyEndAllowThreads(__tstate);
48572 if (PyErr_Occurred()) SWIG_fail;
48573 }
48574 resultobj = SWIG_From_int(static_cast< int >(result));
48575 {
48576 if (temp2)
48577 delete arg2;
48578 }
48579 return resultobj;
48580 fail:
48581 {
48582 if (temp2)
48583 delete arg2;
48584 }
48585 return NULL;
48586 }
48587
48588
48589 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48590 PyObject *resultobj = 0;
48591 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48592 wxArrayString *arg2 = 0 ;
48593 void *argp1 = 0 ;
48594 int res1 = 0 ;
48595 bool temp2 = false ;
48596 PyObject * obj0 = 0 ;
48597 PyObject * obj1 = 0 ;
48598 char * kwnames[] = {
48599 (char *) "self",(char *) "strings", NULL
48600 };
48601
48602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
48603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48604 if (!SWIG_IsOK(res1)) {
48605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48606 }
48607 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48608 {
48609 if (! PySequence_Check(obj1)) {
48610 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
48611 SWIG_fail;
48612 }
48613 arg2 = new wxArrayString;
48614 temp2 = true;
48615 int i, len=PySequence_Length(obj1);
48616 for (i=0; i<len; i++) {
48617 PyObject* item = PySequence_GetItem(obj1, i);
48618 wxString* s = wxString_in_helper(item);
48619 if (PyErr_Occurred()) SWIG_fail;
48620 arg2->Add(*s);
48621 delete s;
48622 Py_DECREF(item);
48623 }
48624 }
48625 {
48626 PyThreadState* __tstate = wxPyBeginAllowThreads();
48627 (arg1)->Append((wxArrayString const &)*arg2);
48628 wxPyEndAllowThreads(__tstate);
48629 if (PyErr_Occurred()) SWIG_fail;
48630 }
48631 resultobj = SWIG_Py_Void();
48632 {
48633 if (temp2) delete arg2;
48634 }
48635 return resultobj;
48636 fail:
48637 {
48638 if (temp2) delete arg2;
48639 }
48640 return NULL;
48641 }
48642
48643
48644 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48645 PyObject *resultobj = 0;
48646 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48647 wxString *arg2 = 0 ;
48648 int arg3 ;
48649 PyObject *arg4 = (PyObject *) NULL ;
48650 int result;
48651 void *argp1 = 0 ;
48652 int res1 = 0 ;
48653 bool temp2 = false ;
48654 int val3 ;
48655 int ecode3 = 0 ;
48656 PyObject * obj0 = 0 ;
48657 PyObject * obj1 = 0 ;
48658 PyObject * obj2 = 0 ;
48659 PyObject * obj3 = 0 ;
48660 char * kwnames[] = {
48661 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
48662 };
48663
48664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48666 if (!SWIG_IsOK(res1)) {
48667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48668 }
48669 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48670 {
48671 arg2 = wxString_in_helper(obj1);
48672 if (arg2 == NULL) SWIG_fail;
48673 temp2 = true;
48674 }
48675 ecode3 = SWIG_AsVal_int(obj2, &val3);
48676 if (!SWIG_IsOK(ecode3)) {
48677 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "int""'");
48678 }
48679 arg3 = static_cast< int >(val3);
48680 if (obj3) {
48681 arg4 = obj3;
48682 }
48683 {
48684 PyThreadState* __tstate = wxPyBeginAllowThreads();
48685 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
48686 wxPyEndAllowThreads(__tstate);
48687 if (PyErr_Occurred()) SWIG_fail;
48688 }
48689 resultobj = SWIG_From_int(static_cast< int >(result));
48690 {
48691 if (temp2)
48692 delete arg2;
48693 }
48694 return resultobj;
48695 fail:
48696 {
48697 if (temp2)
48698 delete arg2;
48699 }
48700 return NULL;
48701 }
48702
48703
48704 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48705 PyObject *resultobj = 0;
48706 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48707 void *argp1 = 0 ;
48708 int res1 = 0 ;
48709 PyObject *swig_obj[1] ;
48710
48711 if (!args) SWIG_fail;
48712 swig_obj[0] = args;
48713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48714 if (!SWIG_IsOK(res1)) {
48715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48716 }
48717 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48718 {
48719 PyThreadState* __tstate = wxPyBeginAllowThreads();
48720 (arg1)->Clear();
48721 wxPyEndAllowThreads(__tstate);
48722 if (PyErr_Occurred()) SWIG_fail;
48723 }
48724 resultobj = SWIG_Py_Void();
48725 return resultobj;
48726 fail:
48727 return NULL;
48728 }
48729
48730
48731 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48732 PyObject *resultobj = 0;
48733 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48734 int arg2 ;
48735 void *argp1 = 0 ;
48736 int res1 = 0 ;
48737 int val2 ;
48738 int ecode2 = 0 ;
48739 PyObject * obj0 = 0 ;
48740 PyObject * obj1 = 0 ;
48741 char * kwnames[] = {
48742 (char *) "self",(char *) "n", NULL
48743 };
48744
48745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
48746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48747 if (!SWIG_IsOK(res1)) {
48748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48749 }
48750 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48751 ecode2 = SWIG_AsVal_int(obj1, &val2);
48752 if (!SWIG_IsOK(ecode2)) {
48753 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "int""'");
48754 }
48755 arg2 = static_cast< int >(val2);
48756 {
48757 PyThreadState* __tstate = wxPyBeginAllowThreads();
48758 (arg1)->Delete(arg2);
48759 wxPyEndAllowThreads(__tstate);
48760 if (PyErr_Occurred()) SWIG_fail;
48761 }
48762 resultobj = SWIG_Py_Void();
48763 return resultobj;
48764 fail:
48765 return NULL;
48766 }
48767
48768
48769 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48770 PyObject *resultobj = 0;
48771 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48772 int arg2 ;
48773 PyObject *result = 0 ;
48774 void *argp1 = 0 ;
48775 int res1 = 0 ;
48776 int val2 ;
48777 int ecode2 = 0 ;
48778 PyObject * obj0 = 0 ;
48779 PyObject * obj1 = 0 ;
48780 char * kwnames[] = {
48781 (char *) "self",(char *) "n", NULL
48782 };
48783
48784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
48785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48786 if (!SWIG_IsOK(res1)) {
48787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48788 }
48789 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48790 ecode2 = SWIG_AsVal_int(obj1, &val2);
48791 if (!SWIG_IsOK(ecode2)) {
48792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "int""'");
48793 }
48794 arg2 = static_cast< int >(val2);
48795 {
48796 PyThreadState* __tstate = wxPyBeginAllowThreads();
48797 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
48798 wxPyEndAllowThreads(__tstate);
48799 if (PyErr_Occurred()) SWIG_fail;
48800 }
48801 resultobj = result;
48802 return resultobj;
48803 fail:
48804 return NULL;
48805 }
48806
48807
48808 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48809 PyObject *resultobj = 0;
48810 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48811 int arg2 ;
48812 PyObject *arg3 = (PyObject *) 0 ;
48813 void *argp1 = 0 ;
48814 int res1 = 0 ;
48815 int val2 ;
48816 int ecode2 = 0 ;
48817 PyObject * obj0 = 0 ;
48818 PyObject * obj1 = 0 ;
48819 PyObject * obj2 = 0 ;
48820 char * kwnames[] = {
48821 (char *) "self",(char *) "n",(char *) "clientData", NULL
48822 };
48823
48824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48826 if (!SWIG_IsOK(res1)) {
48827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48828 }
48829 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48830 ecode2 = SWIG_AsVal_int(obj1, &val2);
48831 if (!SWIG_IsOK(ecode2)) {
48832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "int""'");
48833 }
48834 arg2 = static_cast< int >(val2);
48835 arg3 = obj2;
48836 {
48837 PyThreadState* __tstate = wxPyBeginAllowThreads();
48838 wxItemContainer_SetClientData(arg1,arg2,arg3);
48839 wxPyEndAllowThreads(__tstate);
48840 if (PyErr_Occurred()) SWIG_fail;
48841 }
48842 resultobj = SWIG_Py_Void();
48843 return resultobj;
48844 fail:
48845 return NULL;
48846 }
48847
48848
48849 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48850 PyObject *resultobj = 0;
48851 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48852 int result;
48853 void *argp1 = 0 ;
48854 int res1 = 0 ;
48855 PyObject *swig_obj[1] ;
48856
48857 if (!args) SWIG_fail;
48858 swig_obj[0] = args;
48859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48860 if (!SWIG_IsOK(res1)) {
48861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48862 }
48863 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48864 {
48865 PyThreadState* __tstate = wxPyBeginAllowThreads();
48866 result = (int)((wxItemContainer const *)arg1)->GetCount();
48867 wxPyEndAllowThreads(__tstate);
48868 if (PyErr_Occurred()) SWIG_fail;
48869 }
48870 resultobj = SWIG_From_int(static_cast< int >(result));
48871 return resultobj;
48872 fail:
48873 return NULL;
48874 }
48875
48876
48877 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48878 PyObject *resultobj = 0;
48879 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48880 bool result;
48881 void *argp1 = 0 ;
48882 int res1 = 0 ;
48883 PyObject *swig_obj[1] ;
48884
48885 if (!args) SWIG_fail;
48886 swig_obj[0] = args;
48887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48888 if (!SWIG_IsOK(res1)) {
48889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48890 }
48891 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48892 {
48893 PyThreadState* __tstate = wxPyBeginAllowThreads();
48894 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
48895 wxPyEndAllowThreads(__tstate);
48896 if (PyErr_Occurred()) SWIG_fail;
48897 }
48898 {
48899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48900 }
48901 return resultobj;
48902 fail:
48903 return NULL;
48904 }
48905
48906
48907 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48908 PyObject *resultobj = 0;
48909 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48910 int arg2 ;
48911 wxString result;
48912 void *argp1 = 0 ;
48913 int res1 = 0 ;
48914 int val2 ;
48915 int ecode2 = 0 ;
48916 PyObject * obj0 = 0 ;
48917 PyObject * obj1 = 0 ;
48918 char * kwnames[] = {
48919 (char *) "self",(char *) "n", NULL
48920 };
48921
48922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
48923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48924 if (!SWIG_IsOK(res1)) {
48925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48926 }
48927 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48928 ecode2 = SWIG_AsVal_int(obj1, &val2);
48929 if (!SWIG_IsOK(ecode2)) {
48930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "int""'");
48931 }
48932 arg2 = static_cast< int >(val2);
48933 {
48934 PyThreadState* __tstate = wxPyBeginAllowThreads();
48935 result = ((wxItemContainer const *)arg1)->GetString(arg2);
48936 wxPyEndAllowThreads(__tstate);
48937 if (PyErr_Occurred()) SWIG_fail;
48938 }
48939 {
48940 #if wxUSE_UNICODE
48941 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48942 #else
48943 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48944 #endif
48945 }
48946 return resultobj;
48947 fail:
48948 return NULL;
48949 }
48950
48951
48952 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48953 PyObject *resultobj = 0;
48954 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48955 wxArrayString result;
48956 void *argp1 = 0 ;
48957 int res1 = 0 ;
48958 PyObject *swig_obj[1] ;
48959
48960 if (!args) SWIG_fail;
48961 swig_obj[0] = args;
48962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48963 if (!SWIG_IsOK(res1)) {
48964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48965 }
48966 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48967 {
48968 PyThreadState* __tstate = wxPyBeginAllowThreads();
48969 result = ((wxItemContainer const *)arg1)->GetStrings();
48970 wxPyEndAllowThreads(__tstate);
48971 if (PyErr_Occurred()) SWIG_fail;
48972 }
48973 {
48974 resultobj = wxArrayString2PyList_helper(result);
48975 }
48976 return resultobj;
48977 fail:
48978 return NULL;
48979 }
48980
48981
48982 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48983 PyObject *resultobj = 0;
48984 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48985 int arg2 ;
48986 wxString *arg3 = 0 ;
48987 void *argp1 = 0 ;
48988 int res1 = 0 ;
48989 int val2 ;
48990 int ecode2 = 0 ;
48991 bool temp3 = false ;
48992 PyObject * obj0 = 0 ;
48993 PyObject * obj1 = 0 ;
48994 PyObject * obj2 = 0 ;
48995 char * kwnames[] = {
48996 (char *) "self",(char *) "n",(char *) "s", NULL
48997 };
48998
48999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49001 if (!SWIG_IsOK(res1)) {
49002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
49003 }
49004 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49005 ecode2 = SWIG_AsVal_int(obj1, &val2);
49006 if (!SWIG_IsOK(ecode2)) {
49007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "int""'");
49008 }
49009 arg2 = static_cast< int >(val2);
49010 {
49011 arg3 = wxString_in_helper(obj2);
49012 if (arg3 == NULL) SWIG_fail;
49013 temp3 = true;
49014 }
49015 {
49016 PyThreadState* __tstate = wxPyBeginAllowThreads();
49017 (arg1)->SetString(arg2,(wxString const &)*arg3);
49018 wxPyEndAllowThreads(__tstate);
49019 if (PyErr_Occurred()) SWIG_fail;
49020 }
49021 resultobj = SWIG_Py_Void();
49022 {
49023 if (temp3)
49024 delete arg3;
49025 }
49026 return resultobj;
49027 fail:
49028 {
49029 if (temp3)
49030 delete arg3;
49031 }
49032 return NULL;
49033 }
49034
49035
49036 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49037 PyObject *resultobj = 0;
49038 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
49039 wxString *arg2 = 0 ;
49040 int result;
49041 void *argp1 = 0 ;
49042 int res1 = 0 ;
49043 bool temp2 = false ;
49044 PyObject * obj0 = 0 ;
49045 PyObject * obj1 = 0 ;
49046 char * kwnames[] = {
49047 (char *) "self",(char *) "s", NULL
49048 };
49049
49050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
49051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49052 if (!SWIG_IsOK(res1)) {
49053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
49054 }
49055 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49056 {
49057 arg2 = wxString_in_helper(obj1);
49058 if (arg2 == NULL) SWIG_fail;
49059 temp2 = true;
49060 }
49061 {
49062 PyThreadState* __tstate = wxPyBeginAllowThreads();
49063 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
49064 wxPyEndAllowThreads(__tstate);
49065 if (PyErr_Occurred()) SWIG_fail;
49066 }
49067 resultobj = SWIG_From_int(static_cast< int >(result));
49068 {
49069 if (temp2)
49070 delete arg2;
49071 }
49072 return resultobj;
49073 fail:
49074 {
49075 if (temp2)
49076 delete arg2;
49077 }
49078 return NULL;
49079 }
49080
49081
49082 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49083 PyObject *resultobj = 0;
49084 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
49085 int arg2 ;
49086 void *argp1 = 0 ;
49087 int res1 = 0 ;
49088 int val2 ;
49089 int ecode2 = 0 ;
49090 PyObject * obj0 = 0 ;
49091 PyObject * obj1 = 0 ;
49092 char * kwnames[] = {
49093 (char *) "self",(char *) "n", NULL
49094 };
49095
49096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
49097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49098 if (!SWIG_IsOK(res1)) {
49099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
49100 }
49101 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49102 ecode2 = SWIG_AsVal_int(obj1, &val2);
49103 if (!SWIG_IsOK(ecode2)) {
49104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
49105 }
49106 arg2 = static_cast< int >(val2);
49107 {
49108 PyThreadState* __tstate = wxPyBeginAllowThreads();
49109 (arg1)->SetSelection(arg2);
49110 wxPyEndAllowThreads(__tstate);
49111 if (PyErr_Occurred()) SWIG_fail;
49112 }
49113 resultobj = SWIG_Py_Void();
49114 return resultobj;
49115 fail:
49116 return NULL;
49117 }
49118
49119
49120 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49121 PyObject *resultobj = 0;
49122 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
49123 int result;
49124 void *argp1 = 0 ;
49125 int res1 = 0 ;
49126 PyObject *swig_obj[1] ;
49127
49128 if (!args) SWIG_fail;
49129 swig_obj[0] = args;
49130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49131 if (!SWIG_IsOK(res1)) {
49132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
49133 }
49134 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49135 {
49136 PyThreadState* __tstate = wxPyBeginAllowThreads();
49137 result = (int)((wxItemContainer const *)arg1)->GetSelection();
49138 wxPyEndAllowThreads(__tstate);
49139 if (PyErr_Occurred()) SWIG_fail;
49140 }
49141 resultobj = SWIG_From_int(static_cast< int >(result));
49142 return resultobj;
49143 fail:
49144 return NULL;
49145 }
49146
49147
49148 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49149 PyObject *resultobj = 0;
49150 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
49151 wxString *arg2 = 0 ;
49152 bool result;
49153 void *argp1 = 0 ;
49154 int res1 = 0 ;
49155 bool temp2 = false ;
49156 PyObject * obj0 = 0 ;
49157 PyObject * obj1 = 0 ;
49158 char * kwnames[] = {
49159 (char *) "self",(char *) "s", NULL
49160 };
49161
49162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
49163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49164 if (!SWIG_IsOK(res1)) {
49165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
49166 }
49167 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49168 {
49169 arg2 = wxString_in_helper(obj1);
49170 if (arg2 == NULL) SWIG_fail;
49171 temp2 = true;
49172 }
49173 {
49174 PyThreadState* __tstate = wxPyBeginAllowThreads();
49175 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
49176 wxPyEndAllowThreads(__tstate);
49177 if (PyErr_Occurred()) SWIG_fail;
49178 }
49179 {
49180 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49181 }
49182 {
49183 if (temp2)
49184 delete arg2;
49185 }
49186 return resultobj;
49187 fail:
49188 {
49189 if (temp2)
49190 delete arg2;
49191 }
49192 return NULL;
49193 }
49194
49195
49196 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49197 PyObject *resultobj = 0;
49198 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
49199 wxString result;
49200 void *argp1 = 0 ;
49201 int res1 = 0 ;
49202 PyObject *swig_obj[1] ;
49203
49204 if (!args) SWIG_fail;
49205 swig_obj[0] = args;
49206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49207 if (!SWIG_IsOK(res1)) {
49208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
49209 }
49210 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49211 {
49212 PyThreadState* __tstate = wxPyBeginAllowThreads();
49213 result = ((wxItemContainer const *)arg1)->GetStringSelection();
49214 wxPyEndAllowThreads(__tstate);
49215 if (PyErr_Occurred()) SWIG_fail;
49216 }
49217 {
49218 #if wxUSE_UNICODE
49219 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
49220 #else
49221 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
49222 #endif
49223 }
49224 return resultobj;
49225 fail:
49226 return NULL;
49227 }
49228
49229
49230 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49231 PyObject *resultobj = 0;
49232 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
49233 int arg2 ;
49234 void *argp1 = 0 ;
49235 int res1 = 0 ;
49236 int val2 ;
49237 int ecode2 = 0 ;
49238 PyObject * obj0 = 0 ;
49239 PyObject * obj1 = 0 ;
49240 char * kwnames[] = {
49241 (char *) "self",(char *) "n", NULL
49242 };
49243
49244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
49245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49246 if (!SWIG_IsOK(res1)) {
49247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
49248 }
49249 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49250 ecode2 = SWIG_AsVal_int(obj1, &val2);
49251 if (!SWIG_IsOK(ecode2)) {
49252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
49253 }
49254 arg2 = static_cast< int >(val2);
49255 {
49256 PyThreadState* __tstate = wxPyBeginAllowThreads();
49257 (arg1)->Select(arg2);
49258 wxPyEndAllowThreads(__tstate);
49259 if (PyErr_Occurred()) SWIG_fail;
49260 }
49261 resultobj = SWIG_Py_Void();
49262 return resultobj;
49263 fail:
49264 return NULL;
49265 }
49266
49267
49268 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49269 PyObject *obj;
49270 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49271 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
49272 return SWIG_Py_Void();
49273 }
49274
49275 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49276 PyObject *obj;
49277 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49278 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
49279 return SWIG_Py_Void();
49280 }
49281
49282 SWIGINTERN PyObject *_wrap_new_SizerFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49283 PyObject *resultobj = 0;
49284 int arg1 = (int) 0 ;
49285 wxSizerFlags *result = 0 ;
49286 int val1 ;
49287 int ecode1 = 0 ;
49288 PyObject * obj0 = 0 ;
49289 char * kwnames[] = {
49290 (char *) "proportion", NULL
49291 };
49292
49293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_SizerFlags",kwnames,&obj0)) SWIG_fail;
49294 if (obj0) {
49295 ecode1 = SWIG_AsVal_int(obj0, &val1);
49296 if (!SWIG_IsOK(ecode1)) {
49297 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerFlags" "', expected argument " "1"" of type '" "int""'");
49298 }
49299 arg1 = static_cast< int >(val1);
49300 }
49301 {
49302 PyThreadState* __tstate = wxPyBeginAllowThreads();
49303 result = (wxSizerFlags *)new wxSizerFlags(arg1);
49304 wxPyEndAllowThreads(__tstate);
49305 if (PyErr_Occurred()) SWIG_fail;
49306 }
49307 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerFlags, SWIG_POINTER_NEW | 0 );
49308 return resultobj;
49309 fail:
49310 return NULL;
49311 }
49312
49313
49314 SWIGINTERN PyObject *_wrap_delete_SizerFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49315 PyObject *resultobj = 0;
49316 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49317 void *argp1 = 0 ;
49318 int res1 = 0 ;
49319 PyObject *swig_obj[1] ;
49320
49321 if (!args) SWIG_fail;
49322 swig_obj[0] = args;
49323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, SWIG_POINTER_DISOWN | 0 );
49324 if (!SWIG_IsOK(res1)) {
49325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerFlags" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49326 }
49327 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49328 {
49329 PyThreadState* __tstate = wxPyBeginAllowThreads();
49330 delete arg1;
49331
49332 wxPyEndAllowThreads(__tstate);
49333 if (PyErr_Occurred()) SWIG_fail;
49334 }
49335 resultobj = SWIG_Py_Void();
49336 return resultobj;
49337 fail:
49338 return NULL;
49339 }
49340
49341
49342 SWIGINTERN PyObject *_wrap_SizerFlags_Proportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49343 PyObject *resultobj = 0;
49344 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49345 int arg2 ;
49346 wxSizerFlags *result = 0 ;
49347 void *argp1 = 0 ;
49348 int res1 = 0 ;
49349 int val2 ;
49350 int ecode2 = 0 ;
49351 PyObject * obj0 = 0 ;
49352 PyObject * obj1 = 0 ;
49353 char * kwnames[] = {
49354 (char *) "self",(char *) "proportion", NULL
49355 };
49356
49357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerFlags_Proportion",kwnames,&obj0,&obj1)) SWIG_fail;
49358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49359 if (!SWIG_IsOK(res1)) {
49360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Proportion" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49361 }
49362 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49363 ecode2 = SWIG_AsVal_int(obj1, &val2);
49364 if (!SWIG_IsOK(ecode2)) {
49365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_Proportion" "', expected argument " "2"" of type '" "int""'");
49366 }
49367 arg2 = static_cast< int >(val2);
49368 {
49369 PyThreadState* __tstate = wxPyBeginAllowThreads();
49370 {
49371 wxSizerFlags &_result_ref = (arg1)->Proportion(arg2);
49372 result = (wxSizerFlags *) &_result_ref;
49373 }
49374 wxPyEndAllowThreads(__tstate);
49375 if (PyErr_Occurred()) SWIG_fail;
49376 }
49377 {
49378 resultobj = obj0; Py_INCREF(resultobj);
49379 }
49380 return resultobj;
49381 fail:
49382 return NULL;
49383 }
49384
49385
49386 SWIGINTERN PyObject *_wrap_SizerFlags_Align(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49387 PyObject *resultobj = 0;
49388 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49389 int arg2 ;
49390 wxSizerFlags *result = 0 ;
49391 void *argp1 = 0 ;
49392 int res1 = 0 ;
49393 int val2 ;
49394 int ecode2 = 0 ;
49395 PyObject * obj0 = 0 ;
49396 PyObject * obj1 = 0 ;
49397 char * kwnames[] = {
49398 (char *) "self",(char *) "alignment", NULL
49399 };
49400
49401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerFlags_Align",kwnames,&obj0,&obj1)) SWIG_fail;
49402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49403 if (!SWIG_IsOK(res1)) {
49404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Align" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49405 }
49406 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49407 ecode2 = SWIG_AsVal_int(obj1, &val2);
49408 if (!SWIG_IsOK(ecode2)) {
49409 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_Align" "', expected argument " "2"" of type '" "int""'");
49410 }
49411 arg2 = static_cast< int >(val2);
49412 {
49413 PyThreadState* __tstate = wxPyBeginAllowThreads();
49414 {
49415 wxSizerFlags &_result_ref = (arg1)->Align(arg2);
49416 result = (wxSizerFlags *) &_result_ref;
49417 }
49418 wxPyEndAllowThreads(__tstate);
49419 if (PyErr_Occurred()) SWIG_fail;
49420 }
49421 {
49422 resultobj = obj0; Py_INCREF(resultobj);
49423 }
49424 return resultobj;
49425 fail:
49426 return NULL;
49427 }
49428
49429
49430 SWIGINTERN PyObject *_wrap_SizerFlags_Expand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49431 PyObject *resultobj = 0;
49432 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49433 wxSizerFlags *result = 0 ;
49434 void *argp1 = 0 ;
49435 int res1 = 0 ;
49436 PyObject *swig_obj[1] ;
49437
49438 if (!args) SWIG_fail;
49439 swig_obj[0] = args;
49440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49441 if (!SWIG_IsOK(res1)) {
49442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Expand" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49443 }
49444 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49445 {
49446 PyThreadState* __tstate = wxPyBeginAllowThreads();
49447 {
49448 wxSizerFlags &_result_ref = (arg1)->Expand();
49449 result = (wxSizerFlags *) &_result_ref;
49450 }
49451 wxPyEndAllowThreads(__tstate);
49452 if (PyErr_Occurred()) SWIG_fail;
49453 }
49454 {
49455 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49456 }
49457 return resultobj;
49458 fail:
49459 return NULL;
49460 }
49461
49462
49463 SWIGINTERN PyObject *_wrap_SizerFlags_Centre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49464 PyObject *resultobj = 0;
49465 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49466 wxSizerFlags *result = 0 ;
49467 void *argp1 = 0 ;
49468 int res1 = 0 ;
49469 PyObject *swig_obj[1] ;
49470
49471 if (!args) SWIG_fail;
49472 swig_obj[0] = args;
49473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49474 if (!SWIG_IsOK(res1)) {
49475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Centre" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49476 }
49477 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49478 {
49479 PyThreadState* __tstate = wxPyBeginAllowThreads();
49480 {
49481 wxSizerFlags &_result_ref = (arg1)->Centre();
49482 result = (wxSizerFlags *) &_result_ref;
49483 }
49484 wxPyEndAllowThreads(__tstate);
49485 if (PyErr_Occurred()) SWIG_fail;
49486 }
49487 {
49488 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49489 }
49490 return resultobj;
49491 fail:
49492 return NULL;
49493 }
49494
49495
49496 SWIGINTERN PyObject *_wrap_SizerFlags_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49497 PyObject *resultobj = 0;
49498 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49499 wxSizerFlags *result = 0 ;
49500 void *argp1 = 0 ;
49501 int res1 = 0 ;
49502 PyObject *swig_obj[1] ;
49503
49504 if (!args) SWIG_fail;
49505 swig_obj[0] = args;
49506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49507 if (!SWIG_IsOK(res1)) {
49508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Center" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49509 }
49510 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49511 {
49512 PyThreadState* __tstate = wxPyBeginAllowThreads();
49513 {
49514 wxSizerFlags &_result_ref = (arg1)->Center();
49515 result = (wxSizerFlags *) &_result_ref;
49516 }
49517 wxPyEndAllowThreads(__tstate);
49518 if (PyErr_Occurred()) SWIG_fail;
49519 }
49520 {
49521 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49522 }
49523 return resultobj;
49524 fail:
49525 return NULL;
49526 }
49527
49528
49529 SWIGINTERN PyObject *_wrap_SizerFlags_Left(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49530 PyObject *resultobj = 0;
49531 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49532 wxSizerFlags *result = 0 ;
49533 void *argp1 = 0 ;
49534 int res1 = 0 ;
49535 PyObject *swig_obj[1] ;
49536
49537 if (!args) SWIG_fail;
49538 swig_obj[0] = args;
49539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49540 if (!SWIG_IsOK(res1)) {
49541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Left" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49542 }
49543 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49544 {
49545 PyThreadState* __tstate = wxPyBeginAllowThreads();
49546 {
49547 wxSizerFlags &_result_ref = (arg1)->Left();
49548 result = (wxSizerFlags *) &_result_ref;
49549 }
49550 wxPyEndAllowThreads(__tstate);
49551 if (PyErr_Occurred()) SWIG_fail;
49552 }
49553 {
49554 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49555 }
49556 return resultobj;
49557 fail:
49558 return NULL;
49559 }
49560
49561
49562 SWIGINTERN PyObject *_wrap_SizerFlags_Right(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49563 PyObject *resultobj = 0;
49564 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49565 wxSizerFlags *result = 0 ;
49566 void *argp1 = 0 ;
49567 int res1 = 0 ;
49568 PyObject *swig_obj[1] ;
49569
49570 if (!args) SWIG_fail;
49571 swig_obj[0] = args;
49572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49573 if (!SWIG_IsOK(res1)) {
49574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Right" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49575 }
49576 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49577 {
49578 PyThreadState* __tstate = wxPyBeginAllowThreads();
49579 {
49580 wxSizerFlags &_result_ref = (arg1)->Right();
49581 result = (wxSizerFlags *) &_result_ref;
49582 }
49583 wxPyEndAllowThreads(__tstate);
49584 if (PyErr_Occurred()) SWIG_fail;
49585 }
49586 {
49587 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49588 }
49589 return resultobj;
49590 fail:
49591 return NULL;
49592 }
49593
49594
49595 SWIGINTERN PyObject *_wrap_SizerFlags_Top(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49596 PyObject *resultobj = 0;
49597 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49598 wxSizerFlags *result = 0 ;
49599 void *argp1 = 0 ;
49600 int res1 = 0 ;
49601 PyObject *swig_obj[1] ;
49602
49603 if (!args) SWIG_fail;
49604 swig_obj[0] = args;
49605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49606 if (!SWIG_IsOK(res1)) {
49607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Top" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49608 }
49609 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49610 {
49611 PyThreadState* __tstate = wxPyBeginAllowThreads();
49612 {
49613 wxSizerFlags &_result_ref = (arg1)->Top();
49614 result = (wxSizerFlags *) &_result_ref;
49615 }
49616 wxPyEndAllowThreads(__tstate);
49617 if (PyErr_Occurred()) SWIG_fail;
49618 }
49619 {
49620 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49621 }
49622 return resultobj;
49623 fail:
49624 return NULL;
49625 }
49626
49627
49628 SWIGINTERN PyObject *_wrap_SizerFlags_Bottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49629 PyObject *resultobj = 0;
49630 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49631 wxSizerFlags *result = 0 ;
49632 void *argp1 = 0 ;
49633 int res1 = 0 ;
49634 PyObject *swig_obj[1] ;
49635
49636 if (!args) SWIG_fail;
49637 swig_obj[0] = args;
49638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49639 if (!SWIG_IsOK(res1)) {
49640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Bottom" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49641 }
49642 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49643 {
49644 PyThreadState* __tstate = wxPyBeginAllowThreads();
49645 {
49646 wxSizerFlags &_result_ref = (arg1)->Bottom();
49647 result = (wxSizerFlags *) &_result_ref;
49648 }
49649 wxPyEndAllowThreads(__tstate);
49650 if (PyErr_Occurred()) SWIG_fail;
49651 }
49652 {
49653 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49654 }
49655 return resultobj;
49656 fail:
49657 return NULL;
49658 }
49659
49660
49661 SWIGINTERN PyObject *_wrap_SizerFlags_Shaped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49662 PyObject *resultobj = 0;
49663 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49664 wxSizerFlags *result = 0 ;
49665 void *argp1 = 0 ;
49666 int res1 = 0 ;
49667 PyObject *swig_obj[1] ;
49668
49669 if (!args) SWIG_fail;
49670 swig_obj[0] = args;
49671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49672 if (!SWIG_IsOK(res1)) {
49673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Shaped" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49674 }
49675 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49676 {
49677 PyThreadState* __tstate = wxPyBeginAllowThreads();
49678 {
49679 wxSizerFlags &_result_ref = (arg1)->Shaped();
49680 result = (wxSizerFlags *) &_result_ref;
49681 }
49682 wxPyEndAllowThreads(__tstate);
49683 if (PyErr_Occurred()) SWIG_fail;
49684 }
49685 {
49686 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49687 }
49688 return resultobj;
49689 fail:
49690 return NULL;
49691 }
49692
49693
49694 SWIGINTERN PyObject *_wrap_SizerFlags_FixedMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49695 PyObject *resultobj = 0;
49696 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49697 wxSizerFlags *result = 0 ;
49698 void *argp1 = 0 ;
49699 int res1 = 0 ;
49700 PyObject *swig_obj[1] ;
49701
49702 if (!args) SWIG_fail;
49703 swig_obj[0] = args;
49704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49705 if (!SWIG_IsOK(res1)) {
49706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_FixedMinSize" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49707 }
49708 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49709 {
49710 PyThreadState* __tstate = wxPyBeginAllowThreads();
49711 {
49712 wxSizerFlags &_result_ref = (arg1)->FixedMinSize();
49713 result = (wxSizerFlags *) &_result_ref;
49714 }
49715 wxPyEndAllowThreads(__tstate);
49716 if (PyErr_Occurred()) SWIG_fail;
49717 }
49718 {
49719 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49720 }
49721 return resultobj;
49722 fail:
49723 return NULL;
49724 }
49725
49726
49727 SWIGINTERN PyObject *_wrap_SizerFlags_Border(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49728 PyObject *resultobj = 0;
49729 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49730 int arg2 = (int) wxALL ;
49731 int arg3 = (int) -1 ;
49732 wxSizerFlags *result = 0 ;
49733 void *argp1 = 0 ;
49734 int res1 = 0 ;
49735 int val2 ;
49736 int ecode2 = 0 ;
49737 int val3 ;
49738 int ecode3 = 0 ;
49739 PyObject * obj0 = 0 ;
49740 PyObject * obj1 = 0 ;
49741 PyObject * obj2 = 0 ;
49742 char * kwnames[] = {
49743 (char *) "self",(char *) "direction",(char *) "borderInPixels", NULL
49744 };
49745
49746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:SizerFlags_Border",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49748 if (!SWIG_IsOK(res1)) {
49749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Border" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49750 }
49751 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49752 if (obj1) {
49753 ecode2 = SWIG_AsVal_int(obj1, &val2);
49754 if (!SWIG_IsOK(ecode2)) {
49755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_Border" "', expected argument " "2"" of type '" "int""'");
49756 }
49757 arg2 = static_cast< int >(val2);
49758 }
49759 if (obj2) {
49760 ecode3 = SWIG_AsVal_int(obj2, &val3);
49761 if (!SWIG_IsOK(ecode3)) {
49762 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerFlags_Border" "', expected argument " "3"" of type '" "int""'");
49763 }
49764 arg3 = static_cast< int >(val3);
49765 }
49766 {
49767 PyThreadState* __tstate = wxPyBeginAllowThreads();
49768 {
49769 wxSizerFlags &_result_ref = wxSizerFlags_Border(arg1,arg2,arg3);
49770 result = (wxSizerFlags *) &_result_ref;
49771 }
49772 wxPyEndAllowThreads(__tstate);
49773 if (PyErr_Occurred()) SWIG_fail;
49774 }
49775 {
49776 resultobj = obj0; Py_INCREF(resultobj);
49777 }
49778 return resultobj;
49779 fail:
49780 return NULL;
49781 }
49782
49783
49784 SWIGINTERN PyObject *_wrap_SizerFlags_DoubleBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49785 PyObject *resultobj = 0;
49786 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49787 int arg2 = (int) wxALL ;
49788 wxSizerFlags *result = 0 ;
49789 void *argp1 = 0 ;
49790 int res1 = 0 ;
49791 int val2 ;
49792 int ecode2 = 0 ;
49793 PyObject * obj0 = 0 ;
49794 PyObject * obj1 = 0 ;
49795 char * kwnames[] = {
49796 (char *) "self",(char *) "direction", NULL
49797 };
49798
49799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SizerFlags_DoubleBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49801 if (!SWIG_IsOK(res1)) {
49802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_DoubleBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49803 }
49804 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49805 if (obj1) {
49806 ecode2 = SWIG_AsVal_int(obj1, &val2);
49807 if (!SWIG_IsOK(ecode2)) {
49808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_DoubleBorder" "', expected argument " "2"" of type '" "int""'");
49809 }
49810 arg2 = static_cast< int >(val2);
49811 }
49812 {
49813 PyThreadState* __tstate = wxPyBeginAllowThreads();
49814 {
49815 wxSizerFlags &_result_ref = (arg1)->DoubleBorder(arg2);
49816 result = (wxSizerFlags *) &_result_ref;
49817 }
49818 wxPyEndAllowThreads(__tstate);
49819 if (PyErr_Occurred()) SWIG_fail;
49820 }
49821 {
49822 resultobj = obj0; Py_INCREF(resultobj);
49823 }
49824 return resultobj;
49825 fail:
49826 return NULL;
49827 }
49828
49829
49830 SWIGINTERN PyObject *_wrap_SizerFlags_TripleBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49831 PyObject *resultobj = 0;
49832 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49833 int arg2 = (int) wxALL ;
49834 wxSizerFlags *result = 0 ;
49835 void *argp1 = 0 ;
49836 int res1 = 0 ;
49837 int val2 ;
49838 int ecode2 = 0 ;
49839 PyObject * obj0 = 0 ;
49840 PyObject * obj1 = 0 ;
49841 char * kwnames[] = {
49842 (char *) "self",(char *) "direction", NULL
49843 };
49844
49845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SizerFlags_TripleBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49847 if (!SWIG_IsOK(res1)) {
49848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_TripleBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49849 }
49850 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49851 if (obj1) {
49852 ecode2 = SWIG_AsVal_int(obj1, &val2);
49853 if (!SWIG_IsOK(ecode2)) {
49854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_TripleBorder" "', expected argument " "2"" of type '" "int""'");
49855 }
49856 arg2 = static_cast< int >(val2);
49857 }
49858 {
49859 PyThreadState* __tstate = wxPyBeginAllowThreads();
49860 {
49861 wxSizerFlags &_result_ref = (arg1)->TripleBorder(arg2);
49862 result = (wxSizerFlags *) &_result_ref;
49863 }
49864 wxPyEndAllowThreads(__tstate);
49865 if (PyErr_Occurred()) SWIG_fail;
49866 }
49867 {
49868 resultobj = obj0; Py_INCREF(resultobj);
49869 }
49870 return resultobj;
49871 fail:
49872 return NULL;
49873 }
49874
49875
49876 SWIGINTERN PyObject *_wrap_SizerFlags_HorzBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49877 PyObject *resultobj = 0;
49878 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49879 wxSizerFlags *result = 0 ;
49880 void *argp1 = 0 ;
49881 int res1 = 0 ;
49882 PyObject *swig_obj[1] ;
49883
49884 if (!args) SWIG_fail;
49885 swig_obj[0] = args;
49886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49887 if (!SWIG_IsOK(res1)) {
49888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_HorzBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49889 }
49890 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49891 {
49892 PyThreadState* __tstate = wxPyBeginAllowThreads();
49893 {
49894 wxSizerFlags &_result_ref = (arg1)->HorzBorder();
49895 result = (wxSizerFlags *) &_result_ref;
49896 }
49897 wxPyEndAllowThreads(__tstate);
49898 if (PyErr_Occurred()) SWIG_fail;
49899 }
49900 {
49901 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49902 }
49903 return resultobj;
49904 fail:
49905 return NULL;
49906 }
49907
49908
49909 SWIGINTERN PyObject *_wrap_SizerFlags_DoubleHorzBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49910 PyObject *resultobj = 0;
49911 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49912 wxSizerFlags *result = 0 ;
49913 void *argp1 = 0 ;
49914 int res1 = 0 ;
49915 PyObject *swig_obj[1] ;
49916
49917 if (!args) SWIG_fail;
49918 swig_obj[0] = args;
49919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49920 if (!SWIG_IsOK(res1)) {
49921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_DoubleHorzBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49922 }
49923 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49924 {
49925 PyThreadState* __tstate = wxPyBeginAllowThreads();
49926 {
49927 wxSizerFlags &_result_ref = (arg1)->DoubleHorzBorder();
49928 result = (wxSizerFlags *) &_result_ref;
49929 }
49930 wxPyEndAllowThreads(__tstate);
49931 if (PyErr_Occurred()) SWIG_fail;
49932 }
49933 {
49934 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49935 }
49936 return resultobj;
49937 fail:
49938 return NULL;
49939 }
49940
49941
49942 SWIGINTERN PyObject *_wrap_SizerFlags_GetDefaultBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49943 PyObject *resultobj = 0;
49944 int result;
49945
49946 if (!SWIG_Python_UnpackTuple(args,"SizerFlags_GetDefaultBorder",0,0,0)) SWIG_fail;
49947 {
49948 PyThreadState* __tstate = wxPyBeginAllowThreads();
49949 result = (int)wxSizerFlags::GetDefaultBorder();
49950 wxPyEndAllowThreads(__tstate);
49951 if (PyErr_Occurred()) SWIG_fail;
49952 }
49953 resultobj = SWIG_From_int(static_cast< int >(result));
49954 return resultobj;
49955 fail:
49956 return NULL;
49957 }
49958
49959
49960 SWIGINTERN PyObject *_wrap_SizerFlags_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49961 PyObject *resultobj = 0;
49962 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49963 int result;
49964 void *argp1 = 0 ;
49965 int res1 = 0 ;
49966 PyObject *swig_obj[1] ;
49967
49968 if (!args) SWIG_fail;
49969 swig_obj[0] = args;
49970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49971 if (!SWIG_IsOK(res1)) {
49972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_GetProportion" "', expected argument " "1"" of type '" "wxSizerFlags const *""'");
49973 }
49974 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49975 {
49976 PyThreadState* __tstate = wxPyBeginAllowThreads();
49977 result = (int)((wxSizerFlags const *)arg1)->GetProportion();
49978 wxPyEndAllowThreads(__tstate);
49979 if (PyErr_Occurred()) SWIG_fail;
49980 }
49981 resultobj = SWIG_From_int(static_cast< int >(result));
49982 return resultobj;
49983 fail:
49984 return NULL;
49985 }
49986
49987
49988 SWIGINTERN PyObject *_wrap_SizerFlags_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49989 PyObject *resultobj = 0;
49990 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49991 int result;
49992 void *argp1 = 0 ;
49993 int res1 = 0 ;
49994 PyObject *swig_obj[1] ;
49995
49996 if (!args) SWIG_fail;
49997 swig_obj[0] = args;
49998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49999 if (!SWIG_IsOK(res1)) {
50000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_GetFlags" "', expected argument " "1"" of type '" "wxSizerFlags const *""'");
50001 }
50002 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
50003 {
50004 PyThreadState* __tstate = wxPyBeginAllowThreads();
50005 result = (int)((wxSizerFlags const *)arg1)->GetFlags();
50006 wxPyEndAllowThreads(__tstate);
50007 if (PyErr_Occurred()) SWIG_fail;
50008 }
50009 resultobj = SWIG_From_int(static_cast< int >(result));
50010 return resultobj;
50011 fail:
50012 return NULL;
50013 }
50014
50015
50016 SWIGINTERN PyObject *_wrap_SizerFlags_GetBorderInPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50017 PyObject *resultobj = 0;
50018 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
50019 int result;
50020 void *argp1 = 0 ;
50021 int res1 = 0 ;
50022 PyObject *swig_obj[1] ;
50023
50024 if (!args) SWIG_fail;
50025 swig_obj[0] = args;
50026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
50027 if (!SWIG_IsOK(res1)) {
50028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_GetBorderInPixels" "', expected argument " "1"" of type '" "wxSizerFlags const *""'");
50029 }
50030 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
50031 {
50032 PyThreadState* __tstate = wxPyBeginAllowThreads();
50033 result = (int)((wxSizerFlags const *)arg1)->GetBorderInPixels();
50034 wxPyEndAllowThreads(__tstate);
50035 if (PyErr_Occurred()) SWIG_fail;
50036 }
50037 resultobj = SWIG_From_int(static_cast< int >(result));
50038 return resultobj;
50039 fail:
50040 return NULL;
50041 }
50042
50043
50044 SWIGINTERN PyObject *SizerFlags_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50045 PyObject *obj;
50046 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50047 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerFlags, SWIG_NewClientData(obj));
50048 return SWIG_Py_Void();
50049 }
50050
50051 SWIGINTERN PyObject *SizerFlags_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50052 return SWIG_Python_InitShadowInstance(args);
50053 }
50054
50055 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50056 PyObject *resultobj = 0;
50057 wxSizerItem *result = 0 ;
50058
50059 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
50060 {
50061 PyThreadState* __tstate = wxPyBeginAllowThreads();
50062 result = (wxSizerItem *)new wxSizerItem();
50063 wxPyEndAllowThreads(__tstate);
50064 if (PyErr_Occurred()) SWIG_fail;
50065 }
50066 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
50067 return resultobj;
50068 fail:
50069 return NULL;
50070 }
50071
50072
50073 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50074 PyObject *resultobj = 0;
50075 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50076 void *argp1 = 0 ;
50077 int res1 = 0 ;
50078 PyObject *swig_obj[1] ;
50079
50080 if (!args) SWIG_fail;
50081 swig_obj[0] = args;
50082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50083 if (!SWIG_IsOK(res1)) {
50084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50085 }
50086 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50087 {
50088 PyThreadState* __tstate = wxPyBeginAllowThreads();
50089 delete arg1;
50090
50091 wxPyEndAllowThreads(__tstate);
50092 if (PyErr_Occurred()) SWIG_fail;
50093 }
50094 resultobj = SWIG_Py_Void();
50095 return resultobj;
50096 fail:
50097 return NULL;
50098 }
50099
50100
50101 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50102 PyObject *resultobj = 0;
50103 wxWindow *arg1 = (wxWindow *) 0 ;
50104 int arg2 ;
50105 int arg3 ;
50106 int arg4 ;
50107 PyObject *arg5 = (PyObject *) NULL ;
50108 wxSizerItem *result = 0 ;
50109 void *argp1 = 0 ;
50110 int res1 = 0 ;
50111 int val2 ;
50112 int ecode2 = 0 ;
50113 int val3 ;
50114 int ecode3 = 0 ;
50115 int val4 ;
50116 int ecode4 = 0 ;
50117 PyObject * obj0 = 0 ;
50118 PyObject * obj1 = 0 ;
50119 PyObject * obj2 = 0 ;
50120 PyObject * obj3 = 0 ;
50121 PyObject * obj4 = 0 ;
50122 char * kwnames[] = {
50123 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
50124 };
50125
50126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
50127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
50128 if (!SWIG_IsOK(res1)) {
50129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
50130 }
50131 arg1 = reinterpret_cast< wxWindow * >(argp1);
50132 ecode2 = SWIG_AsVal_int(obj1, &val2);
50133 if (!SWIG_IsOK(ecode2)) {
50134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
50135 }
50136 arg2 = static_cast< int >(val2);
50137 ecode3 = SWIG_AsVal_int(obj2, &val3);
50138 if (!SWIG_IsOK(ecode3)) {
50139 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
50140 }
50141 arg3 = static_cast< int >(val3);
50142 ecode4 = SWIG_AsVal_int(obj3, &val4);
50143 if (!SWIG_IsOK(ecode4)) {
50144 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
50145 }
50146 arg4 = static_cast< int >(val4);
50147 if (obj4) {
50148 arg5 = obj4;
50149 }
50150 {
50151 PyThreadState* __tstate = wxPyBeginAllowThreads();
50152 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
50153 wxPyEndAllowThreads(__tstate);
50154 if (PyErr_Occurred()) SWIG_fail;
50155 }
50156 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
50157 return resultobj;
50158 fail:
50159 return NULL;
50160 }
50161
50162
50163 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50164 PyObject *resultobj = 0;
50165 int arg1 ;
50166 int arg2 ;
50167 int arg3 ;
50168 int arg4 ;
50169 int arg5 ;
50170 PyObject *arg6 = (PyObject *) NULL ;
50171 wxSizerItem *result = 0 ;
50172 int val1 ;
50173 int ecode1 = 0 ;
50174 int val2 ;
50175 int ecode2 = 0 ;
50176 int val3 ;
50177 int ecode3 = 0 ;
50178 int val4 ;
50179 int ecode4 = 0 ;
50180 int val5 ;
50181 int ecode5 = 0 ;
50182 PyObject * obj0 = 0 ;
50183 PyObject * obj1 = 0 ;
50184 PyObject * obj2 = 0 ;
50185 PyObject * obj3 = 0 ;
50186 PyObject * obj4 = 0 ;
50187 PyObject * obj5 = 0 ;
50188 char * kwnames[] = {
50189 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
50190 };
50191
50192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50193 ecode1 = SWIG_AsVal_int(obj0, &val1);
50194 if (!SWIG_IsOK(ecode1)) {
50195 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
50196 }
50197 arg1 = static_cast< int >(val1);
50198 ecode2 = SWIG_AsVal_int(obj1, &val2);
50199 if (!SWIG_IsOK(ecode2)) {
50200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
50201 }
50202 arg2 = static_cast< int >(val2);
50203 ecode3 = SWIG_AsVal_int(obj2, &val3);
50204 if (!SWIG_IsOK(ecode3)) {
50205 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
50206 }
50207 arg3 = static_cast< int >(val3);
50208 ecode4 = SWIG_AsVal_int(obj3, &val4);
50209 if (!SWIG_IsOK(ecode4)) {
50210 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
50211 }
50212 arg4 = static_cast< int >(val4);
50213 ecode5 = SWIG_AsVal_int(obj4, &val5);
50214 if (!SWIG_IsOK(ecode5)) {
50215 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
50216 }
50217 arg5 = static_cast< int >(val5);
50218 if (obj5) {
50219 arg6 = obj5;
50220 }
50221 {
50222 PyThreadState* __tstate = wxPyBeginAllowThreads();
50223 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
50224 wxPyEndAllowThreads(__tstate);
50225 if (PyErr_Occurred()) SWIG_fail;
50226 }
50227 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
50228 return resultobj;
50229 fail:
50230 return NULL;
50231 }
50232
50233
50234 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50235 PyObject *resultobj = 0;
50236 wxSizer *arg1 = (wxSizer *) 0 ;
50237 int arg2 ;
50238 int arg3 ;
50239 int arg4 ;
50240 PyObject *arg5 = (PyObject *) NULL ;
50241 wxSizerItem *result = 0 ;
50242 int res1 = 0 ;
50243 int val2 ;
50244 int ecode2 = 0 ;
50245 int val3 ;
50246 int ecode3 = 0 ;
50247 int val4 ;
50248 int ecode4 = 0 ;
50249 PyObject * obj0 = 0 ;
50250 PyObject * obj1 = 0 ;
50251 PyObject * obj2 = 0 ;
50252 PyObject * obj3 = 0 ;
50253 PyObject * obj4 = 0 ;
50254 char * kwnames[] = {
50255 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
50256 };
50257
50258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
50259 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
50260 if (!SWIG_IsOK(res1)) {
50261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50262 }
50263 ecode2 = SWIG_AsVal_int(obj1, &val2);
50264 if (!SWIG_IsOK(ecode2)) {
50265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
50266 }
50267 arg2 = static_cast< int >(val2);
50268 ecode3 = SWIG_AsVal_int(obj2, &val3);
50269 if (!SWIG_IsOK(ecode3)) {
50270 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
50271 }
50272 arg3 = static_cast< int >(val3);
50273 ecode4 = SWIG_AsVal_int(obj3, &val4);
50274 if (!SWIG_IsOK(ecode4)) {
50275 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
50276 }
50277 arg4 = static_cast< int >(val4);
50278 if (obj4) {
50279 arg5 = obj4;
50280 }
50281 {
50282 PyThreadState* __tstate = wxPyBeginAllowThreads();
50283 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
50284 wxPyEndAllowThreads(__tstate);
50285 if (PyErr_Occurred()) SWIG_fail;
50286 }
50287 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
50288 return resultobj;
50289 fail:
50290 return NULL;
50291 }
50292
50293
50294 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50295 PyObject *resultobj = 0;
50296 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50297 void *argp1 = 0 ;
50298 int res1 = 0 ;
50299 PyObject *swig_obj[1] ;
50300
50301 if (!args) SWIG_fail;
50302 swig_obj[0] = args;
50303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50304 if (!SWIG_IsOK(res1)) {
50305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50306 }
50307 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50308 {
50309 PyThreadState* __tstate = wxPyBeginAllowThreads();
50310 (arg1)->DeleteWindows();
50311 wxPyEndAllowThreads(__tstate);
50312 if (PyErr_Occurred()) SWIG_fail;
50313 }
50314 resultobj = SWIG_Py_Void();
50315 return resultobj;
50316 fail:
50317 return NULL;
50318 }
50319
50320
50321 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50322 PyObject *resultobj = 0;
50323 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50324 void *argp1 = 0 ;
50325 int res1 = 0 ;
50326 PyObject *swig_obj[1] ;
50327
50328 if (!args) SWIG_fail;
50329 swig_obj[0] = args;
50330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50331 if (!SWIG_IsOK(res1)) {
50332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50333 }
50334 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50335 {
50336 PyThreadState* __tstate = wxPyBeginAllowThreads();
50337 (arg1)->DetachSizer();
50338 wxPyEndAllowThreads(__tstate);
50339 if (PyErr_Occurred()) SWIG_fail;
50340 }
50341 resultobj = SWIG_Py_Void();
50342 return resultobj;
50343 fail:
50344 return NULL;
50345 }
50346
50347
50348 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50349 PyObject *resultobj = 0;
50350 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50351 wxSize result;
50352 void *argp1 = 0 ;
50353 int res1 = 0 ;
50354 PyObject *swig_obj[1] ;
50355
50356 if (!args) SWIG_fail;
50357 swig_obj[0] = args;
50358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50359 if (!SWIG_IsOK(res1)) {
50360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50361 }
50362 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50363 {
50364 PyThreadState* __tstate = wxPyBeginAllowThreads();
50365 result = (arg1)->GetSize();
50366 wxPyEndAllowThreads(__tstate);
50367 if (PyErr_Occurred()) SWIG_fail;
50368 }
50369 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50370 return resultobj;
50371 fail:
50372 return NULL;
50373 }
50374
50375
50376 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50377 PyObject *resultobj = 0;
50378 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50379 wxSize result;
50380 void *argp1 = 0 ;
50381 int res1 = 0 ;
50382 PyObject *swig_obj[1] ;
50383
50384 if (!args) SWIG_fail;
50385 swig_obj[0] = args;
50386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50387 if (!SWIG_IsOK(res1)) {
50388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50389 }
50390 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50391 {
50392 PyThreadState* __tstate = wxPyBeginAllowThreads();
50393 result = (arg1)->CalcMin();
50394 wxPyEndAllowThreads(__tstate);
50395 if (PyErr_Occurred()) SWIG_fail;
50396 }
50397 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50398 return resultobj;
50399 fail:
50400 return NULL;
50401 }
50402
50403
50404 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50405 PyObject *resultobj = 0;
50406 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50407 wxPoint *arg2 = 0 ;
50408 wxSize *arg3 = 0 ;
50409 void *argp1 = 0 ;
50410 int res1 = 0 ;
50411 wxPoint temp2 ;
50412 wxSize temp3 ;
50413 PyObject * obj0 = 0 ;
50414 PyObject * obj1 = 0 ;
50415 PyObject * obj2 = 0 ;
50416 char * kwnames[] = {
50417 (char *) "self",(char *) "pos",(char *) "size", NULL
50418 };
50419
50420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50422 if (!SWIG_IsOK(res1)) {
50423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50424 }
50425 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50426 {
50427 arg2 = &temp2;
50428 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
50429 }
50430 {
50431 arg3 = &temp3;
50432 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
50433 }
50434 {
50435 PyThreadState* __tstate = wxPyBeginAllowThreads();
50436 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
50437 wxPyEndAllowThreads(__tstate);
50438 if (PyErr_Occurred()) SWIG_fail;
50439 }
50440 resultobj = SWIG_Py_Void();
50441 return resultobj;
50442 fail:
50443 return NULL;
50444 }
50445
50446
50447 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50448 PyObject *resultobj = 0;
50449 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50450 wxSize result;
50451 void *argp1 = 0 ;
50452 int res1 = 0 ;
50453 PyObject *swig_obj[1] ;
50454
50455 if (!args) SWIG_fail;
50456 swig_obj[0] = args;
50457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50458 if (!SWIG_IsOK(res1)) {
50459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50460 }
50461 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50462 {
50463 PyThreadState* __tstate = wxPyBeginAllowThreads();
50464 result = (arg1)->GetMinSize();
50465 wxPyEndAllowThreads(__tstate);
50466 if (PyErr_Occurred()) SWIG_fail;
50467 }
50468 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50469 return resultobj;
50470 fail:
50471 return NULL;
50472 }
50473
50474
50475 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50476 PyObject *resultobj = 0;
50477 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50478 wxSize result;
50479 void *argp1 = 0 ;
50480 int res1 = 0 ;
50481 PyObject *swig_obj[1] ;
50482
50483 if (!args) SWIG_fail;
50484 swig_obj[0] = args;
50485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50486 if (!SWIG_IsOK(res1)) {
50487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
50488 }
50489 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50490 {
50491 PyThreadState* __tstate = wxPyBeginAllowThreads();
50492 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
50493 wxPyEndAllowThreads(__tstate);
50494 if (PyErr_Occurred()) SWIG_fail;
50495 }
50496 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50497 return resultobj;
50498 fail:
50499 return NULL;
50500 }
50501
50502
50503 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50504 PyObject *resultobj = 0;
50505 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50506 int arg2 ;
50507 int arg3 ;
50508 void *argp1 = 0 ;
50509 int res1 = 0 ;
50510 int val2 ;
50511 int ecode2 = 0 ;
50512 int val3 ;
50513 int ecode3 = 0 ;
50514 PyObject * obj0 = 0 ;
50515 PyObject * obj1 = 0 ;
50516 PyObject * obj2 = 0 ;
50517 char * kwnames[] = {
50518 (char *) "self",(char *) "x",(char *) "y", NULL
50519 };
50520
50521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50523 if (!SWIG_IsOK(res1)) {
50524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50525 }
50526 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50527 ecode2 = SWIG_AsVal_int(obj1, &val2);
50528 if (!SWIG_IsOK(ecode2)) {
50529 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
50530 }
50531 arg2 = static_cast< int >(val2);
50532 ecode3 = SWIG_AsVal_int(obj2, &val3);
50533 if (!SWIG_IsOK(ecode3)) {
50534 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
50535 }
50536 arg3 = static_cast< int >(val3);
50537 {
50538 PyThreadState* __tstate = wxPyBeginAllowThreads();
50539 (arg1)->SetInitSize(arg2,arg3);
50540 wxPyEndAllowThreads(__tstate);
50541 if (PyErr_Occurred()) SWIG_fail;
50542 }
50543 resultobj = SWIG_Py_Void();
50544 return resultobj;
50545 fail:
50546 return NULL;
50547 }
50548
50549
50550 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50551 PyObject *resultobj = 0;
50552 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50553 int arg2 ;
50554 int arg3 ;
50555 void *argp1 = 0 ;
50556 int res1 = 0 ;
50557 int val2 ;
50558 int ecode2 = 0 ;
50559 int val3 ;
50560 int ecode3 = 0 ;
50561 PyObject * obj0 = 0 ;
50562 PyObject * obj1 = 0 ;
50563 PyObject * obj2 = 0 ;
50564 char * kwnames[] = {
50565 (char *) "self",(char *) "width",(char *) "height", NULL
50566 };
50567
50568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50570 if (!SWIG_IsOK(res1)) {
50571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50572 }
50573 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50574 ecode2 = SWIG_AsVal_int(obj1, &val2);
50575 if (!SWIG_IsOK(ecode2)) {
50576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
50577 }
50578 arg2 = static_cast< int >(val2);
50579 ecode3 = SWIG_AsVal_int(obj2, &val3);
50580 if (!SWIG_IsOK(ecode3)) {
50581 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
50582 }
50583 arg3 = static_cast< int >(val3);
50584 {
50585 PyThreadState* __tstate = wxPyBeginAllowThreads();
50586 (arg1)->SetRatio(arg2,arg3);
50587 wxPyEndAllowThreads(__tstate);
50588 if (PyErr_Occurred()) SWIG_fail;
50589 }
50590 resultobj = SWIG_Py_Void();
50591 return resultobj;
50592 fail:
50593 return NULL;
50594 }
50595
50596
50597 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50598 PyObject *resultobj = 0;
50599 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50600 wxSize *arg2 = 0 ;
50601 void *argp1 = 0 ;
50602 int res1 = 0 ;
50603 wxSize temp2 ;
50604 PyObject * obj0 = 0 ;
50605 PyObject * obj1 = 0 ;
50606 char * kwnames[] = {
50607 (char *) "self",(char *) "size", NULL
50608 };
50609
50610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
50611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50612 if (!SWIG_IsOK(res1)) {
50613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50614 }
50615 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50616 {
50617 arg2 = &temp2;
50618 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50619 }
50620 {
50621 PyThreadState* __tstate = wxPyBeginAllowThreads();
50622 (arg1)->SetRatio((wxSize const &)*arg2);
50623 wxPyEndAllowThreads(__tstate);
50624 if (PyErr_Occurred()) SWIG_fail;
50625 }
50626 resultobj = SWIG_Py_Void();
50627 return resultobj;
50628 fail:
50629 return NULL;
50630 }
50631
50632
50633 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50634 PyObject *resultobj = 0;
50635 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50636 float arg2 ;
50637 void *argp1 = 0 ;
50638 int res1 = 0 ;
50639 float val2 ;
50640 int ecode2 = 0 ;
50641 PyObject * obj0 = 0 ;
50642 PyObject * obj1 = 0 ;
50643 char * kwnames[] = {
50644 (char *) "self",(char *) "ratio", NULL
50645 };
50646
50647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
50648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50649 if (!SWIG_IsOK(res1)) {
50650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50651 }
50652 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50653 ecode2 = SWIG_AsVal_float(obj1, &val2);
50654 if (!SWIG_IsOK(ecode2)) {
50655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
50656 }
50657 arg2 = static_cast< float >(val2);
50658 {
50659 PyThreadState* __tstate = wxPyBeginAllowThreads();
50660 (arg1)->SetRatio(arg2);
50661 wxPyEndAllowThreads(__tstate);
50662 if (PyErr_Occurred()) SWIG_fail;
50663 }
50664 resultobj = SWIG_Py_Void();
50665 return resultobj;
50666 fail:
50667 return NULL;
50668 }
50669
50670
50671 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50672 PyObject *resultobj = 0;
50673 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50674 float result;
50675 void *argp1 = 0 ;
50676 int res1 = 0 ;
50677 PyObject *swig_obj[1] ;
50678
50679 if (!args) SWIG_fail;
50680 swig_obj[0] = args;
50681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50682 if (!SWIG_IsOK(res1)) {
50683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50684 }
50685 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50686 {
50687 PyThreadState* __tstate = wxPyBeginAllowThreads();
50688 result = (float)(arg1)->GetRatio();
50689 wxPyEndAllowThreads(__tstate);
50690 if (PyErr_Occurred()) SWIG_fail;
50691 }
50692 resultobj = SWIG_From_float(static_cast< float >(result));
50693 return resultobj;
50694 fail:
50695 return NULL;
50696 }
50697
50698
50699 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50700 PyObject *resultobj = 0;
50701 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50702 wxRect result;
50703 void *argp1 = 0 ;
50704 int res1 = 0 ;
50705 PyObject *swig_obj[1] ;
50706
50707 if (!args) SWIG_fail;
50708 swig_obj[0] = args;
50709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50710 if (!SWIG_IsOK(res1)) {
50711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50712 }
50713 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50714 {
50715 PyThreadState* __tstate = wxPyBeginAllowThreads();
50716 result = (arg1)->GetRect();
50717 wxPyEndAllowThreads(__tstate);
50718 if (PyErr_Occurred()) SWIG_fail;
50719 }
50720 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
50721 return resultobj;
50722 fail:
50723 return NULL;
50724 }
50725
50726
50727 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50728 PyObject *resultobj = 0;
50729 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50730 bool result;
50731 void *argp1 = 0 ;
50732 int res1 = 0 ;
50733 PyObject *swig_obj[1] ;
50734
50735 if (!args) SWIG_fail;
50736 swig_obj[0] = args;
50737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50738 if (!SWIG_IsOK(res1)) {
50739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50740 }
50741 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50742 {
50743 PyThreadState* __tstate = wxPyBeginAllowThreads();
50744 result = (bool)(arg1)->IsWindow();
50745 wxPyEndAllowThreads(__tstate);
50746 if (PyErr_Occurred()) SWIG_fail;
50747 }
50748 {
50749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50750 }
50751 return resultobj;
50752 fail:
50753 return NULL;
50754 }
50755
50756
50757 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50758 PyObject *resultobj = 0;
50759 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50760 bool result;
50761 void *argp1 = 0 ;
50762 int res1 = 0 ;
50763 PyObject *swig_obj[1] ;
50764
50765 if (!args) SWIG_fail;
50766 swig_obj[0] = args;
50767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50768 if (!SWIG_IsOK(res1)) {
50769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50770 }
50771 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50772 {
50773 PyThreadState* __tstate = wxPyBeginAllowThreads();
50774 result = (bool)(arg1)->IsSizer();
50775 wxPyEndAllowThreads(__tstate);
50776 if (PyErr_Occurred()) SWIG_fail;
50777 }
50778 {
50779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50780 }
50781 return resultobj;
50782 fail:
50783 return NULL;
50784 }
50785
50786
50787 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50788 PyObject *resultobj = 0;
50789 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50790 bool result;
50791 void *argp1 = 0 ;
50792 int res1 = 0 ;
50793 PyObject *swig_obj[1] ;
50794
50795 if (!args) SWIG_fail;
50796 swig_obj[0] = args;
50797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50798 if (!SWIG_IsOK(res1)) {
50799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50800 }
50801 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50802 {
50803 PyThreadState* __tstate = wxPyBeginAllowThreads();
50804 result = (bool)(arg1)->IsSpacer();
50805 wxPyEndAllowThreads(__tstate);
50806 if (PyErr_Occurred()) SWIG_fail;
50807 }
50808 {
50809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50810 }
50811 return resultobj;
50812 fail:
50813 return NULL;
50814 }
50815
50816
50817 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50818 PyObject *resultobj = 0;
50819 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50820 int arg2 ;
50821 void *argp1 = 0 ;
50822 int res1 = 0 ;
50823 int val2 ;
50824 int ecode2 = 0 ;
50825 PyObject * obj0 = 0 ;
50826 PyObject * obj1 = 0 ;
50827 char * kwnames[] = {
50828 (char *) "self",(char *) "proportion", NULL
50829 };
50830
50831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
50832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50833 if (!SWIG_IsOK(res1)) {
50834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50835 }
50836 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50837 ecode2 = SWIG_AsVal_int(obj1, &val2);
50838 if (!SWIG_IsOK(ecode2)) {
50839 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
50840 }
50841 arg2 = static_cast< int >(val2);
50842 {
50843 PyThreadState* __tstate = wxPyBeginAllowThreads();
50844 (arg1)->SetProportion(arg2);
50845 wxPyEndAllowThreads(__tstate);
50846 if (PyErr_Occurred()) SWIG_fail;
50847 }
50848 resultobj = SWIG_Py_Void();
50849 return resultobj;
50850 fail:
50851 return NULL;
50852 }
50853
50854
50855 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50856 PyObject *resultobj = 0;
50857 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50858 int result;
50859 void *argp1 = 0 ;
50860 int res1 = 0 ;
50861 PyObject *swig_obj[1] ;
50862
50863 if (!args) SWIG_fail;
50864 swig_obj[0] = args;
50865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50866 if (!SWIG_IsOK(res1)) {
50867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50868 }
50869 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50870 {
50871 PyThreadState* __tstate = wxPyBeginAllowThreads();
50872 result = (int)(arg1)->GetProportion();
50873 wxPyEndAllowThreads(__tstate);
50874 if (PyErr_Occurred()) SWIG_fail;
50875 }
50876 resultobj = SWIG_From_int(static_cast< int >(result));
50877 return resultobj;
50878 fail:
50879 return NULL;
50880 }
50881
50882
50883 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50884 PyObject *resultobj = 0;
50885 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50886 int arg2 ;
50887 void *argp1 = 0 ;
50888 int res1 = 0 ;
50889 int val2 ;
50890 int ecode2 = 0 ;
50891 PyObject * obj0 = 0 ;
50892 PyObject * obj1 = 0 ;
50893 char * kwnames[] = {
50894 (char *) "self",(char *) "flag", NULL
50895 };
50896
50897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
50898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50899 if (!SWIG_IsOK(res1)) {
50900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50901 }
50902 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50903 ecode2 = SWIG_AsVal_int(obj1, &val2);
50904 if (!SWIG_IsOK(ecode2)) {
50905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
50906 }
50907 arg2 = static_cast< int >(val2);
50908 {
50909 PyThreadState* __tstate = wxPyBeginAllowThreads();
50910 (arg1)->SetFlag(arg2);
50911 wxPyEndAllowThreads(__tstate);
50912 if (PyErr_Occurred()) SWIG_fail;
50913 }
50914 resultobj = SWIG_Py_Void();
50915 return resultobj;
50916 fail:
50917 return NULL;
50918 }
50919
50920
50921 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50922 PyObject *resultobj = 0;
50923 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50924 int result;
50925 void *argp1 = 0 ;
50926 int res1 = 0 ;
50927 PyObject *swig_obj[1] ;
50928
50929 if (!args) SWIG_fail;
50930 swig_obj[0] = args;
50931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50932 if (!SWIG_IsOK(res1)) {
50933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50934 }
50935 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50936 {
50937 PyThreadState* __tstate = wxPyBeginAllowThreads();
50938 result = (int)(arg1)->GetFlag();
50939 wxPyEndAllowThreads(__tstate);
50940 if (PyErr_Occurred()) SWIG_fail;
50941 }
50942 resultobj = SWIG_From_int(static_cast< int >(result));
50943 return resultobj;
50944 fail:
50945 return NULL;
50946 }
50947
50948
50949 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50950 PyObject *resultobj = 0;
50951 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50952 int arg2 ;
50953 void *argp1 = 0 ;
50954 int res1 = 0 ;
50955 int val2 ;
50956 int ecode2 = 0 ;
50957 PyObject * obj0 = 0 ;
50958 PyObject * obj1 = 0 ;
50959 char * kwnames[] = {
50960 (char *) "self",(char *) "border", NULL
50961 };
50962
50963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
50964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50965 if (!SWIG_IsOK(res1)) {
50966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50967 }
50968 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50969 ecode2 = SWIG_AsVal_int(obj1, &val2);
50970 if (!SWIG_IsOK(ecode2)) {
50971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
50972 }
50973 arg2 = static_cast< int >(val2);
50974 {
50975 PyThreadState* __tstate = wxPyBeginAllowThreads();
50976 (arg1)->SetBorder(arg2);
50977 wxPyEndAllowThreads(__tstate);
50978 if (PyErr_Occurred()) SWIG_fail;
50979 }
50980 resultobj = SWIG_Py_Void();
50981 return resultobj;
50982 fail:
50983 return NULL;
50984 }
50985
50986
50987 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50988 PyObject *resultobj = 0;
50989 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50990 int result;
50991 void *argp1 = 0 ;
50992 int res1 = 0 ;
50993 PyObject *swig_obj[1] ;
50994
50995 if (!args) SWIG_fail;
50996 swig_obj[0] = args;
50997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50998 if (!SWIG_IsOK(res1)) {
50999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51000 }
51001 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51002 {
51003 PyThreadState* __tstate = wxPyBeginAllowThreads();
51004 result = (int)(arg1)->GetBorder();
51005 wxPyEndAllowThreads(__tstate);
51006 if (PyErr_Occurred()) SWIG_fail;
51007 }
51008 resultobj = SWIG_From_int(static_cast< int >(result));
51009 return resultobj;
51010 fail:
51011 return NULL;
51012 }
51013
51014
51015 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51016 PyObject *resultobj = 0;
51017 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51018 wxWindow *result = 0 ;
51019 void *argp1 = 0 ;
51020 int res1 = 0 ;
51021 PyObject *swig_obj[1] ;
51022
51023 if (!args) SWIG_fail;
51024 swig_obj[0] = args;
51025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51026 if (!SWIG_IsOK(res1)) {
51027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51028 }
51029 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51030 {
51031 PyThreadState* __tstate = wxPyBeginAllowThreads();
51032 result = (wxWindow *)(arg1)->GetWindow();
51033 wxPyEndAllowThreads(__tstate);
51034 if (PyErr_Occurred()) SWIG_fail;
51035 }
51036 {
51037 resultobj = wxPyMake_wxObject(result, 0);
51038 }
51039 return resultobj;
51040 fail:
51041 return NULL;
51042 }
51043
51044
51045 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51046 PyObject *resultobj = 0;
51047 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51048 wxSizer *result = 0 ;
51049 void *argp1 = 0 ;
51050 int res1 = 0 ;
51051 PyObject *swig_obj[1] ;
51052
51053 if (!args) SWIG_fail;
51054 swig_obj[0] = args;
51055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51056 if (!SWIG_IsOK(res1)) {
51057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51058 }
51059 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51060 {
51061 PyThreadState* __tstate = wxPyBeginAllowThreads();
51062 result = (wxSizer *)(arg1)->GetSizer();
51063 wxPyEndAllowThreads(__tstate);
51064 if (PyErr_Occurred()) SWIG_fail;
51065 }
51066 {
51067 resultobj = wxPyMake_wxObject(result, (bool)0);
51068 }
51069 return resultobj;
51070 fail:
51071 return NULL;
51072 }
51073
51074
51075 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51076 PyObject *resultobj = 0;
51077 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51078 wxSize result;
51079 void *argp1 = 0 ;
51080 int res1 = 0 ;
51081 PyObject *swig_obj[1] ;
51082
51083 if (!args) SWIG_fail;
51084 swig_obj[0] = args;
51085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51086 if (!SWIG_IsOK(res1)) {
51087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51088 }
51089 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51090 {
51091 PyThreadState* __tstate = wxPyBeginAllowThreads();
51092 result = (arg1)->GetSpacer();
51093 wxPyEndAllowThreads(__tstate);
51094 if (PyErr_Occurred()) SWIG_fail;
51095 }
51096 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51097 return resultobj;
51098 fail:
51099 return NULL;
51100 }
51101
51102
51103 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51104 PyObject *resultobj = 0;
51105 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51106 wxWindow *arg2 = (wxWindow *) 0 ;
51107 void *argp1 = 0 ;
51108 int res1 = 0 ;
51109 void *argp2 = 0 ;
51110 int res2 = 0 ;
51111 PyObject * obj0 = 0 ;
51112 PyObject * obj1 = 0 ;
51113 char * kwnames[] = {
51114 (char *) "self",(char *) "window", NULL
51115 };
51116
51117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
51118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51119 if (!SWIG_IsOK(res1)) {
51120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51121 }
51122 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51123 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51124 if (!SWIG_IsOK(res2)) {
51125 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
51126 }
51127 arg2 = reinterpret_cast< wxWindow * >(argp2);
51128 {
51129 PyThreadState* __tstate = wxPyBeginAllowThreads();
51130 (arg1)->SetWindow(arg2);
51131 wxPyEndAllowThreads(__tstate);
51132 if (PyErr_Occurred()) SWIG_fail;
51133 }
51134 resultobj = SWIG_Py_Void();
51135 return resultobj;
51136 fail:
51137 return NULL;
51138 }
51139
51140
51141 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51142 PyObject *resultobj = 0;
51143 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51144 wxSizer *arg2 = (wxSizer *) 0 ;
51145 void *argp1 = 0 ;
51146 int res1 = 0 ;
51147 int res2 = 0 ;
51148 PyObject * obj0 = 0 ;
51149 PyObject * obj1 = 0 ;
51150 char * kwnames[] = {
51151 (char *) "self",(char *) "sizer", NULL
51152 };
51153
51154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51155 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51156 if (!SWIG_IsOK(res1)) {
51157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51158 }
51159 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51160 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
51161 if (!SWIG_IsOK(res2)) {
51162 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
51163 }
51164 {
51165 PyThreadState* __tstate = wxPyBeginAllowThreads();
51166 (arg1)->SetSizer(arg2);
51167 wxPyEndAllowThreads(__tstate);
51168 if (PyErr_Occurred()) SWIG_fail;
51169 }
51170 resultobj = SWIG_Py_Void();
51171 return resultobj;
51172 fail:
51173 return NULL;
51174 }
51175
51176
51177 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51178 PyObject *resultobj = 0;
51179 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51180 wxSize *arg2 = 0 ;
51181 void *argp1 = 0 ;
51182 int res1 = 0 ;
51183 wxSize temp2 ;
51184 PyObject * obj0 = 0 ;
51185 PyObject * obj1 = 0 ;
51186 char * kwnames[] = {
51187 (char *) "self",(char *) "size", NULL
51188 };
51189
51190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
51191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51192 if (!SWIG_IsOK(res1)) {
51193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51194 }
51195 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51196 {
51197 arg2 = &temp2;
51198 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
51199 }
51200 {
51201 PyThreadState* __tstate = wxPyBeginAllowThreads();
51202 (arg1)->SetSpacer((wxSize const &)*arg2);
51203 wxPyEndAllowThreads(__tstate);
51204 if (PyErr_Occurred()) SWIG_fail;
51205 }
51206 resultobj = SWIG_Py_Void();
51207 return resultobj;
51208 fail:
51209 return NULL;
51210 }
51211
51212
51213 SWIGINTERN PyObject *_wrap_SizerItem_AssignWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51214 PyObject *resultobj = 0;
51215 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51216 wxWindow *arg2 = (wxWindow *) 0 ;
51217 void *argp1 = 0 ;
51218 int res1 = 0 ;
51219 void *argp2 = 0 ;
51220 int res2 = 0 ;
51221 PyObject * obj0 = 0 ;
51222 PyObject * obj1 = 0 ;
51223 char * kwnames[] = {
51224 (char *) "self",(char *) "window", NULL
51225 };
51226
51227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_AssignWindow",kwnames,&obj0,&obj1)) SWIG_fail;
51228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51229 if (!SWIG_IsOK(res1)) {
51230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_AssignWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51231 }
51232 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51233 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51234 if (!SWIG_IsOK(res2)) {
51235 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_AssignWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
51236 }
51237 arg2 = reinterpret_cast< wxWindow * >(argp2);
51238 {
51239 PyThreadState* __tstate = wxPyBeginAllowThreads();
51240 (arg1)->AssignWindow(arg2);
51241 wxPyEndAllowThreads(__tstate);
51242 if (PyErr_Occurred()) SWIG_fail;
51243 }
51244 resultobj = SWIG_Py_Void();
51245 return resultobj;
51246 fail:
51247 return NULL;
51248 }
51249
51250
51251 SWIGINTERN PyObject *_wrap_SizerItem_AssignSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51252 PyObject *resultobj = 0;
51253 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51254 wxSizer *arg2 = (wxSizer *) 0 ;
51255 void *argp1 = 0 ;
51256 int res1 = 0 ;
51257 void *argp2 = 0 ;
51258 int res2 = 0 ;
51259 PyObject * obj0 = 0 ;
51260 PyObject * obj1 = 0 ;
51261 char * kwnames[] = {
51262 (char *) "self",(char *) "sizer", NULL
51263 };
51264
51265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_AssignSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51267 if (!SWIG_IsOK(res1)) {
51268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_AssignSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51269 }
51270 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51271 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51272 if (!SWIG_IsOK(res2)) {
51273 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_AssignSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
51274 }
51275 arg2 = reinterpret_cast< wxSizer * >(argp2);
51276 {
51277 PyThreadState* __tstate = wxPyBeginAllowThreads();
51278 (arg1)->AssignSizer(arg2);
51279 wxPyEndAllowThreads(__tstate);
51280 if (PyErr_Occurred()) SWIG_fail;
51281 }
51282 resultobj = SWIG_Py_Void();
51283 return resultobj;
51284 fail:
51285 return NULL;
51286 }
51287
51288
51289 SWIGINTERN PyObject *_wrap_SizerItem_AssignSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51290 PyObject *resultobj = 0;
51291 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51292 wxSize *arg2 = 0 ;
51293 void *argp1 = 0 ;
51294 int res1 = 0 ;
51295 wxSize temp2 ;
51296 PyObject * obj0 = 0 ;
51297 PyObject * obj1 = 0 ;
51298 char * kwnames[] = {
51299 (char *) "self",(char *) "size", NULL
51300 };
51301
51302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_AssignSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
51303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51304 if (!SWIG_IsOK(res1)) {
51305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_AssignSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51306 }
51307 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51308 {
51309 arg2 = &temp2;
51310 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
51311 }
51312 {
51313 PyThreadState* __tstate = wxPyBeginAllowThreads();
51314 (arg1)->AssignSpacer((wxSize const &)*arg2);
51315 wxPyEndAllowThreads(__tstate);
51316 if (PyErr_Occurred()) SWIG_fail;
51317 }
51318 resultobj = SWIG_Py_Void();
51319 return resultobj;
51320 fail:
51321 return NULL;
51322 }
51323
51324
51325 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51326 PyObject *resultobj = 0;
51327 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51328 bool arg2 ;
51329 void *argp1 = 0 ;
51330 int res1 = 0 ;
51331 bool val2 ;
51332 int ecode2 = 0 ;
51333 PyObject * obj0 = 0 ;
51334 PyObject * obj1 = 0 ;
51335 char * kwnames[] = {
51336 (char *) "self",(char *) "show", NULL
51337 };
51338
51339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
51340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51341 if (!SWIG_IsOK(res1)) {
51342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51343 }
51344 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51345 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51346 if (!SWIG_IsOK(ecode2)) {
51347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
51348 }
51349 arg2 = static_cast< bool >(val2);
51350 {
51351 PyThreadState* __tstate = wxPyBeginAllowThreads();
51352 (arg1)->Show(arg2);
51353 wxPyEndAllowThreads(__tstate);
51354 if (PyErr_Occurred()) SWIG_fail;
51355 }
51356 resultobj = SWIG_Py_Void();
51357 return resultobj;
51358 fail:
51359 return NULL;
51360 }
51361
51362
51363 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51364 PyObject *resultobj = 0;
51365 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51366 bool result;
51367 void *argp1 = 0 ;
51368 int res1 = 0 ;
51369 PyObject *swig_obj[1] ;
51370
51371 if (!args) SWIG_fail;
51372 swig_obj[0] = args;
51373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51374 if (!SWIG_IsOK(res1)) {
51375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51376 }
51377 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51378 {
51379 PyThreadState* __tstate = wxPyBeginAllowThreads();
51380 result = (bool)(arg1)->IsShown();
51381 wxPyEndAllowThreads(__tstate);
51382 if (PyErr_Occurred()) SWIG_fail;
51383 }
51384 {
51385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51386 }
51387 return resultobj;
51388 fail:
51389 return NULL;
51390 }
51391
51392
51393 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51394 PyObject *resultobj = 0;
51395 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51396 wxPoint result;
51397 void *argp1 = 0 ;
51398 int res1 = 0 ;
51399 PyObject *swig_obj[1] ;
51400
51401 if (!args) SWIG_fail;
51402 swig_obj[0] = args;
51403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51404 if (!SWIG_IsOK(res1)) {
51405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51406 }
51407 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51408 {
51409 PyThreadState* __tstate = wxPyBeginAllowThreads();
51410 result = (arg1)->GetPosition();
51411 wxPyEndAllowThreads(__tstate);
51412 if (PyErr_Occurred()) SWIG_fail;
51413 }
51414 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
51415 return resultobj;
51416 fail:
51417 return NULL;
51418 }
51419
51420
51421 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51422 PyObject *resultobj = 0;
51423 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51424 PyObject *result = 0 ;
51425 void *argp1 = 0 ;
51426 int res1 = 0 ;
51427 PyObject *swig_obj[1] ;
51428
51429 if (!args) SWIG_fail;
51430 swig_obj[0] = args;
51431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51432 if (!SWIG_IsOK(res1)) {
51433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51434 }
51435 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51436 {
51437 PyThreadState* __tstate = wxPyBeginAllowThreads();
51438 result = (PyObject *)wxSizerItem_GetUserData(arg1);
51439 wxPyEndAllowThreads(__tstate);
51440 if (PyErr_Occurred()) SWIG_fail;
51441 }
51442 resultobj = result;
51443 return resultobj;
51444 fail:
51445 return NULL;
51446 }
51447
51448
51449 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51450 PyObject *resultobj = 0;
51451 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51452 PyObject *arg2 = (PyObject *) 0 ;
51453 void *argp1 = 0 ;
51454 int res1 = 0 ;
51455 PyObject * obj0 = 0 ;
51456 PyObject * obj1 = 0 ;
51457 char * kwnames[] = {
51458 (char *) "self",(char *) "userData", NULL
51459 };
51460
51461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
51462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51463 if (!SWIG_IsOK(res1)) {
51464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51465 }
51466 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51467 arg2 = obj1;
51468 {
51469 PyThreadState* __tstate = wxPyBeginAllowThreads();
51470 wxSizerItem_SetUserData(arg1,arg2);
51471 wxPyEndAllowThreads(__tstate);
51472 if (PyErr_Occurred()) SWIG_fail;
51473 }
51474 resultobj = SWIG_Py_Void();
51475 return resultobj;
51476 fail:
51477 return NULL;
51478 }
51479
51480
51481 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51482 PyObject *obj;
51483 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51484 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
51485 return SWIG_Py_Void();
51486 }
51487
51488 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51489 return SWIG_Python_InitShadowInstance(args);
51490 }
51491
51492 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51493 PyObject *resultobj = 0;
51494 wxSizer *arg1 = (wxSizer *) 0 ;
51495 void *argp1 = 0 ;
51496 int res1 = 0 ;
51497 PyObject *swig_obj[1] ;
51498
51499 if (!args) SWIG_fail;
51500 swig_obj[0] = args;
51501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
51502 if (!SWIG_IsOK(res1)) {
51503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
51504 }
51505 arg1 = reinterpret_cast< wxSizer * >(argp1);
51506 {
51507 PyThreadState* __tstate = wxPyBeginAllowThreads();
51508 delete arg1;
51509
51510 wxPyEndAllowThreads(__tstate);
51511 if (PyErr_Occurred()) SWIG_fail;
51512 }
51513 resultobj = SWIG_Py_Void();
51514 return resultobj;
51515 fail:
51516 return NULL;
51517 }
51518
51519
51520 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51521 PyObject *resultobj = 0;
51522 wxSizer *arg1 = (wxSizer *) 0 ;
51523 PyObject *arg2 = (PyObject *) 0 ;
51524 void *argp1 = 0 ;
51525 int res1 = 0 ;
51526 PyObject * obj0 = 0 ;
51527 PyObject * obj1 = 0 ;
51528 char * kwnames[] = {
51529 (char *) "self",(char *) "_self", NULL
51530 };
51531
51532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
51533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51534 if (!SWIG_IsOK(res1)) {
51535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
51536 }
51537 arg1 = reinterpret_cast< wxSizer * >(argp1);
51538 arg2 = obj1;
51539 {
51540 PyThreadState* __tstate = wxPyBeginAllowThreads();
51541 wxSizer__setOORInfo(arg1,arg2);
51542 wxPyEndAllowThreads(__tstate);
51543 if (PyErr_Occurred()) SWIG_fail;
51544 }
51545 resultobj = SWIG_Py_Void();
51546 return resultobj;
51547 fail:
51548 return NULL;
51549 }
51550
51551
51552 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51553 PyObject *resultobj = 0;
51554 wxSizer *arg1 = (wxSizer *) 0 ;
51555 PyObject *arg2 = (PyObject *) 0 ;
51556 int arg3 = (int) 0 ;
51557 int arg4 = (int) 0 ;
51558 int arg5 = (int) 0 ;
51559 PyObject *arg6 = (PyObject *) NULL ;
51560 wxSizerItem *result = 0 ;
51561 void *argp1 = 0 ;
51562 int res1 = 0 ;
51563 int val3 ;
51564 int ecode3 = 0 ;
51565 int val4 ;
51566 int ecode4 = 0 ;
51567 int val5 ;
51568 int ecode5 = 0 ;
51569 PyObject * obj0 = 0 ;
51570 PyObject * obj1 = 0 ;
51571 PyObject * obj2 = 0 ;
51572 PyObject * obj3 = 0 ;
51573 PyObject * obj4 = 0 ;
51574 PyObject * obj5 = 0 ;
51575 char * kwnames[] = {
51576 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
51577 };
51578
51579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51581 if (!SWIG_IsOK(res1)) {
51582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
51583 }
51584 arg1 = reinterpret_cast< wxSizer * >(argp1);
51585 arg2 = obj1;
51586 if (obj2) {
51587 ecode3 = SWIG_AsVal_int(obj2, &val3);
51588 if (!SWIG_IsOK(ecode3)) {
51589 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
51590 }
51591 arg3 = static_cast< int >(val3);
51592 }
51593 if (obj3) {
51594 ecode4 = SWIG_AsVal_int(obj3, &val4);
51595 if (!SWIG_IsOK(ecode4)) {
51596 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
51597 }
51598 arg4 = static_cast< int >(val4);
51599 }
51600 if (obj4) {
51601 ecode5 = SWIG_AsVal_int(obj4, &val5);
51602 if (!SWIG_IsOK(ecode5)) {
51603 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
51604 }
51605 arg5 = static_cast< int >(val5);
51606 }
51607 if (obj5) {
51608 arg6 = obj5;
51609 }
51610 {
51611 PyThreadState* __tstate = wxPyBeginAllowThreads();
51612 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
51613 wxPyEndAllowThreads(__tstate);
51614 if (PyErr_Occurred()) SWIG_fail;
51615 }
51616 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51617 return resultobj;
51618 fail:
51619 return NULL;
51620 }
51621
51622
51623 SWIGINTERN PyObject *_wrap_Sizer_AddF(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51624 PyObject *resultobj = 0;
51625 wxSizer *arg1 = (wxSizer *) 0 ;
51626 PyObject *arg2 = (PyObject *) 0 ;
51627 wxSizerFlags *arg3 = 0 ;
51628 wxSizerItem *result = 0 ;
51629 void *argp1 = 0 ;
51630 int res1 = 0 ;
51631 void *argp3 = 0 ;
51632 int res3 = 0 ;
51633 PyObject * obj0 = 0 ;
51634 PyObject * obj1 = 0 ;
51635 PyObject * obj2 = 0 ;
51636 char * kwnames[] = {
51637 (char *) "self",(char *) "item",(char *) "flags", NULL
51638 };
51639
51640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_AddF",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51642 if (!SWIG_IsOK(res1)) {
51643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddF" "', expected argument " "1"" of type '" "wxSizer *""'");
51644 }
51645 arg1 = reinterpret_cast< wxSizer * >(argp1);
51646 arg2 = obj1;
51647 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxSizerFlags, 0 );
51648 if (!SWIG_IsOK(res3)) {
51649 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_AddF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51650 }
51651 if (!argp3) {
51652 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sizer_AddF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51653 }
51654 arg3 = reinterpret_cast< wxSizerFlags * >(argp3);
51655 {
51656 PyThreadState* __tstate = wxPyBeginAllowThreads();
51657 result = (wxSizerItem *)wxSizer_AddF(arg1,arg2,*arg3);
51658 wxPyEndAllowThreads(__tstate);
51659 if (PyErr_Occurred()) SWIG_fail;
51660 }
51661 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51662 return resultobj;
51663 fail:
51664 return NULL;
51665 }
51666
51667
51668 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51669 PyObject *resultobj = 0;
51670 wxSizer *arg1 = (wxSizer *) 0 ;
51671 int arg2 ;
51672 PyObject *arg3 = (PyObject *) 0 ;
51673 int arg4 = (int) 0 ;
51674 int arg5 = (int) 0 ;
51675 int arg6 = (int) 0 ;
51676 PyObject *arg7 = (PyObject *) NULL ;
51677 wxSizerItem *result = 0 ;
51678 void *argp1 = 0 ;
51679 int res1 = 0 ;
51680 int val2 ;
51681 int ecode2 = 0 ;
51682 int val4 ;
51683 int ecode4 = 0 ;
51684 int val5 ;
51685 int ecode5 = 0 ;
51686 int val6 ;
51687 int ecode6 = 0 ;
51688 PyObject * obj0 = 0 ;
51689 PyObject * obj1 = 0 ;
51690 PyObject * obj2 = 0 ;
51691 PyObject * obj3 = 0 ;
51692 PyObject * obj4 = 0 ;
51693 PyObject * obj5 = 0 ;
51694 PyObject * obj6 = 0 ;
51695 char * kwnames[] = {
51696 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
51697 };
51698
51699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51701 if (!SWIG_IsOK(res1)) {
51702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
51703 }
51704 arg1 = reinterpret_cast< wxSizer * >(argp1);
51705 ecode2 = SWIG_AsVal_int(obj1, &val2);
51706 if (!SWIG_IsOK(ecode2)) {
51707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
51708 }
51709 arg2 = static_cast< int >(val2);
51710 arg3 = obj2;
51711 if (obj3) {
51712 ecode4 = SWIG_AsVal_int(obj3, &val4);
51713 if (!SWIG_IsOK(ecode4)) {
51714 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
51715 }
51716 arg4 = static_cast< int >(val4);
51717 }
51718 if (obj4) {
51719 ecode5 = SWIG_AsVal_int(obj4, &val5);
51720 if (!SWIG_IsOK(ecode5)) {
51721 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
51722 }
51723 arg5 = static_cast< int >(val5);
51724 }
51725 if (obj5) {
51726 ecode6 = SWIG_AsVal_int(obj5, &val6);
51727 if (!SWIG_IsOK(ecode6)) {
51728 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
51729 }
51730 arg6 = static_cast< int >(val6);
51731 }
51732 if (obj6) {
51733 arg7 = obj6;
51734 }
51735 {
51736 PyThreadState* __tstate = wxPyBeginAllowThreads();
51737 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
51738 wxPyEndAllowThreads(__tstate);
51739 if (PyErr_Occurred()) SWIG_fail;
51740 }
51741 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51742 return resultobj;
51743 fail:
51744 return NULL;
51745 }
51746
51747
51748 SWIGINTERN PyObject *_wrap_Sizer_InsertF(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51749 PyObject *resultobj = 0;
51750 wxSizer *arg1 = (wxSizer *) 0 ;
51751 int arg2 ;
51752 PyObject *arg3 = (PyObject *) 0 ;
51753 wxSizerFlags *arg4 = 0 ;
51754 wxSizerItem *result = 0 ;
51755 void *argp1 = 0 ;
51756 int res1 = 0 ;
51757 int val2 ;
51758 int ecode2 = 0 ;
51759 void *argp4 = 0 ;
51760 int res4 = 0 ;
51761 PyObject * obj0 = 0 ;
51762 PyObject * obj1 = 0 ;
51763 PyObject * obj2 = 0 ;
51764 PyObject * obj3 = 0 ;
51765 char * kwnames[] = {
51766 (char *) "self",(char *) "before",(char *) "item",(char *) "flags", NULL
51767 };
51768
51769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Sizer_InsertF",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51771 if (!SWIG_IsOK(res1)) {
51772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertF" "', expected argument " "1"" of type '" "wxSizer *""'");
51773 }
51774 arg1 = reinterpret_cast< wxSizer * >(argp1);
51775 ecode2 = SWIG_AsVal_int(obj1, &val2);
51776 if (!SWIG_IsOK(ecode2)) {
51777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertF" "', expected argument " "2"" of type '" "int""'");
51778 }
51779 arg2 = static_cast< int >(val2);
51780 arg3 = obj2;
51781 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxSizerFlags, 0 );
51782 if (!SWIG_IsOK(res4)) {
51783 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Sizer_InsertF" "', expected argument " "4"" of type '" "wxSizerFlags &""'");
51784 }
51785 if (!argp4) {
51786 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sizer_InsertF" "', expected argument " "4"" of type '" "wxSizerFlags &""'");
51787 }
51788 arg4 = reinterpret_cast< wxSizerFlags * >(argp4);
51789 {
51790 PyThreadState* __tstate = wxPyBeginAllowThreads();
51791 result = (wxSizerItem *)wxSizer_InsertF(arg1,arg2,arg3,*arg4);
51792 wxPyEndAllowThreads(__tstate);
51793 if (PyErr_Occurred()) SWIG_fail;
51794 }
51795 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51796 return resultobj;
51797 fail:
51798 return NULL;
51799 }
51800
51801
51802 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51803 PyObject *resultobj = 0;
51804 wxSizer *arg1 = (wxSizer *) 0 ;
51805 PyObject *arg2 = (PyObject *) 0 ;
51806 int arg3 = (int) 0 ;
51807 int arg4 = (int) 0 ;
51808 int arg5 = (int) 0 ;
51809 PyObject *arg6 = (PyObject *) NULL ;
51810 wxSizerItem *result = 0 ;
51811 void *argp1 = 0 ;
51812 int res1 = 0 ;
51813 int val3 ;
51814 int ecode3 = 0 ;
51815 int val4 ;
51816 int ecode4 = 0 ;
51817 int val5 ;
51818 int ecode5 = 0 ;
51819 PyObject * obj0 = 0 ;
51820 PyObject * obj1 = 0 ;
51821 PyObject * obj2 = 0 ;
51822 PyObject * obj3 = 0 ;
51823 PyObject * obj4 = 0 ;
51824 PyObject * obj5 = 0 ;
51825 char * kwnames[] = {
51826 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
51827 };
51828
51829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51831 if (!SWIG_IsOK(res1)) {
51832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
51833 }
51834 arg1 = reinterpret_cast< wxSizer * >(argp1);
51835 arg2 = obj1;
51836 if (obj2) {
51837 ecode3 = SWIG_AsVal_int(obj2, &val3);
51838 if (!SWIG_IsOK(ecode3)) {
51839 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
51840 }
51841 arg3 = static_cast< int >(val3);
51842 }
51843 if (obj3) {
51844 ecode4 = SWIG_AsVal_int(obj3, &val4);
51845 if (!SWIG_IsOK(ecode4)) {
51846 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
51847 }
51848 arg4 = static_cast< int >(val4);
51849 }
51850 if (obj4) {
51851 ecode5 = SWIG_AsVal_int(obj4, &val5);
51852 if (!SWIG_IsOK(ecode5)) {
51853 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
51854 }
51855 arg5 = static_cast< int >(val5);
51856 }
51857 if (obj5) {
51858 arg6 = obj5;
51859 }
51860 {
51861 PyThreadState* __tstate = wxPyBeginAllowThreads();
51862 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
51863 wxPyEndAllowThreads(__tstate);
51864 if (PyErr_Occurred()) SWIG_fail;
51865 }
51866 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51867 return resultobj;
51868 fail:
51869 return NULL;
51870 }
51871
51872
51873 SWIGINTERN PyObject *_wrap_Sizer_PrependF(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51874 PyObject *resultobj = 0;
51875 wxSizer *arg1 = (wxSizer *) 0 ;
51876 PyObject *arg2 = (PyObject *) 0 ;
51877 wxSizerFlags *arg3 = 0 ;
51878 wxSizerItem *result = 0 ;
51879 void *argp1 = 0 ;
51880 int res1 = 0 ;
51881 void *argp3 = 0 ;
51882 int res3 = 0 ;
51883 PyObject * obj0 = 0 ;
51884 PyObject * obj1 = 0 ;
51885 PyObject * obj2 = 0 ;
51886 char * kwnames[] = {
51887 (char *) "self",(char *) "item",(char *) "flags", NULL
51888 };
51889
51890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_PrependF",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51892 if (!SWIG_IsOK(res1)) {
51893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependF" "', expected argument " "1"" of type '" "wxSizer *""'");
51894 }
51895 arg1 = reinterpret_cast< wxSizer * >(argp1);
51896 arg2 = obj1;
51897 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxSizerFlags, 0 );
51898 if (!SWIG_IsOK(res3)) {
51899 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_PrependF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51900 }
51901 if (!argp3) {
51902 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sizer_PrependF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51903 }
51904 arg3 = reinterpret_cast< wxSizerFlags * >(argp3);
51905 {
51906 PyThreadState* __tstate = wxPyBeginAllowThreads();
51907 result = (wxSizerItem *)wxSizer_PrependF(arg1,arg2,*arg3);
51908 wxPyEndAllowThreads(__tstate);
51909 if (PyErr_Occurred()) SWIG_fail;
51910 }
51911 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51912 return resultobj;
51913 fail:
51914 return NULL;
51915 }
51916
51917
51918 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51919 PyObject *resultobj = 0;
51920 wxSizer *arg1 = (wxSizer *) 0 ;
51921 PyObject *arg2 = (PyObject *) 0 ;
51922 bool result;
51923 void *argp1 = 0 ;
51924 int res1 = 0 ;
51925 PyObject * obj0 = 0 ;
51926 PyObject * obj1 = 0 ;
51927 char * kwnames[] = {
51928 (char *) "self",(char *) "item", NULL
51929 };
51930
51931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) 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_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
51935 }
51936 arg1 = reinterpret_cast< wxSizer * >(argp1);
51937 arg2 = obj1;
51938 {
51939 PyThreadState* __tstate = wxPyBeginAllowThreads();
51940 result = (bool)wxSizer_Remove(arg1,arg2);
51941 wxPyEndAllowThreads(__tstate);
51942 if (PyErr_Occurred()) SWIG_fail;
51943 }
51944 {
51945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51946 }
51947 return resultobj;
51948 fail:
51949 return NULL;
51950 }
51951
51952
51953 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51954 PyObject *resultobj = 0;
51955 wxSizer *arg1 = (wxSizer *) 0 ;
51956 PyObject *arg2 = (PyObject *) 0 ;
51957 bool result;
51958 void *argp1 = 0 ;
51959 int res1 = 0 ;
51960 PyObject * obj0 = 0 ;
51961 PyObject * obj1 = 0 ;
51962 char * kwnames[] = {
51963 (char *) "self",(char *) "item", NULL
51964 };
51965
51966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
51967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51968 if (!SWIG_IsOK(res1)) {
51969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
51970 }
51971 arg1 = reinterpret_cast< wxSizer * >(argp1);
51972 arg2 = obj1;
51973 {
51974 PyThreadState* __tstate = wxPyBeginAllowThreads();
51975 result = (bool)wxSizer_Detach(arg1,arg2);
51976 wxPyEndAllowThreads(__tstate);
51977 if (PyErr_Occurred()) SWIG_fail;
51978 }
51979 {
51980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51981 }
51982 return resultobj;
51983 fail:
51984 return NULL;
51985 }
51986
51987
51988 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51989 PyObject *resultobj = 0;
51990 wxSizer *arg1 = (wxSizer *) 0 ;
51991 PyObject *arg2 = (PyObject *) 0 ;
51992 bool arg3 = (bool) false ;
51993 wxSizerItem *result = 0 ;
51994 void *argp1 = 0 ;
51995 int res1 = 0 ;
51996 bool val3 ;
51997 int ecode3 = 0 ;
51998 PyObject * obj0 = 0 ;
51999 PyObject * obj1 = 0 ;
52000 PyObject * obj2 = 0 ;
52001 char * kwnames[] = {
52002 (char *) "self",(char *) "item",(char *) "recursive", NULL
52003 };
52004
52005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Sizer_GetItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52007 if (!SWIG_IsOK(res1)) {
52008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
52009 }
52010 arg1 = reinterpret_cast< wxSizer * >(argp1);
52011 arg2 = obj1;
52012 if (obj2) {
52013 ecode3 = SWIG_AsVal_bool(obj2, &val3);
52014 if (!SWIG_IsOK(ecode3)) {
52015 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_GetItem" "', expected argument " "3"" of type '" "bool""'");
52016 }
52017 arg3 = static_cast< bool >(val3);
52018 }
52019 {
52020 PyThreadState* __tstate = wxPyBeginAllowThreads();
52021 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2,arg3);
52022 wxPyEndAllowThreads(__tstate);
52023 if (PyErr_Occurred()) SWIG_fail;
52024 }
52025 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
52026 return resultobj;
52027 fail:
52028 return NULL;
52029 }
52030
52031
52032 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52033 PyObject *resultobj = 0;
52034 wxSizer *arg1 = (wxSizer *) 0 ;
52035 PyObject *arg2 = (PyObject *) 0 ;
52036 wxSize *arg3 = 0 ;
52037 void *argp1 = 0 ;
52038 int res1 = 0 ;
52039 wxSize temp3 ;
52040 PyObject * obj0 = 0 ;
52041 PyObject * obj1 = 0 ;
52042 PyObject * obj2 = 0 ;
52043 char * kwnames[] = {
52044 (char *) "self",(char *) "item",(char *) "size", NULL
52045 };
52046
52047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52049 if (!SWIG_IsOK(res1)) {
52050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
52051 }
52052 arg1 = reinterpret_cast< wxSizer * >(argp1);
52053 arg2 = obj1;
52054 {
52055 arg3 = &temp3;
52056 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
52057 }
52058 {
52059 PyThreadState* __tstate = wxPyBeginAllowThreads();
52060 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
52061 wxPyEndAllowThreads(__tstate);
52062 if (PyErr_Occurred()) SWIG_fail;
52063 }
52064 resultobj = SWIG_Py_Void();
52065 return resultobj;
52066 fail:
52067 return NULL;
52068 }
52069
52070
52071 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52072 PyObject *resultobj = 0;
52073 wxSizer *arg1 = (wxSizer *) 0 ;
52074 wxWindow *arg2 = (wxWindow *) 0 ;
52075 wxWindow *arg3 = (wxWindow *) 0 ;
52076 bool arg4 = (bool) false ;
52077 bool result;
52078 void *argp1 = 0 ;
52079 int res1 = 0 ;
52080 void *argp2 = 0 ;
52081 int res2 = 0 ;
52082 void *argp3 = 0 ;
52083 int res3 = 0 ;
52084 bool val4 ;
52085 int ecode4 = 0 ;
52086 PyObject * obj0 = 0 ;
52087 PyObject * obj1 = 0 ;
52088 PyObject * obj2 = 0 ;
52089 PyObject * obj3 = 0 ;
52090 char * kwnames[] = {
52091 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
52092 };
52093
52094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52096 if (!SWIG_IsOK(res1)) {
52097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
52098 }
52099 arg1 = reinterpret_cast< wxSizer * >(argp1);
52100 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52101 if (!SWIG_IsOK(res2)) {
52102 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52103 }
52104 arg2 = reinterpret_cast< wxWindow * >(argp2);
52105 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52106 if (!SWIG_IsOK(res3)) {
52107 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
52108 }
52109 arg3 = reinterpret_cast< wxWindow * >(argp3);
52110 if (obj3) {
52111 ecode4 = SWIG_AsVal_bool(obj3, &val4);
52112 if (!SWIG_IsOK(ecode4)) {
52113 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
52114 }
52115 arg4 = static_cast< bool >(val4);
52116 }
52117 {
52118 PyThreadState* __tstate = wxPyBeginAllowThreads();
52119 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
52120 wxPyEndAllowThreads(__tstate);
52121 if (PyErr_Occurred()) SWIG_fail;
52122 }
52123 {
52124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52125 }
52126 return resultobj;
52127 fail:
52128 return NULL;
52129 }
52130
52131
52132 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52133 PyObject *resultobj = 0;
52134 wxSizer *arg1 = (wxSizer *) 0 ;
52135 wxSizer *arg2 = (wxSizer *) 0 ;
52136 wxSizer *arg3 = (wxSizer *) 0 ;
52137 bool arg4 = (bool) false ;
52138 bool result;
52139 void *argp1 = 0 ;
52140 int res1 = 0 ;
52141 void *argp2 = 0 ;
52142 int res2 = 0 ;
52143 void *argp3 = 0 ;
52144 int res3 = 0 ;
52145 bool val4 ;
52146 int ecode4 = 0 ;
52147 PyObject * obj0 = 0 ;
52148 PyObject * obj1 = 0 ;
52149 PyObject * obj2 = 0 ;
52150 PyObject * obj3 = 0 ;
52151 char * kwnames[] = {
52152 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
52153 };
52154
52155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52157 if (!SWIG_IsOK(res1)) {
52158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
52159 }
52160 arg1 = reinterpret_cast< wxSizer * >(argp1);
52161 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52162 if (!SWIG_IsOK(res2)) {
52163 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
52164 }
52165 arg2 = reinterpret_cast< wxSizer * >(argp2);
52166 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
52167 if (!SWIG_IsOK(res3)) {
52168 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
52169 }
52170 arg3 = reinterpret_cast< wxSizer * >(argp3);
52171 if (obj3) {
52172 ecode4 = SWIG_AsVal_bool(obj3, &val4);
52173 if (!SWIG_IsOK(ecode4)) {
52174 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
52175 }
52176 arg4 = static_cast< bool >(val4);
52177 }
52178 {
52179 PyThreadState* __tstate = wxPyBeginAllowThreads();
52180 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
52181 wxPyEndAllowThreads(__tstate);
52182 if (PyErr_Occurred()) SWIG_fail;
52183 }
52184 {
52185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52186 }
52187 return resultobj;
52188 fail:
52189 return NULL;
52190 }
52191
52192
52193 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52194 PyObject *resultobj = 0;
52195 wxSizer *arg1 = (wxSizer *) 0 ;
52196 size_t arg2 ;
52197 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
52198 bool result;
52199 void *argp1 = 0 ;
52200 int res1 = 0 ;
52201 size_t val2 ;
52202 int ecode2 = 0 ;
52203 void *argp3 = 0 ;
52204 int res3 = 0 ;
52205 PyObject * obj0 = 0 ;
52206 PyObject * obj1 = 0 ;
52207 PyObject * obj2 = 0 ;
52208 char * kwnames[] = {
52209 (char *) "self",(char *) "index",(char *) "newitem", NULL
52210 };
52211
52212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52214 if (!SWIG_IsOK(res1)) {
52215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
52216 }
52217 arg1 = reinterpret_cast< wxSizer * >(argp1);
52218 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
52219 if (!SWIG_IsOK(ecode2)) {
52220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
52221 }
52222 arg2 = static_cast< size_t >(val2);
52223 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
52224 if (!SWIG_IsOK(res3)) {
52225 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
52226 }
52227 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
52228 {
52229 PyThreadState* __tstate = wxPyBeginAllowThreads();
52230 result = (bool)(arg1)->Replace(arg2,arg3);
52231 wxPyEndAllowThreads(__tstate);
52232 if (PyErr_Occurred()) SWIG_fail;
52233 }
52234 {
52235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52236 }
52237 return resultobj;
52238 fail:
52239 return NULL;
52240 }
52241
52242
52243 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52244 PyObject *resultobj = 0;
52245 wxSizer *arg1 = (wxSizer *) 0 ;
52246 wxWindow *arg2 = (wxWindow *) 0 ;
52247 void *argp1 = 0 ;
52248 int res1 = 0 ;
52249 void *argp2 = 0 ;
52250 int res2 = 0 ;
52251 PyObject * obj0 = 0 ;
52252 PyObject * obj1 = 0 ;
52253 char * kwnames[] = {
52254 (char *) "self",(char *) "window", NULL
52255 };
52256
52257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
52258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52259 if (!SWIG_IsOK(res1)) {
52260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
52261 }
52262 arg1 = reinterpret_cast< wxSizer * >(argp1);
52263 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52264 if (!SWIG_IsOK(res2)) {
52265 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
52266 }
52267 arg2 = reinterpret_cast< wxWindow * >(argp2);
52268 {
52269 PyThreadState* __tstate = wxPyBeginAllowThreads();
52270 (arg1)->SetContainingWindow(arg2);
52271 wxPyEndAllowThreads(__tstate);
52272 if (PyErr_Occurred()) SWIG_fail;
52273 }
52274 resultobj = SWIG_Py_Void();
52275 return resultobj;
52276 fail:
52277 return NULL;
52278 }
52279
52280
52281 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52282 PyObject *resultobj = 0;
52283 wxSizer *arg1 = (wxSizer *) 0 ;
52284 wxWindow *result = 0 ;
52285 void *argp1 = 0 ;
52286 int res1 = 0 ;
52287 PyObject *swig_obj[1] ;
52288
52289 if (!args) SWIG_fail;
52290 swig_obj[0] = args;
52291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52292 if (!SWIG_IsOK(res1)) {
52293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
52294 }
52295 arg1 = reinterpret_cast< wxSizer * >(argp1);
52296 {
52297 PyThreadState* __tstate = wxPyBeginAllowThreads();
52298 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
52299 wxPyEndAllowThreads(__tstate);
52300 if (PyErr_Occurred()) SWIG_fail;
52301 }
52302 {
52303 resultobj = wxPyMake_wxObject(result, 0);
52304 }
52305 return resultobj;
52306 fail:
52307 return NULL;
52308 }
52309
52310
52311 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52312 PyObject *resultobj = 0;
52313 wxSizer *arg1 = (wxSizer *) 0 ;
52314 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
52315 wxSizerItem *result = 0 ;
52316 void *argp1 = 0 ;
52317 int res1 = 0 ;
52318 int res2 = 0 ;
52319 PyObject * obj0 = 0 ;
52320 PyObject * obj1 = 0 ;
52321 char * kwnames[] = {
52322 (char *) "self",(char *) "item", NULL
52323 };
52324
52325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
52326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52327 if (!SWIG_IsOK(res1)) {
52328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
52329 }
52330 arg1 = reinterpret_cast< wxSizer * >(argp1);
52331 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
52332 if (!SWIG_IsOK(res2)) {
52333 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
52334 }
52335 {
52336 PyThreadState* __tstate = wxPyBeginAllowThreads();
52337 result = (wxSizerItem *)(arg1)->Add(arg2);
52338 wxPyEndAllowThreads(__tstate);
52339 if (PyErr_Occurred()) SWIG_fail;
52340 }
52341 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
52342 return resultobj;
52343 fail:
52344 return NULL;
52345 }
52346
52347
52348 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52349 PyObject *resultobj = 0;
52350 wxSizer *arg1 = (wxSizer *) 0 ;
52351 size_t arg2 ;
52352 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
52353 wxSizerItem *result = 0 ;
52354 void *argp1 = 0 ;
52355 int res1 = 0 ;
52356 size_t val2 ;
52357 int ecode2 = 0 ;
52358 int res3 = 0 ;
52359 PyObject * obj0 = 0 ;
52360 PyObject * obj1 = 0 ;
52361 PyObject * obj2 = 0 ;
52362 char * kwnames[] = {
52363 (char *) "self",(char *) "index",(char *) "item", NULL
52364 };
52365
52366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) 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_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
52370 }
52371 arg1 = reinterpret_cast< wxSizer * >(argp1);
52372 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
52373 if (!SWIG_IsOK(ecode2)) {
52374 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
52375 }
52376 arg2 = static_cast< size_t >(val2);
52377 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
52378 if (!SWIG_IsOK(res3)) {
52379 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
52380 }
52381 {
52382 PyThreadState* __tstate = wxPyBeginAllowThreads();
52383 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
52384 wxPyEndAllowThreads(__tstate);
52385 if (PyErr_Occurred()) SWIG_fail;
52386 }
52387 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
52388 return resultobj;
52389 fail:
52390 return NULL;
52391 }
52392
52393
52394 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52395 PyObject *resultobj = 0;
52396 wxSizer *arg1 = (wxSizer *) 0 ;
52397 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
52398 wxSizerItem *result = 0 ;
52399 void *argp1 = 0 ;
52400 int res1 = 0 ;
52401 int res2 = 0 ;
52402 PyObject * obj0 = 0 ;
52403 PyObject * obj1 = 0 ;
52404 char * kwnames[] = {
52405 (char *) "self",(char *) "item", NULL
52406 };
52407
52408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
52409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52410 if (!SWIG_IsOK(res1)) {
52411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
52412 }
52413 arg1 = reinterpret_cast< wxSizer * >(argp1);
52414 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
52415 if (!SWIG_IsOK(res2)) {
52416 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
52417 }
52418 {
52419 PyThreadState* __tstate = wxPyBeginAllowThreads();
52420 result = (wxSizerItem *)(arg1)->Prepend(arg2);
52421 wxPyEndAllowThreads(__tstate);
52422 if (PyErr_Occurred()) SWIG_fail;
52423 }
52424 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
52425 return resultobj;
52426 fail:
52427 return NULL;
52428 }
52429
52430
52431 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52432 PyObject *resultobj = 0;
52433 wxSizer *arg1 = (wxSizer *) 0 ;
52434 int arg2 ;
52435 int arg3 ;
52436 int arg4 ;
52437 int arg5 ;
52438 void *argp1 = 0 ;
52439 int res1 = 0 ;
52440 int val2 ;
52441 int ecode2 = 0 ;
52442 int val3 ;
52443 int ecode3 = 0 ;
52444 int val4 ;
52445 int ecode4 = 0 ;
52446 int val5 ;
52447 int ecode5 = 0 ;
52448 PyObject * obj0 = 0 ;
52449 PyObject * obj1 = 0 ;
52450 PyObject * obj2 = 0 ;
52451 PyObject * obj3 = 0 ;
52452 PyObject * obj4 = 0 ;
52453 char * kwnames[] = {
52454 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
52455 };
52456
52457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
52458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52459 if (!SWIG_IsOK(res1)) {
52460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
52461 }
52462 arg1 = reinterpret_cast< wxSizer * >(argp1);
52463 ecode2 = SWIG_AsVal_int(obj1, &val2);
52464 if (!SWIG_IsOK(ecode2)) {
52465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
52466 }
52467 arg2 = static_cast< int >(val2);
52468 ecode3 = SWIG_AsVal_int(obj2, &val3);
52469 if (!SWIG_IsOK(ecode3)) {
52470 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
52471 }
52472 arg3 = static_cast< int >(val3);
52473 ecode4 = SWIG_AsVal_int(obj3, &val4);
52474 if (!SWIG_IsOK(ecode4)) {
52475 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
52476 }
52477 arg4 = static_cast< int >(val4);
52478 ecode5 = SWIG_AsVal_int(obj4, &val5);
52479 if (!SWIG_IsOK(ecode5)) {
52480 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
52481 }
52482 arg5 = static_cast< int >(val5);
52483 {
52484 PyThreadState* __tstate = wxPyBeginAllowThreads();
52485 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
52486 wxPyEndAllowThreads(__tstate);
52487 if (PyErr_Occurred()) SWIG_fail;
52488 }
52489 resultobj = SWIG_Py_Void();
52490 return resultobj;
52491 fail:
52492 return NULL;
52493 }
52494
52495
52496 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52497 PyObject *resultobj = 0;
52498 wxSizer *arg1 = (wxSizer *) 0 ;
52499 wxSize *arg2 = 0 ;
52500 void *argp1 = 0 ;
52501 int res1 = 0 ;
52502 wxSize temp2 ;
52503 PyObject * obj0 = 0 ;
52504 PyObject * obj1 = 0 ;
52505 char * kwnames[] = {
52506 (char *) "self",(char *) "size", NULL
52507 };
52508
52509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
52510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52511 if (!SWIG_IsOK(res1)) {
52512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
52513 }
52514 arg1 = reinterpret_cast< wxSizer * >(argp1);
52515 {
52516 arg2 = &temp2;
52517 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
52518 }
52519 {
52520 PyThreadState* __tstate = wxPyBeginAllowThreads();
52521 (arg1)->SetMinSize((wxSize const &)*arg2);
52522 wxPyEndAllowThreads(__tstate);
52523 if (PyErr_Occurred()) SWIG_fail;
52524 }
52525 resultobj = SWIG_Py_Void();
52526 return resultobj;
52527 fail:
52528 return NULL;
52529 }
52530
52531
52532 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52533 PyObject *resultobj = 0;
52534 wxSizer *arg1 = (wxSizer *) 0 ;
52535 wxSize result;
52536 void *argp1 = 0 ;
52537 int res1 = 0 ;
52538 PyObject *swig_obj[1] ;
52539
52540 if (!args) SWIG_fail;
52541 swig_obj[0] = args;
52542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52543 if (!SWIG_IsOK(res1)) {
52544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
52545 }
52546 arg1 = reinterpret_cast< wxSizer * >(argp1);
52547 {
52548 PyThreadState* __tstate = wxPyBeginAllowThreads();
52549 result = (arg1)->GetSize();
52550 wxPyEndAllowThreads(__tstate);
52551 if (PyErr_Occurred()) SWIG_fail;
52552 }
52553 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
52554 return resultobj;
52555 fail:
52556 return NULL;
52557 }
52558
52559
52560 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52561 PyObject *resultobj = 0;
52562 wxSizer *arg1 = (wxSizer *) 0 ;
52563 wxPoint result;
52564 void *argp1 = 0 ;
52565 int res1 = 0 ;
52566 PyObject *swig_obj[1] ;
52567
52568 if (!args) SWIG_fail;
52569 swig_obj[0] = args;
52570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52571 if (!SWIG_IsOK(res1)) {
52572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
52573 }
52574 arg1 = reinterpret_cast< wxSizer * >(argp1);
52575 {
52576 PyThreadState* __tstate = wxPyBeginAllowThreads();
52577 result = (arg1)->GetPosition();
52578 wxPyEndAllowThreads(__tstate);
52579 if (PyErr_Occurred()) SWIG_fail;
52580 }
52581 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
52582 return resultobj;
52583 fail:
52584 return NULL;
52585 }
52586
52587
52588 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52589 PyObject *resultobj = 0;
52590 wxSizer *arg1 = (wxSizer *) 0 ;
52591 wxSize result;
52592 void *argp1 = 0 ;
52593 int res1 = 0 ;
52594 PyObject *swig_obj[1] ;
52595
52596 if (!args) SWIG_fail;
52597 swig_obj[0] = args;
52598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52599 if (!SWIG_IsOK(res1)) {
52600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
52601 }
52602 arg1 = reinterpret_cast< wxSizer * >(argp1);
52603 {
52604 PyThreadState* __tstate = wxPyBeginAllowThreads();
52605 result = (arg1)->GetMinSize();
52606 wxPyEndAllowThreads(__tstate);
52607 if (PyErr_Occurred()) SWIG_fail;
52608 }
52609 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
52610 return resultobj;
52611 fail:
52612 return NULL;
52613 }
52614
52615
52616 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52617 PyObject *resultobj = 0;
52618 wxSizer *arg1 = (wxSizer *) 0 ;
52619 void *argp1 = 0 ;
52620 int res1 = 0 ;
52621 PyObject *swig_obj[1] ;
52622
52623 if (!args) SWIG_fail;
52624 swig_obj[0] = args;
52625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52626 if (!SWIG_IsOK(res1)) {
52627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
52628 }
52629 arg1 = reinterpret_cast< wxSizer * >(argp1);
52630 {
52631 PyThreadState* __tstate = wxPyBeginAllowThreads();
52632 (arg1)->RecalcSizes();
52633 wxPyEndAllowThreads(__tstate);
52634 if (PyErr_Occurred()) SWIG_fail;
52635 }
52636 resultobj = SWIG_Py_Void();
52637 return resultobj;
52638 fail:
52639 return NULL;
52640 }
52641
52642
52643 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52644 PyObject *resultobj = 0;
52645 wxSizer *arg1 = (wxSizer *) 0 ;
52646 wxSize result;
52647 void *argp1 = 0 ;
52648 int res1 = 0 ;
52649 PyObject *swig_obj[1] ;
52650
52651 if (!args) SWIG_fail;
52652 swig_obj[0] = args;
52653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52654 if (!SWIG_IsOK(res1)) {
52655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
52656 }
52657 arg1 = reinterpret_cast< wxSizer * >(argp1);
52658 {
52659 PyThreadState* __tstate = wxPyBeginAllowThreads();
52660 result = (arg1)->CalcMin();
52661 wxPyEndAllowThreads(__tstate);
52662 if (PyErr_Occurred()) SWIG_fail;
52663 }
52664 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
52665 return resultobj;
52666 fail:
52667 return NULL;
52668 }
52669
52670
52671 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52672 PyObject *resultobj = 0;
52673 wxSizer *arg1 = (wxSizer *) 0 ;
52674 void *argp1 = 0 ;
52675 int res1 = 0 ;
52676 PyObject *swig_obj[1] ;
52677
52678 if (!args) SWIG_fail;
52679 swig_obj[0] = args;
52680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52681 if (!SWIG_IsOK(res1)) {
52682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
52683 }
52684 arg1 = reinterpret_cast< wxSizer * >(argp1);
52685 {
52686 PyThreadState* __tstate = wxPyBeginAllowThreads();
52687 (arg1)->Layout();
52688 wxPyEndAllowThreads(__tstate);
52689 if (PyErr_Occurred()) SWIG_fail;
52690 }
52691 resultobj = SWIG_Py_Void();
52692 return resultobj;
52693 fail:
52694 return NULL;
52695 }
52696
52697
52698 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52699 PyObject *resultobj = 0;
52700 wxSizer *arg1 = (wxSizer *) 0 ;
52701 wxWindow *arg2 = (wxWindow *) 0 ;
52702 wxSize result;
52703 void *argp1 = 0 ;
52704 int res1 = 0 ;
52705 void *argp2 = 0 ;
52706 int res2 = 0 ;
52707 PyObject * obj0 = 0 ;
52708 PyObject * obj1 = 0 ;
52709 char * kwnames[] = {
52710 (char *) "self",(char *) "window", NULL
52711 };
52712
52713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
52714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52715 if (!SWIG_IsOK(res1)) {
52716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
52717 }
52718 arg1 = reinterpret_cast< wxSizer * >(argp1);
52719 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52720 if (!SWIG_IsOK(res2)) {
52721 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
52722 }
52723 arg2 = reinterpret_cast< wxWindow * >(argp2);
52724 {
52725 PyThreadState* __tstate = wxPyBeginAllowThreads();
52726 result = (arg1)->Fit(arg2);
52727 wxPyEndAllowThreads(__tstate);
52728 if (PyErr_Occurred()) SWIG_fail;
52729 }
52730 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
52731 return resultobj;
52732 fail:
52733 return NULL;
52734 }
52735
52736
52737 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52738 PyObject *resultobj = 0;
52739 wxSizer *arg1 = (wxSizer *) 0 ;
52740 wxWindow *arg2 = (wxWindow *) 0 ;
52741 void *argp1 = 0 ;
52742 int res1 = 0 ;
52743 void *argp2 = 0 ;
52744 int res2 = 0 ;
52745 PyObject * obj0 = 0 ;
52746 PyObject * obj1 = 0 ;
52747 char * kwnames[] = {
52748 (char *) "self",(char *) "window", NULL
52749 };
52750
52751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
52752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52753 if (!SWIG_IsOK(res1)) {
52754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
52755 }
52756 arg1 = reinterpret_cast< wxSizer * >(argp1);
52757 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52758 if (!SWIG_IsOK(res2)) {
52759 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
52760 }
52761 arg2 = reinterpret_cast< wxWindow * >(argp2);
52762 {
52763 PyThreadState* __tstate = wxPyBeginAllowThreads();
52764 (arg1)->FitInside(arg2);
52765 wxPyEndAllowThreads(__tstate);
52766 if (PyErr_Occurred()) SWIG_fail;
52767 }
52768 resultobj = SWIG_Py_Void();
52769 return resultobj;
52770 fail:
52771 return NULL;
52772 }
52773
52774
52775 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52776 PyObject *resultobj = 0;
52777 wxSizer *arg1 = (wxSizer *) 0 ;
52778 wxWindow *arg2 = (wxWindow *) 0 ;
52779 void *argp1 = 0 ;
52780 int res1 = 0 ;
52781 void *argp2 = 0 ;
52782 int res2 = 0 ;
52783 PyObject * obj0 = 0 ;
52784 PyObject * obj1 = 0 ;
52785 char * kwnames[] = {
52786 (char *) "self",(char *) "window", NULL
52787 };
52788
52789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
52790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52791 if (!SWIG_IsOK(res1)) {
52792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
52793 }
52794 arg1 = reinterpret_cast< wxSizer * >(argp1);
52795 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52796 if (!SWIG_IsOK(res2)) {
52797 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
52798 }
52799 arg2 = reinterpret_cast< wxWindow * >(argp2);
52800 {
52801 PyThreadState* __tstate = wxPyBeginAllowThreads();
52802 (arg1)->SetSizeHints(arg2);
52803 wxPyEndAllowThreads(__tstate);
52804 if (PyErr_Occurred()) SWIG_fail;
52805 }
52806 resultobj = SWIG_Py_Void();
52807 return resultobj;
52808 fail:
52809 return NULL;
52810 }
52811
52812
52813 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52814 PyObject *resultobj = 0;
52815 wxSizer *arg1 = (wxSizer *) 0 ;
52816 wxWindow *arg2 = (wxWindow *) 0 ;
52817 void *argp1 = 0 ;
52818 int res1 = 0 ;
52819 void *argp2 = 0 ;
52820 int res2 = 0 ;
52821 PyObject * obj0 = 0 ;
52822 PyObject * obj1 = 0 ;
52823 char * kwnames[] = {
52824 (char *) "self",(char *) "window", NULL
52825 };
52826
52827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
52828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52829 if (!SWIG_IsOK(res1)) {
52830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
52831 }
52832 arg1 = reinterpret_cast< wxSizer * >(argp1);
52833 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52834 if (!SWIG_IsOK(res2)) {
52835 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
52836 }
52837 arg2 = reinterpret_cast< wxWindow * >(argp2);
52838 {
52839 PyThreadState* __tstate = wxPyBeginAllowThreads();
52840 (arg1)->SetVirtualSizeHints(arg2);
52841 wxPyEndAllowThreads(__tstate);
52842 if (PyErr_Occurred()) SWIG_fail;
52843 }
52844 resultobj = SWIG_Py_Void();
52845 return resultobj;
52846 fail:
52847 return NULL;
52848 }
52849
52850
52851 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52852 PyObject *resultobj = 0;
52853 wxSizer *arg1 = (wxSizer *) 0 ;
52854 bool arg2 = (bool) false ;
52855 void *argp1 = 0 ;
52856 int res1 = 0 ;
52857 bool val2 ;
52858 int ecode2 = 0 ;
52859 PyObject * obj0 = 0 ;
52860 PyObject * obj1 = 0 ;
52861 char * kwnames[] = {
52862 (char *) "self",(char *) "deleteWindows", NULL
52863 };
52864
52865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
52866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52867 if (!SWIG_IsOK(res1)) {
52868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
52869 }
52870 arg1 = reinterpret_cast< wxSizer * >(argp1);
52871 if (obj1) {
52872 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52873 if (!SWIG_IsOK(ecode2)) {
52874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
52875 }
52876 arg2 = static_cast< bool >(val2);
52877 }
52878 {
52879 PyThreadState* __tstate = wxPyBeginAllowThreads();
52880 (arg1)->Clear(arg2);
52881 wxPyEndAllowThreads(__tstate);
52882 if (PyErr_Occurred()) SWIG_fail;
52883 }
52884 resultobj = SWIG_Py_Void();
52885 return resultobj;
52886 fail:
52887 return NULL;
52888 }
52889
52890
52891 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52892 PyObject *resultobj = 0;
52893 wxSizer *arg1 = (wxSizer *) 0 ;
52894 void *argp1 = 0 ;
52895 int res1 = 0 ;
52896 PyObject *swig_obj[1] ;
52897
52898 if (!args) SWIG_fail;
52899 swig_obj[0] = args;
52900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52901 if (!SWIG_IsOK(res1)) {
52902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
52903 }
52904 arg1 = reinterpret_cast< wxSizer * >(argp1);
52905 {
52906 PyThreadState* __tstate = wxPyBeginAllowThreads();
52907 (arg1)->DeleteWindows();
52908 wxPyEndAllowThreads(__tstate);
52909 if (PyErr_Occurred()) SWIG_fail;
52910 }
52911 resultobj = SWIG_Py_Void();
52912 return resultobj;
52913 fail:
52914 return NULL;
52915 }
52916
52917
52918 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52919 PyObject *resultobj = 0;
52920 wxSizer *arg1 = (wxSizer *) 0 ;
52921 PyObject *result = 0 ;
52922 void *argp1 = 0 ;
52923 int res1 = 0 ;
52924 PyObject *swig_obj[1] ;
52925
52926 if (!args) SWIG_fail;
52927 swig_obj[0] = args;
52928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52929 if (!SWIG_IsOK(res1)) {
52930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
52931 }
52932 arg1 = reinterpret_cast< wxSizer * >(argp1);
52933 {
52934 PyThreadState* __tstate = wxPyBeginAllowThreads();
52935 result = (PyObject *)wxSizer_GetChildren(arg1);
52936 wxPyEndAllowThreads(__tstate);
52937 if (PyErr_Occurred()) SWIG_fail;
52938 }
52939 resultobj = result;
52940 return resultobj;
52941 fail:
52942 return NULL;
52943 }
52944
52945
52946 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52947 PyObject *resultobj = 0;
52948 wxSizer *arg1 = (wxSizer *) 0 ;
52949 PyObject *arg2 = (PyObject *) 0 ;
52950 bool arg3 = (bool) true ;
52951 bool arg4 = (bool) false ;
52952 bool result;
52953 void *argp1 = 0 ;
52954 int res1 = 0 ;
52955 bool val3 ;
52956 int ecode3 = 0 ;
52957 bool val4 ;
52958 int ecode4 = 0 ;
52959 PyObject * obj0 = 0 ;
52960 PyObject * obj1 = 0 ;
52961 PyObject * obj2 = 0 ;
52962 PyObject * obj3 = 0 ;
52963 char * kwnames[] = {
52964 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
52965 };
52966
52967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52969 if (!SWIG_IsOK(res1)) {
52970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
52971 }
52972 arg1 = reinterpret_cast< wxSizer * >(argp1);
52973 arg2 = obj1;
52974 if (obj2) {
52975 ecode3 = SWIG_AsVal_bool(obj2, &val3);
52976 if (!SWIG_IsOK(ecode3)) {
52977 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
52978 }
52979 arg3 = static_cast< bool >(val3);
52980 }
52981 if (obj3) {
52982 ecode4 = SWIG_AsVal_bool(obj3, &val4);
52983 if (!SWIG_IsOK(ecode4)) {
52984 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
52985 }
52986 arg4 = static_cast< bool >(val4);
52987 }
52988 {
52989 PyThreadState* __tstate = wxPyBeginAllowThreads();
52990 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
52991 wxPyEndAllowThreads(__tstate);
52992 if (PyErr_Occurred()) SWIG_fail;
52993 }
52994 {
52995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52996 }
52997 return resultobj;
52998 fail:
52999 return NULL;
53000 }
53001
53002
53003 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53004 PyObject *resultobj = 0;
53005 wxSizer *arg1 = (wxSizer *) 0 ;
53006 PyObject *arg2 = (PyObject *) 0 ;
53007 bool result;
53008 void *argp1 = 0 ;
53009 int res1 = 0 ;
53010 PyObject * obj0 = 0 ;
53011 PyObject * obj1 = 0 ;
53012 char * kwnames[] = {
53013 (char *) "self",(char *) "item", NULL
53014 };
53015
53016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
53017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
53018 if (!SWIG_IsOK(res1)) {
53019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
53020 }
53021 arg1 = reinterpret_cast< wxSizer * >(argp1);
53022 arg2 = obj1;
53023 {
53024 PyThreadState* __tstate = wxPyBeginAllowThreads();
53025 result = (bool)wxSizer_IsShown(arg1,arg2);
53026 wxPyEndAllowThreads(__tstate);
53027 if (PyErr_Occurred()) SWIG_fail;
53028 }
53029 {
53030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53031 }
53032 return resultobj;
53033 fail:
53034 return NULL;
53035 }
53036
53037
53038 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53039 PyObject *resultobj = 0;
53040 wxSizer *arg1 = (wxSizer *) 0 ;
53041 bool arg2 ;
53042 void *argp1 = 0 ;
53043 int res1 = 0 ;
53044 bool val2 ;
53045 int ecode2 = 0 ;
53046 PyObject * obj0 = 0 ;
53047 PyObject * obj1 = 0 ;
53048 char * kwnames[] = {
53049 (char *) "self",(char *) "show", NULL
53050 };
53051
53052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
53053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
53054 if (!SWIG_IsOK(res1)) {
53055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
53056 }
53057 arg1 = reinterpret_cast< wxSizer * >(argp1);
53058 ecode2 = SWIG_AsVal_bool(obj1, &val2);
53059 if (!SWIG_IsOK(ecode2)) {
53060 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
53061 }
53062 arg2 = static_cast< bool >(val2);
53063 {
53064 PyThreadState* __tstate = wxPyBeginAllowThreads();
53065 (arg1)->ShowItems(arg2);
53066 wxPyEndAllowThreads(__tstate);
53067 if (PyErr_Occurred()) SWIG_fail;
53068 }
53069 resultobj = SWIG_Py_Void();
53070 return resultobj;
53071 fail:
53072 return NULL;
53073 }
53074
53075
53076 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53077 PyObject *obj;
53078 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53079 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
53080 return SWIG_Py_Void();
53081 }
53082
53083 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53084 PyObject *resultobj = 0;
53085 wxPySizer *result = 0 ;
53086
53087 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
53088 {
53089 PyThreadState* __tstate = wxPyBeginAllowThreads();
53090 result = (wxPySizer *)new wxPySizer();
53091 wxPyEndAllowThreads(__tstate);
53092 if (PyErr_Occurred()) SWIG_fail;
53093 }
53094 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
53095 return resultobj;
53096 fail:
53097 return NULL;
53098 }
53099
53100
53101 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53102 PyObject *resultobj = 0;
53103 wxPySizer *arg1 = (wxPySizer *) 0 ;
53104 PyObject *arg2 = (PyObject *) 0 ;
53105 PyObject *arg3 = (PyObject *) 0 ;
53106 void *argp1 = 0 ;
53107 int res1 = 0 ;
53108 PyObject * obj0 = 0 ;
53109 PyObject * obj1 = 0 ;
53110 PyObject * obj2 = 0 ;
53111 char * kwnames[] = {
53112 (char *) "self",(char *) "self",(char *) "_class", NULL
53113 };
53114
53115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
53117 if (!SWIG_IsOK(res1)) {
53118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
53119 }
53120 arg1 = reinterpret_cast< wxPySizer * >(argp1);
53121 arg2 = obj1;
53122 arg3 = obj2;
53123 {
53124 PyThreadState* __tstate = wxPyBeginAllowThreads();
53125 (arg1)->_setCallbackInfo(arg2,arg3);
53126 wxPyEndAllowThreads(__tstate);
53127 if (PyErr_Occurred()) SWIG_fail;
53128 }
53129 resultobj = SWIG_Py_Void();
53130 return resultobj;
53131 fail:
53132 return NULL;
53133 }
53134
53135
53136 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53137 PyObject *obj;
53138 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53139 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
53140 return SWIG_Py_Void();
53141 }
53142
53143 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53144 return SWIG_Python_InitShadowInstance(args);
53145 }
53146
53147 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53148 PyObject *resultobj = 0;
53149 int arg1 = (int) wxHORIZONTAL ;
53150 wxBoxSizer *result = 0 ;
53151 int val1 ;
53152 int ecode1 = 0 ;
53153 PyObject * obj0 = 0 ;
53154 char * kwnames[] = {
53155 (char *) "orient", NULL
53156 };
53157
53158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
53159 if (obj0) {
53160 ecode1 = SWIG_AsVal_int(obj0, &val1);
53161 if (!SWIG_IsOK(ecode1)) {
53162 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
53163 }
53164 arg1 = static_cast< int >(val1);
53165 }
53166 {
53167 PyThreadState* __tstate = wxPyBeginAllowThreads();
53168 result = (wxBoxSizer *)new wxBoxSizer(arg1);
53169 wxPyEndAllowThreads(__tstate);
53170 if (PyErr_Occurred()) SWIG_fail;
53171 }
53172 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
53173 return resultobj;
53174 fail:
53175 return NULL;
53176 }
53177
53178
53179 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53180 PyObject *resultobj = 0;
53181 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
53182 int result;
53183 void *argp1 = 0 ;
53184 int res1 = 0 ;
53185 PyObject *swig_obj[1] ;
53186
53187 if (!args) SWIG_fail;
53188 swig_obj[0] = args;
53189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
53190 if (!SWIG_IsOK(res1)) {
53191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
53192 }
53193 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
53194 {
53195 PyThreadState* __tstate = wxPyBeginAllowThreads();
53196 result = (int)(arg1)->GetOrientation();
53197 wxPyEndAllowThreads(__tstate);
53198 if (PyErr_Occurred()) SWIG_fail;
53199 }
53200 resultobj = SWIG_From_int(static_cast< int >(result));
53201 return resultobj;
53202 fail:
53203 return NULL;
53204 }
53205
53206
53207 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53208 PyObject *resultobj = 0;
53209 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
53210 int arg2 ;
53211 void *argp1 = 0 ;
53212 int res1 = 0 ;
53213 int val2 ;
53214 int ecode2 = 0 ;
53215 PyObject * obj0 = 0 ;
53216 PyObject * obj1 = 0 ;
53217 char * kwnames[] = {
53218 (char *) "self",(char *) "orient", NULL
53219 };
53220
53221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
53222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
53223 if (!SWIG_IsOK(res1)) {
53224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
53225 }
53226 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
53227 ecode2 = SWIG_AsVal_int(obj1, &val2);
53228 if (!SWIG_IsOK(ecode2)) {
53229 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
53230 }
53231 arg2 = static_cast< int >(val2);
53232 {
53233 PyThreadState* __tstate = wxPyBeginAllowThreads();
53234 (arg1)->SetOrientation(arg2);
53235 wxPyEndAllowThreads(__tstate);
53236 if (PyErr_Occurred()) SWIG_fail;
53237 }
53238 resultobj = SWIG_Py_Void();
53239 return resultobj;
53240 fail:
53241 return NULL;
53242 }
53243
53244
53245 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53246 PyObject *obj;
53247 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53248 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
53249 return SWIG_Py_Void();
53250 }
53251
53252 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53253 return SWIG_Python_InitShadowInstance(args);
53254 }
53255
53256 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53257 PyObject *resultobj = 0;
53258 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
53259 int arg2 = (int) wxHORIZONTAL ;
53260 wxStaticBoxSizer *result = 0 ;
53261 void *argp1 = 0 ;
53262 int res1 = 0 ;
53263 int val2 ;
53264 int ecode2 = 0 ;
53265 PyObject * obj0 = 0 ;
53266 PyObject * obj1 = 0 ;
53267 char * kwnames[] = {
53268 (char *) "box",(char *) "orient", NULL
53269 };
53270
53271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
53273 if (!SWIG_IsOK(res1)) {
53274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
53275 }
53276 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
53277 if (obj1) {
53278 ecode2 = SWIG_AsVal_int(obj1, &val2);
53279 if (!SWIG_IsOK(ecode2)) {
53280 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
53281 }
53282 arg2 = static_cast< int >(val2);
53283 }
53284 {
53285 PyThreadState* __tstate = wxPyBeginAllowThreads();
53286 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
53287 wxPyEndAllowThreads(__tstate);
53288 if (PyErr_Occurred()) SWIG_fail;
53289 }
53290 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
53291 return resultobj;
53292 fail:
53293 return NULL;
53294 }
53295
53296
53297 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53298 PyObject *resultobj = 0;
53299 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
53300 wxStaticBox *result = 0 ;
53301 void *argp1 = 0 ;
53302 int res1 = 0 ;
53303 PyObject *swig_obj[1] ;
53304
53305 if (!args) SWIG_fail;
53306 swig_obj[0] = args;
53307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
53308 if (!SWIG_IsOK(res1)) {
53309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
53310 }
53311 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
53312 {
53313 PyThreadState* __tstate = wxPyBeginAllowThreads();
53314 result = (wxStaticBox *)(arg1)->GetStaticBox();
53315 wxPyEndAllowThreads(__tstate);
53316 if (PyErr_Occurred()) SWIG_fail;
53317 }
53318 {
53319 resultobj = wxPyMake_wxObject(result, (bool)0);
53320 }
53321 return resultobj;
53322 fail:
53323 return NULL;
53324 }
53325
53326
53327 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53328 PyObject *obj;
53329 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53330 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
53331 return SWIG_Py_Void();
53332 }
53333
53334 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53335 return SWIG_Python_InitShadowInstance(args);
53336 }
53337
53338 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53339 PyObject *resultobj = 0;
53340 int arg1 = (int) 1 ;
53341 int arg2 = (int) 0 ;
53342 int arg3 = (int) 0 ;
53343 int arg4 = (int) 0 ;
53344 wxGridSizer *result = 0 ;
53345 int val1 ;
53346 int ecode1 = 0 ;
53347 int val2 ;
53348 int ecode2 = 0 ;
53349 int val3 ;
53350 int ecode3 = 0 ;
53351 int val4 ;
53352 int ecode4 = 0 ;
53353 PyObject * obj0 = 0 ;
53354 PyObject * obj1 = 0 ;
53355 PyObject * obj2 = 0 ;
53356 PyObject * obj3 = 0 ;
53357 char * kwnames[] = {
53358 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
53359 };
53360
53361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53362 if (obj0) {
53363 ecode1 = SWIG_AsVal_int(obj0, &val1);
53364 if (!SWIG_IsOK(ecode1)) {
53365 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
53366 }
53367 arg1 = static_cast< int >(val1);
53368 }
53369 if (obj1) {
53370 ecode2 = SWIG_AsVal_int(obj1, &val2);
53371 if (!SWIG_IsOK(ecode2)) {
53372 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
53373 }
53374 arg2 = static_cast< int >(val2);
53375 }
53376 if (obj2) {
53377 ecode3 = SWIG_AsVal_int(obj2, &val3);
53378 if (!SWIG_IsOK(ecode3)) {
53379 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
53380 }
53381 arg3 = static_cast< int >(val3);
53382 }
53383 if (obj3) {
53384 ecode4 = SWIG_AsVal_int(obj3, &val4);
53385 if (!SWIG_IsOK(ecode4)) {
53386 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
53387 }
53388 arg4 = static_cast< int >(val4);
53389 }
53390 {
53391 PyThreadState* __tstate = wxPyBeginAllowThreads();
53392 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
53393 wxPyEndAllowThreads(__tstate);
53394 if (PyErr_Occurred()) SWIG_fail;
53395 }
53396 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
53397 return resultobj;
53398 fail:
53399 return NULL;
53400 }
53401
53402
53403 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53404 PyObject *resultobj = 0;
53405 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53406 int arg2 ;
53407 void *argp1 = 0 ;
53408 int res1 = 0 ;
53409 int val2 ;
53410 int ecode2 = 0 ;
53411 PyObject * obj0 = 0 ;
53412 PyObject * obj1 = 0 ;
53413 char * kwnames[] = {
53414 (char *) "self",(char *) "cols", NULL
53415 };
53416
53417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
53418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53419 if (!SWIG_IsOK(res1)) {
53420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53421 }
53422 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53423 ecode2 = SWIG_AsVal_int(obj1, &val2);
53424 if (!SWIG_IsOK(ecode2)) {
53425 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
53426 }
53427 arg2 = static_cast< int >(val2);
53428 {
53429 PyThreadState* __tstate = wxPyBeginAllowThreads();
53430 (arg1)->SetCols(arg2);
53431 wxPyEndAllowThreads(__tstate);
53432 if (PyErr_Occurred()) SWIG_fail;
53433 }
53434 resultobj = SWIG_Py_Void();
53435 return resultobj;
53436 fail:
53437 return NULL;
53438 }
53439
53440
53441 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53442 PyObject *resultobj = 0;
53443 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53444 int arg2 ;
53445 void *argp1 = 0 ;
53446 int res1 = 0 ;
53447 int val2 ;
53448 int ecode2 = 0 ;
53449 PyObject * obj0 = 0 ;
53450 PyObject * obj1 = 0 ;
53451 char * kwnames[] = {
53452 (char *) "self",(char *) "rows", NULL
53453 };
53454
53455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
53456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53457 if (!SWIG_IsOK(res1)) {
53458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53459 }
53460 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53461 ecode2 = SWIG_AsVal_int(obj1, &val2);
53462 if (!SWIG_IsOK(ecode2)) {
53463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
53464 }
53465 arg2 = static_cast< int >(val2);
53466 {
53467 PyThreadState* __tstate = wxPyBeginAllowThreads();
53468 (arg1)->SetRows(arg2);
53469 wxPyEndAllowThreads(__tstate);
53470 if (PyErr_Occurred()) SWIG_fail;
53471 }
53472 resultobj = SWIG_Py_Void();
53473 return resultobj;
53474 fail:
53475 return NULL;
53476 }
53477
53478
53479 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53480 PyObject *resultobj = 0;
53481 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53482 int arg2 ;
53483 void *argp1 = 0 ;
53484 int res1 = 0 ;
53485 int val2 ;
53486 int ecode2 = 0 ;
53487 PyObject * obj0 = 0 ;
53488 PyObject * obj1 = 0 ;
53489 char * kwnames[] = {
53490 (char *) "self",(char *) "gap", NULL
53491 };
53492
53493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
53494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53495 if (!SWIG_IsOK(res1)) {
53496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53497 }
53498 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53499 ecode2 = SWIG_AsVal_int(obj1, &val2);
53500 if (!SWIG_IsOK(ecode2)) {
53501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
53502 }
53503 arg2 = static_cast< int >(val2);
53504 {
53505 PyThreadState* __tstate = wxPyBeginAllowThreads();
53506 (arg1)->SetVGap(arg2);
53507 wxPyEndAllowThreads(__tstate);
53508 if (PyErr_Occurred()) SWIG_fail;
53509 }
53510 resultobj = SWIG_Py_Void();
53511 return resultobj;
53512 fail:
53513 return NULL;
53514 }
53515
53516
53517 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53518 PyObject *resultobj = 0;
53519 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53520 int arg2 ;
53521 void *argp1 = 0 ;
53522 int res1 = 0 ;
53523 int val2 ;
53524 int ecode2 = 0 ;
53525 PyObject * obj0 = 0 ;
53526 PyObject * obj1 = 0 ;
53527 char * kwnames[] = {
53528 (char *) "self",(char *) "gap", NULL
53529 };
53530
53531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
53532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53533 if (!SWIG_IsOK(res1)) {
53534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53535 }
53536 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53537 ecode2 = SWIG_AsVal_int(obj1, &val2);
53538 if (!SWIG_IsOK(ecode2)) {
53539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
53540 }
53541 arg2 = static_cast< int >(val2);
53542 {
53543 PyThreadState* __tstate = wxPyBeginAllowThreads();
53544 (arg1)->SetHGap(arg2);
53545 wxPyEndAllowThreads(__tstate);
53546 if (PyErr_Occurred()) SWIG_fail;
53547 }
53548 resultobj = SWIG_Py_Void();
53549 return resultobj;
53550 fail:
53551 return NULL;
53552 }
53553
53554
53555 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53556 PyObject *resultobj = 0;
53557 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53558 int result;
53559 void *argp1 = 0 ;
53560 int res1 = 0 ;
53561 PyObject *swig_obj[1] ;
53562
53563 if (!args) SWIG_fail;
53564 swig_obj[0] = args;
53565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53566 if (!SWIG_IsOK(res1)) {
53567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53568 }
53569 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53570 {
53571 PyThreadState* __tstate = wxPyBeginAllowThreads();
53572 result = (int)(arg1)->GetCols();
53573 wxPyEndAllowThreads(__tstate);
53574 if (PyErr_Occurred()) SWIG_fail;
53575 }
53576 resultobj = SWIG_From_int(static_cast< int >(result));
53577 return resultobj;
53578 fail:
53579 return NULL;
53580 }
53581
53582
53583 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53584 PyObject *resultobj = 0;
53585 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53586 int result;
53587 void *argp1 = 0 ;
53588 int res1 = 0 ;
53589 PyObject *swig_obj[1] ;
53590
53591 if (!args) SWIG_fail;
53592 swig_obj[0] = args;
53593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53594 if (!SWIG_IsOK(res1)) {
53595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53596 }
53597 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53598 {
53599 PyThreadState* __tstate = wxPyBeginAllowThreads();
53600 result = (int)(arg1)->GetRows();
53601 wxPyEndAllowThreads(__tstate);
53602 if (PyErr_Occurred()) SWIG_fail;
53603 }
53604 resultobj = SWIG_From_int(static_cast< int >(result));
53605 return resultobj;
53606 fail:
53607 return NULL;
53608 }
53609
53610
53611 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53612 PyObject *resultobj = 0;
53613 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53614 int result;
53615 void *argp1 = 0 ;
53616 int res1 = 0 ;
53617 PyObject *swig_obj[1] ;
53618
53619 if (!args) SWIG_fail;
53620 swig_obj[0] = args;
53621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53622 if (!SWIG_IsOK(res1)) {
53623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53624 }
53625 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53626 {
53627 PyThreadState* __tstate = wxPyBeginAllowThreads();
53628 result = (int)(arg1)->GetVGap();
53629 wxPyEndAllowThreads(__tstate);
53630 if (PyErr_Occurred()) SWIG_fail;
53631 }
53632 resultobj = SWIG_From_int(static_cast< int >(result));
53633 return resultobj;
53634 fail:
53635 return NULL;
53636 }
53637
53638
53639 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53640 PyObject *resultobj = 0;
53641 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53642 int result;
53643 void *argp1 = 0 ;
53644 int res1 = 0 ;
53645 PyObject *swig_obj[1] ;
53646
53647 if (!args) SWIG_fail;
53648 swig_obj[0] = args;
53649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53650 if (!SWIG_IsOK(res1)) {
53651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53652 }
53653 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53654 {
53655 PyThreadState* __tstate = wxPyBeginAllowThreads();
53656 result = (int)(arg1)->GetHGap();
53657 wxPyEndAllowThreads(__tstate);
53658 if (PyErr_Occurred()) SWIG_fail;
53659 }
53660 resultobj = SWIG_From_int(static_cast< int >(result));
53661 return resultobj;
53662 fail:
53663 return NULL;
53664 }
53665
53666
53667 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53668 PyObject *obj;
53669 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53670 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
53671 return SWIG_Py_Void();
53672 }
53673
53674 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53675 return SWIG_Python_InitShadowInstance(args);
53676 }
53677
53678 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53679 PyObject *resultobj = 0;
53680 int arg1 = (int) 1 ;
53681 int arg2 = (int) 0 ;
53682 int arg3 = (int) 0 ;
53683 int arg4 = (int) 0 ;
53684 wxFlexGridSizer *result = 0 ;
53685 int val1 ;
53686 int ecode1 = 0 ;
53687 int val2 ;
53688 int ecode2 = 0 ;
53689 int val3 ;
53690 int ecode3 = 0 ;
53691 int val4 ;
53692 int ecode4 = 0 ;
53693 PyObject * obj0 = 0 ;
53694 PyObject * obj1 = 0 ;
53695 PyObject * obj2 = 0 ;
53696 PyObject * obj3 = 0 ;
53697 char * kwnames[] = {
53698 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
53699 };
53700
53701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53702 if (obj0) {
53703 ecode1 = SWIG_AsVal_int(obj0, &val1);
53704 if (!SWIG_IsOK(ecode1)) {
53705 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
53706 }
53707 arg1 = static_cast< int >(val1);
53708 }
53709 if (obj1) {
53710 ecode2 = SWIG_AsVal_int(obj1, &val2);
53711 if (!SWIG_IsOK(ecode2)) {
53712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
53713 }
53714 arg2 = static_cast< int >(val2);
53715 }
53716 if (obj2) {
53717 ecode3 = SWIG_AsVal_int(obj2, &val3);
53718 if (!SWIG_IsOK(ecode3)) {
53719 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
53720 }
53721 arg3 = static_cast< int >(val3);
53722 }
53723 if (obj3) {
53724 ecode4 = SWIG_AsVal_int(obj3, &val4);
53725 if (!SWIG_IsOK(ecode4)) {
53726 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
53727 }
53728 arg4 = static_cast< int >(val4);
53729 }
53730 {
53731 PyThreadState* __tstate = wxPyBeginAllowThreads();
53732 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
53733 wxPyEndAllowThreads(__tstate);
53734 if (PyErr_Occurred()) SWIG_fail;
53735 }
53736 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
53737 return resultobj;
53738 fail:
53739 return NULL;
53740 }
53741
53742
53743 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53744 PyObject *resultobj = 0;
53745 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53746 size_t arg2 ;
53747 int arg3 = (int) 0 ;
53748 void *argp1 = 0 ;
53749 int res1 = 0 ;
53750 size_t val2 ;
53751 int ecode2 = 0 ;
53752 int val3 ;
53753 int ecode3 = 0 ;
53754 PyObject * obj0 = 0 ;
53755 PyObject * obj1 = 0 ;
53756 PyObject * obj2 = 0 ;
53757 char * kwnames[] = {
53758 (char *) "self",(char *) "idx",(char *) "proportion", NULL
53759 };
53760
53761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53763 if (!SWIG_IsOK(res1)) {
53764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53765 }
53766 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53767 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53768 if (!SWIG_IsOK(ecode2)) {
53769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
53770 }
53771 arg2 = static_cast< size_t >(val2);
53772 if (obj2) {
53773 ecode3 = SWIG_AsVal_int(obj2, &val3);
53774 if (!SWIG_IsOK(ecode3)) {
53775 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
53776 }
53777 arg3 = static_cast< int >(val3);
53778 }
53779 {
53780 PyThreadState* __tstate = wxPyBeginAllowThreads();
53781 (arg1)->AddGrowableRow(arg2,arg3);
53782 wxPyEndAllowThreads(__tstate);
53783 if (PyErr_Occurred()) SWIG_fail;
53784 }
53785 resultobj = SWIG_Py_Void();
53786 return resultobj;
53787 fail:
53788 return NULL;
53789 }
53790
53791
53792 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53793 PyObject *resultobj = 0;
53794 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53795 size_t arg2 ;
53796 void *argp1 = 0 ;
53797 int res1 = 0 ;
53798 size_t val2 ;
53799 int ecode2 = 0 ;
53800 PyObject * obj0 = 0 ;
53801 PyObject * obj1 = 0 ;
53802 char * kwnames[] = {
53803 (char *) "self",(char *) "idx", NULL
53804 };
53805
53806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
53807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53808 if (!SWIG_IsOK(res1)) {
53809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53810 }
53811 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53812 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53813 if (!SWIG_IsOK(ecode2)) {
53814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
53815 }
53816 arg2 = static_cast< size_t >(val2);
53817 {
53818 PyThreadState* __tstate = wxPyBeginAllowThreads();
53819 (arg1)->RemoveGrowableRow(arg2);
53820 wxPyEndAllowThreads(__tstate);
53821 if (PyErr_Occurred()) SWIG_fail;
53822 }
53823 resultobj = SWIG_Py_Void();
53824 return resultobj;
53825 fail:
53826 return NULL;
53827 }
53828
53829
53830 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53831 PyObject *resultobj = 0;
53832 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53833 size_t arg2 ;
53834 int arg3 = (int) 0 ;
53835 void *argp1 = 0 ;
53836 int res1 = 0 ;
53837 size_t val2 ;
53838 int ecode2 = 0 ;
53839 int val3 ;
53840 int ecode3 = 0 ;
53841 PyObject * obj0 = 0 ;
53842 PyObject * obj1 = 0 ;
53843 PyObject * obj2 = 0 ;
53844 char * kwnames[] = {
53845 (char *) "self",(char *) "idx",(char *) "proportion", NULL
53846 };
53847
53848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53850 if (!SWIG_IsOK(res1)) {
53851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53852 }
53853 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53854 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53855 if (!SWIG_IsOK(ecode2)) {
53856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
53857 }
53858 arg2 = static_cast< size_t >(val2);
53859 if (obj2) {
53860 ecode3 = SWIG_AsVal_int(obj2, &val3);
53861 if (!SWIG_IsOK(ecode3)) {
53862 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
53863 }
53864 arg3 = static_cast< int >(val3);
53865 }
53866 {
53867 PyThreadState* __tstate = wxPyBeginAllowThreads();
53868 (arg1)->AddGrowableCol(arg2,arg3);
53869 wxPyEndAllowThreads(__tstate);
53870 if (PyErr_Occurred()) SWIG_fail;
53871 }
53872 resultobj = SWIG_Py_Void();
53873 return resultobj;
53874 fail:
53875 return NULL;
53876 }
53877
53878
53879 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53880 PyObject *resultobj = 0;
53881 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53882 size_t arg2 ;
53883 void *argp1 = 0 ;
53884 int res1 = 0 ;
53885 size_t val2 ;
53886 int ecode2 = 0 ;
53887 PyObject * obj0 = 0 ;
53888 PyObject * obj1 = 0 ;
53889 char * kwnames[] = {
53890 (char *) "self",(char *) "idx", NULL
53891 };
53892
53893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
53894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53895 if (!SWIG_IsOK(res1)) {
53896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53897 }
53898 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53899 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53900 if (!SWIG_IsOK(ecode2)) {
53901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
53902 }
53903 arg2 = static_cast< size_t >(val2);
53904 {
53905 PyThreadState* __tstate = wxPyBeginAllowThreads();
53906 (arg1)->RemoveGrowableCol(arg2);
53907 wxPyEndAllowThreads(__tstate);
53908 if (PyErr_Occurred()) SWIG_fail;
53909 }
53910 resultobj = SWIG_Py_Void();
53911 return resultobj;
53912 fail:
53913 return NULL;
53914 }
53915
53916
53917 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53918 PyObject *resultobj = 0;
53919 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53920 int arg2 ;
53921 void *argp1 = 0 ;
53922 int res1 = 0 ;
53923 int val2 ;
53924 int ecode2 = 0 ;
53925 PyObject * obj0 = 0 ;
53926 PyObject * obj1 = 0 ;
53927 char * kwnames[] = {
53928 (char *) "self",(char *) "direction", NULL
53929 };
53930
53931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
53932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53933 if (!SWIG_IsOK(res1)) {
53934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53935 }
53936 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53937 ecode2 = SWIG_AsVal_int(obj1, &val2);
53938 if (!SWIG_IsOK(ecode2)) {
53939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
53940 }
53941 arg2 = static_cast< int >(val2);
53942 {
53943 PyThreadState* __tstate = wxPyBeginAllowThreads();
53944 (arg1)->SetFlexibleDirection(arg2);
53945 wxPyEndAllowThreads(__tstate);
53946 if (PyErr_Occurred()) SWIG_fail;
53947 }
53948 resultobj = SWIG_Py_Void();
53949 return resultobj;
53950 fail:
53951 return NULL;
53952 }
53953
53954
53955 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53956 PyObject *resultobj = 0;
53957 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53958 int result;
53959 void *argp1 = 0 ;
53960 int res1 = 0 ;
53961 PyObject *swig_obj[1] ;
53962
53963 if (!args) SWIG_fail;
53964 swig_obj[0] = args;
53965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53966 if (!SWIG_IsOK(res1)) {
53967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53968 }
53969 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53970 {
53971 PyThreadState* __tstate = wxPyBeginAllowThreads();
53972 result = (int)(arg1)->GetFlexibleDirection();
53973 wxPyEndAllowThreads(__tstate);
53974 if (PyErr_Occurred()) SWIG_fail;
53975 }
53976 resultobj = SWIG_From_int(static_cast< int >(result));
53977 return resultobj;
53978 fail:
53979 return NULL;
53980 }
53981
53982
53983 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53984 PyObject *resultobj = 0;
53985 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53986 wxFlexSizerGrowMode arg2 ;
53987 void *argp1 = 0 ;
53988 int res1 = 0 ;
53989 int val2 ;
53990 int ecode2 = 0 ;
53991 PyObject * obj0 = 0 ;
53992 PyObject * obj1 = 0 ;
53993 char * kwnames[] = {
53994 (char *) "self",(char *) "mode", NULL
53995 };
53996
53997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
53998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53999 if (!SWIG_IsOK(res1)) {
54000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
54001 }
54002 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
54003 ecode2 = SWIG_AsVal_int(obj1, &val2);
54004 if (!SWIG_IsOK(ecode2)) {
54005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
54006 }
54007 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
54008 {
54009 PyThreadState* __tstate = wxPyBeginAllowThreads();
54010 (arg1)->SetNonFlexibleGrowMode(arg2);
54011 wxPyEndAllowThreads(__tstate);
54012 if (PyErr_Occurred()) SWIG_fail;
54013 }
54014 resultobj = SWIG_Py_Void();
54015 return resultobj;
54016 fail:
54017 return NULL;
54018 }
54019
54020
54021 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54022 PyObject *resultobj = 0;
54023 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
54024 wxFlexSizerGrowMode result;
54025 void *argp1 = 0 ;
54026 int res1 = 0 ;
54027 PyObject *swig_obj[1] ;
54028
54029 if (!args) SWIG_fail;
54030 swig_obj[0] = args;
54031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
54032 if (!SWIG_IsOK(res1)) {
54033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
54034 }
54035 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
54036 {
54037 PyThreadState* __tstate = wxPyBeginAllowThreads();
54038 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
54039 wxPyEndAllowThreads(__tstate);
54040 if (PyErr_Occurred()) SWIG_fail;
54041 }
54042 resultobj = SWIG_From_int(static_cast< int >(result));
54043 return resultobj;
54044 fail:
54045 return NULL;
54046 }
54047
54048
54049 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54050 PyObject *resultobj = 0;
54051 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
54052 wxArrayInt *result = 0 ;
54053 void *argp1 = 0 ;
54054 int res1 = 0 ;
54055 PyObject *swig_obj[1] ;
54056
54057 if (!args) SWIG_fail;
54058 swig_obj[0] = args;
54059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
54060 if (!SWIG_IsOK(res1)) {
54061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
54062 }
54063 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
54064 {
54065 PyThreadState* __tstate = wxPyBeginAllowThreads();
54066 {
54067 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
54068 result = (wxArrayInt *) &_result_ref;
54069 }
54070 wxPyEndAllowThreads(__tstate);
54071 if (PyErr_Occurred()) SWIG_fail;
54072 }
54073 {
54074 resultobj = wxArrayInt2PyList_helper(*result);
54075 }
54076 return resultobj;
54077 fail:
54078 return NULL;
54079 }
54080
54081
54082 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54083 PyObject *resultobj = 0;
54084 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
54085 wxArrayInt *result = 0 ;
54086 void *argp1 = 0 ;
54087 int res1 = 0 ;
54088 PyObject *swig_obj[1] ;
54089
54090 if (!args) SWIG_fail;
54091 swig_obj[0] = args;
54092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
54093 if (!SWIG_IsOK(res1)) {
54094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
54095 }
54096 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
54097 {
54098 PyThreadState* __tstate = wxPyBeginAllowThreads();
54099 {
54100 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
54101 result = (wxArrayInt *) &_result_ref;
54102 }
54103 wxPyEndAllowThreads(__tstate);
54104 if (PyErr_Occurred()) SWIG_fail;
54105 }
54106 {
54107 resultobj = wxArrayInt2PyList_helper(*result);
54108 }
54109 return resultobj;
54110 fail:
54111 return NULL;
54112 }
54113
54114
54115 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54116 PyObject *obj;
54117 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54118 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
54119 return SWIG_Py_Void();
54120 }
54121
54122 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54123 return SWIG_Python_InitShadowInstance(args);
54124 }
54125
54126 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54127 PyObject *resultobj = 0;
54128 wxStdDialogButtonSizer *result = 0 ;
54129
54130 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
54131 {
54132 PyThreadState* __tstate = wxPyBeginAllowThreads();
54133 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
54134 wxPyEndAllowThreads(__tstate);
54135 if (PyErr_Occurred()) SWIG_fail;
54136 }
54137 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
54138 return resultobj;
54139 fail:
54140 return NULL;
54141 }
54142
54143
54144 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54145 PyObject *resultobj = 0;
54146 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54147 wxButton *arg2 = (wxButton *) 0 ;
54148 void *argp1 = 0 ;
54149 int res1 = 0 ;
54150 void *argp2 = 0 ;
54151 int res2 = 0 ;
54152 PyObject * obj0 = 0 ;
54153 PyObject * obj1 = 0 ;
54154 char * kwnames[] = {
54155 (char *) "self",(char *) "button", NULL
54156 };
54157
54158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
54159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54160 if (!SWIG_IsOK(res1)) {
54161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
54162 }
54163 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54164 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
54165 if (!SWIG_IsOK(res2)) {
54166 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
54167 }
54168 arg2 = reinterpret_cast< wxButton * >(argp2);
54169 {
54170 PyThreadState* __tstate = wxPyBeginAllowThreads();
54171 (arg1)->AddButton(arg2);
54172 wxPyEndAllowThreads(__tstate);
54173 if (PyErr_Occurred()) SWIG_fail;
54174 }
54175 resultobj = SWIG_Py_Void();
54176 return resultobj;
54177 fail:
54178 return NULL;
54179 }
54180
54181
54182 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54183 PyObject *resultobj = 0;
54184 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54185 void *argp1 = 0 ;
54186 int res1 = 0 ;
54187 PyObject *swig_obj[1] ;
54188
54189 if (!args) SWIG_fail;
54190 swig_obj[0] = args;
54191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54192 if (!SWIG_IsOK(res1)) {
54193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
54194 }
54195 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54196 {
54197 PyThreadState* __tstate = wxPyBeginAllowThreads();
54198 (arg1)->Realize();
54199 wxPyEndAllowThreads(__tstate);
54200 if (PyErr_Occurred()) SWIG_fail;
54201 }
54202 resultobj = SWIG_Py_Void();
54203 return resultobj;
54204 fail:
54205 return NULL;
54206 }
54207
54208
54209 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54210 PyObject *resultobj = 0;
54211 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54212 wxButton *arg2 = (wxButton *) 0 ;
54213 void *argp1 = 0 ;
54214 int res1 = 0 ;
54215 void *argp2 = 0 ;
54216 int res2 = 0 ;
54217 PyObject * obj0 = 0 ;
54218 PyObject * obj1 = 0 ;
54219 char * kwnames[] = {
54220 (char *) "self",(char *) "button", NULL
54221 };
54222
54223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
54224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54225 if (!SWIG_IsOK(res1)) {
54226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
54227 }
54228 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54229 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
54230 if (!SWIG_IsOK(res2)) {
54231 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
54232 }
54233 arg2 = reinterpret_cast< wxButton * >(argp2);
54234 {
54235 PyThreadState* __tstate = wxPyBeginAllowThreads();
54236 (arg1)->SetAffirmativeButton(arg2);
54237 wxPyEndAllowThreads(__tstate);
54238 if (PyErr_Occurred()) SWIG_fail;
54239 }
54240 resultobj = SWIG_Py_Void();
54241 return resultobj;
54242 fail:
54243 return NULL;
54244 }
54245
54246
54247 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54248 PyObject *resultobj = 0;
54249 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54250 wxButton *arg2 = (wxButton *) 0 ;
54251 void *argp1 = 0 ;
54252 int res1 = 0 ;
54253 void *argp2 = 0 ;
54254 int res2 = 0 ;
54255 PyObject * obj0 = 0 ;
54256 PyObject * obj1 = 0 ;
54257 char * kwnames[] = {
54258 (char *) "self",(char *) "button", NULL
54259 };
54260
54261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
54262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54263 if (!SWIG_IsOK(res1)) {
54264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
54265 }
54266 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54267 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
54268 if (!SWIG_IsOK(res2)) {
54269 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
54270 }
54271 arg2 = reinterpret_cast< wxButton * >(argp2);
54272 {
54273 PyThreadState* __tstate = wxPyBeginAllowThreads();
54274 (arg1)->SetNegativeButton(arg2);
54275 wxPyEndAllowThreads(__tstate);
54276 if (PyErr_Occurred()) SWIG_fail;
54277 }
54278 resultobj = SWIG_Py_Void();
54279 return resultobj;
54280 fail:
54281 return NULL;
54282 }
54283
54284
54285 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54286 PyObject *resultobj = 0;
54287 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54288 wxButton *arg2 = (wxButton *) 0 ;
54289 void *argp1 = 0 ;
54290 int res1 = 0 ;
54291 void *argp2 = 0 ;
54292 int res2 = 0 ;
54293 PyObject * obj0 = 0 ;
54294 PyObject * obj1 = 0 ;
54295 char * kwnames[] = {
54296 (char *) "self",(char *) "button", NULL
54297 };
54298
54299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
54300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54301 if (!SWIG_IsOK(res1)) {
54302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
54303 }
54304 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54305 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
54306 if (!SWIG_IsOK(res2)) {
54307 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
54308 }
54309 arg2 = reinterpret_cast< wxButton * >(argp2);
54310 {
54311 PyThreadState* __tstate = wxPyBeginAllowThreads();
54312 (arg1)->SetCancelButton(arg2);
54313 wxPyEndAllowThreads(__tstate);
54314 if (PyErr_Occurred()) SWIG_fail;
54315 }
54316 resultobj = SWIG_Py_Void();
54317 return resultobj;
54318 fail:
54319 return NULL;
54320 }
54321
54322
54323 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54324 PyObject *resultobj = 0;
54325 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54326 wxButton *result = 0 ;
54327 void *argp1 = 0 ;
54328 int res1 = 0 ;
54329 PyObject *swig_obj[1] ;
54330
54331 if (!args) SWIG_fail;
54332 swig_obj[0] = args;
54333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54334 if (!SWIG_IsOK(res1)) {
54335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
54336 }
54337 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54338 {
54339 PyThreadState* __tstate = wxPyBeginAllowThreads();
54340 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
54341 wxPyEndAllowThreads(__tstate);
54342 if (PyErr_Occurred()) SWIG_fail;
54343 }
54344 {
54345 resultobj = wxPyMake_wxObject(result, (bool)0);
54346 }
54347 return resultobj;
54348 fail:
54349 return NULL;
54350 }
54351
54352
54353 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54354 PyObject *resultobj = 0;
54355 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54356 wxButton *result = 0 ;
54357 void *argp1 = 0 ;
54358 int res1 = 0 ;
54359 PyObject *swig_obj[1] ;
54360
54361 if (!args) SWIG_fail;
54362 swig_obj[0] = args;
54363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54364 if (!SWIG_IsOK(res1)) {
54365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
54366 }
54367 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54368 {
54369 PyThreadState* __tstate = wxPyBeginAllowThreads();
54370 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
54371 wxPyEndAllowThreads(__tstate);
54372 if (PyErr_Occurred()) SWIG_fail;
54373 }
54374 {
54375 resultobj = wxPyMake_wxObject(result, (bool)0);
54376 }
54377 return resultobj;
54378 fail:
54379 return NULL;
54380 }
54381
54382
54383 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54384 PyObject *resultobj = 0;
54385 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54386 wxButton *result = 0 ;
54387 void *argp1 = 0 ;
54388 int res1 = 0 ;
54389 PyObject *swig_obj[1] ;
54390
54391 if (!args) SWIG_fail;
54392 swig_obj[0] = args;
54393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54394 if (!SWIG_IsOK(res1)) {
54395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
54396 }
54397 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54398 {
54399 PyThreadState* __tstate = wxPyBeginAllowThreads();
54400 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
54401 wxPyEndAllowThreads(__tstate);
54402 if (PyErr_Occurred()) SWIG_fail;
54403 }
54404 {
54405 resultobj = wxPyMake_wxObject(result, (bool)0);
54406 }
54407 return resultobj;
54408 fail:
54409 return NULL;
54410 }
54411
54412
54413 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54414 PyObject *resultobj = 0;
54415 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54416 wxButton *result = 0 ;
54417 void *argp1 = 0 ;
54418 int res1 = 0 ;
54419 PyObject *swig_obj[1] ;
54420
54421 if (!args) SWIG_fail;
54422 swig_obj[0] = args;
54423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54424 if (!SWIG_IsOK(res1)) {
54425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
54426 }
54427 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54428 {
54429 PyThreadState* __tstate = wxPyBeginAllowThreads();
54430 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
54431 wxPyEndAllowThreads(__tstate);
54432 if (PyErr_Occurred()) SWIG_fail;
54433 }
54434 {
54435 resultobj = wxPyMake_wxObject(result, (bool)0);
54436 }
54437 return resultobj;
54438 fail:
54439 return NULL;
54440 }
54441
54442
54443 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54444 PyObject *resultobj = 0;
54445 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54446 wxButton *result = 0 ;
54447 void *argp1 = 0 ;
54448 int res1 = 0 ;
54449 PyObject *swig_obj[1] ;
54450
54451 if (!args) SWIG_fail;
54452 swig_obj[0] = args;
54453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54454 if (!SWIG_IsOK(res1)) {
54455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
54456 }
54457 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54458 {
54459 PyThreadState* __tstate = wxPyBeginAllowThreads();
54460 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
54461 wxPyEndAllowThreads(__tstate);
54462 if (PyErr_Occurred()) SWIG_fail;
54463 }
54464 {
54465 resultobj = wxPyMake_wxObject(result, (bool)0);
54466 }
54467 return resultobj;
54468 fail:
54469 return NULL;
54470 }
54471
54472
54473 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54474 PyObject *obj;
54475 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54476 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
54477 return SWIG_Py_Void();
54478 }
54479
54480 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54481 return SWIG_Python_InitShadowInstance(args);
54482 }
54483
54484 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54485 PyObject *resultobj = 0;
54486 int arg1 = (int) 0 ;
54487 int arg2 = (int) 0 ;
54488 wxGBPosition *result = 0 ;
54489 int val1 ;
54490 int ecode1 = 0 ;
54491 int val2 ;
54492 int ecode2 = 0 ;
54493 PyObject * obj0 = 0 ;
54494 PyObject * obj1 = 0 ;
54495 char * kwnames[] = {
54496 (char *) "row",(char *) "col", NULL
54497 };
54498
54499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
54500 if (obj0) {
54501 ecode1 = SWIG_AsVal_int(obj0, &val1);
54502 if (!SWIG_IsOK(ecode1)) {
54503 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
54504 }
54505 arg1 = static_cast< int >(val1);
54506 }
54507 if (obj1) {
54508 ecode2 = SWIG_AsVal_int(obj1, &val2);
54509 if (!SWIG_IsOK(ecode2)) {
54510 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
54511 }
54512 arg2 = static_cast< int >(val2);
54513 }
54514 {
54515 PyThreadState* __tstate = wxPyBeginAllowThreads();
54516 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
54517 wxPyEndAllowThreads(__tstate);
54518 if (PyErr_Occurred()) SWIG_fail;
54519 }
54520 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
54521 return resultobj;
54522 fail:
54523 return NULL;
54524 }
54525
54526
54527 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54528 PyObject *resultobj = 0;
54529 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54530 void *argp1 = 0 ;
54531 int res1 = 0 ;
54532 PyObject *swig_obj[1] ;
54533
54534 if (!args) SWIG_fail;
54535 swig_obj[0] = args;
54536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
54537 if (!SWIG_IsOK(res1)) {
54538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54539 }
54540 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54541 {
54542 PyThreadState* __tstate = wxPyBeginAllowThreads();
54543 delete arg1;
54544
54545 wxPyEndAllowThreads(__tstate);
54546 if (PyErr_Occurred()) SWIG_fail;
54547 }
54548 resultobj = SWIG_Py_Void();
54549 return resultobj;
54550 fail:
54551 return NULL;
54552 }
54553
54554
54555 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54556 PyObject *resultobj = 0;
54557 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54558 int result;
54559 void *argp1 = 0 ;
54560 int res1 = 0 ;
54561 PyObject *swig_obj[1] ;
54562
54563 if (!args) SWIG_fail;
54564 swig_obj[0] = args;
54565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54566 if (!SWIG_IsOK(res1)) {
54567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
54568 }
54569 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54570 {
54571 PyThreadState* __tstate = wxPyBeginAllowThreads();
54572 result = (int)((wxGBPosition const *)arg1)->GetRow();
54573 wxPyEndAllowThreads(__tstate);
54574 if (PyErr_Occurred()) SWIG_fail;
54575 }
54576 resultobj = SWIG_From_int(static_cast< int >(result));
54577 return resultobj;
54578 fail:
54579 return NULL;
54580 }
54581
54582
54583 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54584 PyObject *resultobj = 0;
54585 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54586 int result;
54587 void *argp1 = 0 ;
54588 int res1 = 0 ;
54589 PyObject *swig_obj[1] ;
54590
54591 if (!args) SWIG_fail;
54592 swig_obj[0] = args;
54593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54594 if (!SWIG_IsOK(res1)) {
54595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
54596 }
54597 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54598 {
54599 PyThreadState* __tstate = wxPyBeginAllowThreads();
54600 result = (int)((wxGBPosition const *)arg1)->GetCol();
54601 wxPyEndAllowThreads(__tstate);
54602 if (PyErr_Occurred()) SWIG_fail;
54603 }
54604 resultobj = SWIG_From_int(static_cast< int >(result));
54605 return resultobj;
54606 fail:
54607 return NULL;
54608 }
54609
54610
54611 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54612 PyObject *resultobj = 0;
54613 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54614 int arg2 ;
54615 void *argp1 = 0 ;
54616 int res1 = 0 ;
54617 int val2 ;
54618 int ecode2 = 0 ;
54619 PyObject * obj0 = 0 ;
54620 PyObject * obj1 = 0 ;
54621 char * kwnames[] = {
54622 (char *) "self",(char *) "row", NULL
54623 };
54624
54625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
54626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54627 if (!SWIG_IsOK(res1)) {
54628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54629 }
54630 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54631 ecode2 = SWIG_AsVal_int(obj1, &val2);
54632 if (!SWIG_IsOK(ecode2)) {
54633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
54634 }
54635 arg2 = static_cast< int >(val2);
54636 {
54637 PyThreadState* __tstate = wxPyBeginAllowThreads();
54638 (arg1)->SetRow(arg2);
54639 wxPyEndAllowThreads(__tstate);
54640 if (PyErr_Occurred()) SWIG_fail;
54641 }
54642 resultobj = SWIG_Py_Void();
54643 return resultobj;
54644 fail:
54645 return NULL;
54646 }
54647
54648
54649 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54650 PyObject *resultobj = 0;
54651 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54652 int arg2 ;
54653 void *argp1 = 0 ;
54654 int res1 = 0 ;
54655 int val2 ;
54656 int ecode2 = 0 ;
54657 PyObject * obj0 = 0 ;
54658 PyObject * obj1 = 0 ;
54659 char * kwnames[] = {
54660 (char *) "self",(char *) "col", NULL
54661 };
54662
54663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
54664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54665 if (!SWIG_IsOK(res1)) {
54666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54667 }
54668 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54669 ecode2 = SWIG_AsVal_int(obj1, &val2);
54670 if (!SWIG_IsOK(ecode2)) {
54671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
54672 }
54673 arg2 = static_cast< int >(val2);
54674 {
54675 PyThreadState* __tstate = wxPyBeginAllowThreads();
54676 (arg1)->SetCol(arg2);
54677 wxPyEndAllowThreads(__tstate);
54678 if (PyErr_Occurred()) SWIG_fail;
54679 }
54680 resultobj = SWIG_Py_Void();
54681 return resultobj;
54682 fail:
54683 return NULL;
54684 }
54685
54686
54687 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54688 PyObject *resultobj = 0;
54689 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54690 PyObject *arg2 = (PyObject *) 0 ;
54691 bool result;
54692 void *argp1 = 0 ;
54693 int res1 = 0 ;
54694 PyObject * obj0 = 0 ;
54695 PyObject * obj1 = 0 ;
54696 char * kwnames[] = {
54697 (char *) "self",(char *) "other", NULL
54698 };
54699
54700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
54701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54702 if (!SWIG_IsOK(res1)) {
54703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54704 }
54705 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54706 arg2 = obj1;
54707 {
54708 result = (bool)wxGBPosition___eq__(arg1,arg2);
54709 if (PyErr_Occurred()) SWIG_fail;
54710 }
54711 {
54712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54713 }
54714 return resultobj;
54715 fail:
54716 return NULL;
54717 }
54718
54719
54720 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54721 PyObject *resultobj = 0;
54722 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54723 PyObject *arg2 = (PyObject *) 0 ;
54724 bool result;
54725 void *argp1 = 0 ;
54726 int res1 = 0 ;
54727 PyObject * obj0 = 0 ;
54728 PyObject * obj1 = 0 ;
54729 char * kwnames[] = {
54730 (char *) "self",(char *) "other", NULL
54731 };
54732
54733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
54734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54735 if (!SWIG_IsOK(res1)) {
54736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54737 }
54738 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54739 arg2 = obj1;
54740 {
54741 result = (bool)wxGBPosition___ne__(arg1,arg2);
54742 if (PyErr_Occurred()) SWIG_fail;
54743 }
54744 {
54745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54746 }
54747 return resultobj;
54748 fail:
54749 return NULL;
54750 }
54751
54752
54753 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54754 PyObject *resultobj = 0;
54755 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54756 int arg2 = (int) 0 ;
54757 int arg3 = (int) 0 ;
54758 void *argp1 = 0 ;
54759 int res1 = 0 ;
54760 int val2 ;
54761 int ecode2 = 0 ;
54762 int val3 ;
54763 int ecode3 = 0 ;
54764 PyObject * obj0 = 0 ;
54765 PyObject * obj1 = 0 ;
54766 PyObject * obj2 = 0 ;
54767 char * kwnames[] = {
54768 (char *) "self",(char *) "row",(char *) "col", NULL
54769 };
54770
54771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) 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_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54775 }
54776 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54777 if (obj1) {
54778 ecode2 = SWIG_AsVal_int(obj1, &val2);
54779 if (!SWIG_IsOK(ecode2)) {
54780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
54781 }
54782 arg2 = static_cast< int >(val2);
54783 }
54784 if (obj2) {
54785 ecode3 = SWIG_AsVal_int(obj2, &val3);
54786 if (!SWIG_IsOK(ecode3)) {
54787 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
54788 }
54789 arg3 = static_cast< int >(val3);
54790 }
54791 {
54792 PyThreadState* __tstate = wxPyBeginAllowThreads();
54793 wxGBPosition_Set(arg1,arg2,arg3);
54794 wxPyEndAllowThreads(__tstate);
54795 if (PyErr_Occurred()) SWIG_fail;
54796 }
54797 resultobj = SWIG_Py_Void();
54798 return resultobj;
54799 fail:
54800 return NULL;
54801 }
54802
54803
54804 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54805 PyObject *resultobj = 0;
54806 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54807 PyObject *result = 0 ;
54808 void *argp1 = 0 ;
54809 int res1 = 0 ;
54810 PyObject *swig_obj[1] ;
54811
54812 if (!args) SWIG_fail;
54813 swig_obj[0] = args;
54814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54815 if (!SWIG_IsOK(res1)) {
54816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54817 }
54818 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54819 {
54820 PyThreadState* __tstate = wxPyBeginAllowThreads();
54821 result = (PyObject *)wxGBPosition_Get(arg1);
54822 wxPyEndAllowThreads(__tstate);
54823 if (PyErr_Occurred()) SWIG_fail;
54824 }
54825 resultobj = result;
54826 return resultobj;
54827 fail:
54828 return NULL;
54829 }
54830
54831
54832 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54833 PyObject *obj;
54834 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54835 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
54836 return SWIG_Py_Void();
54837 }
54838
54839 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54840 return SWIG_Python_InitShadowInstance(args);
54841 }
54842
54843 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54844 PyObject *resultobj = 0;
54845 int arg1 = (int) 1 ;
54846 int arg2 = (int) 1 ;
54847 wxGBSpan *result = 0 ;
54848 int val1 ;
54849 int ecode1 = 0 ;
54850 int val2 ;
54851 int ecode2 = 0 ;
54852 PyObject * obj0 = 0 ;
54853 PyObject * obj1 = 0 ;
54854 char * kwnames[] = {
54855 (char *) "rowspan",(char *) "colspan", NULL
54856 };
54857
54858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
54859 if (obj0) {
54860 ecode1 = SWIG_AsVal_int(obj0, &val1);
54861 if (!SWIG_IsOK(ecode1)) {
54862 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
54863 }
54864 arg1 = static_cast< int >(val1);
54865 }
54866 if (obj1) {
54867 ecode2 = SWIG_AsVal_int(obj1, &val2);
54868 if (!SWIG_IsOK(ecode2)) {
54869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
54870 }
54871 arg2 = static_cast< int >(val2);
54872 }
54873 {
54874 PyThreadState* __tstate = wxPyBeginAllowThreads();
54875 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
54876 wxPyEndAllowThreads(__tstate);
54877 if (PyErr_Occurred()) SWIG_fail;
54878 }
54879 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
54880 return resultobj;
54881 fail:
54882 return NULL;
54883 }
54884
54885
54886 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54887 PyObject *resultobj = 0;
54888 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54889 void *argp1 = 0 ;
54890 int res1 = 0 ;
54891 PyObject *swig_obj[1] ;
54892
54893 if (!args) SWIG_fail;
54894 swig_obj[0] = args;
54895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
54896 if (!SWIG_IsOK(res1)) {
54897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54898 }
54899 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54900 {
54901 PyThreadState* __tstate = wxPyBeginAllowThreads();
54902 delete arg1;
54903
54904 wxPyEndAllowThreads(__tstate);
54905 if (PyErr_Occurred()) SWIG_fail;
54906 }
54907 resultobj = SWIG_Py_Void();
54908 return resultobj;
54909 fail:
54910 return NULL;
54911 }
54912
54913
54914 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54915 PyObject *resultobj = 0;
54916 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54917 int result;
54918 void *argp1 = 0 ;
54919 int res1 = 0 ;
54920 PyObject *swig_obj[1] ;
54921
54922 if (!args) SWIG_fail;
54923 swig_obj[0] = args;
54924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54925 if (!SWIG_IsOK(res1)) {
54926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
54927 }
54928 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54929 {
54930 PyThreadState* __tstate = wxPyBeginAllowThreads();
54931 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
54932 wxPyEndAllowThreads(__tstate);
54933 if (PyErr_Occurred()) SWIG_fail;
54934 }
54935 resultobj = SWIG_From_int(static_cast< int >(result));
54936 return resultobj;
54937 fail:
54938 return NULL;
54939 }
54940
54941
54942 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54943 PyObject *resultobj = 0;
54944 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54945 int result;
54946 void *argp1 = 0 ;
54947 int res1 = 0 ;
54948 PyObject *swig_obj[1] ;
54949
54950 if (!args) SWIG_fail;
54951 swig_obj[0] = args;
54952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54953 if (!SWIG_IsOK(res1)) {
54954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
54955 }
54956 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54957 {
54958 PyThreadState* __tstate = wxPyBeginAllowThreads();
54959 result = (int)((wxGBSpan const *)arg1)->GetColspan();
54960 wxPyEndAllowThreads(__tstate);
54961 if (PyErr_Occurred()) SWIG_fail;
54962 }
54963 resultobj = SWIG_From_int(static_cast< int >(result));
54964 return resultobj;
54965 fail:
54966 return NULL;
54967 }
54968
54969
54970 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54971 PyObject *resultobj = 0;
54972 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54973 int arg2 ;
54974 void *argp1 = 0 ;
54975 int res1 = 0 ;
54976 int val2 ;
54977 int ecode2 = 0 ;
54978 PyObject * obj0 = 0 ;
54979 PyObject * obj1 = 0 ;
54980 char * kwnames[] = {
54981 (char *) "self",(char *) "rowspan", NULL
54982 };
54983
54984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
54985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54986 if (!SWIG_IsOK(res1)) {
54987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54988 }
54989 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54990 ecode2 = SWIG_AsVal_int(obj1, &val2);
54991 if (!SWIG_IsOK(ecode2)) {
54992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
54993 }
54994 arg2 = static_cast< int >(val2);
54995 {
54996 PyThreadState* __tstate = wxPyBeginAllowThreads();
54997 (arg1)->SetRowspan(arg2);
54998 wxPyEndAllowThreads(__tstate);
54999 if (PyErr_Occurred()) SWIG_fail;
55000 }
55001 resultobj = SWIG_Py_Void();
55002 return resultobj;
55003 fail:
55004 return NULL;
55005 }
55006
55007
55008 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55009 PyObject *resultobj = 0;
55010 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
55011 int arg2 ;
55012 void *argp1 = 0 ;
55013 int res1 = 0 ;
55014 int val2 ;
55015 int ecode2 = 0 ;
55016 PyObject * obj0 = 0 ;
55017 PyObject * obj1 = 0 ;
55018 char * kwnames[] = {
55019 (char *) "self",(char *) "colspan", NULL
55020 };
55021
55022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
55023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
55024 if (!SWIG_IsOK(res1)) {
55025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
55026 }
55027 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
55028 ecode2 = SWIG_AsVal_int(obj1, &val2);
55029 if (!SWIG_IsOK(ecode2)) {
55030 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
55031 }
55032 arg2 = static_cast< int >(val2);
55033 {
55034 PyThreadState* __tstate = wxPyBeginAllowThreads();
55035 (arg1)->SetColspan(arg2);
55036 wxPyEndAllowThreads(__tstate);
55037 if (PyErr_Occurred()) SWIG_fail;
55038 }
55039 resultobj = SWIG_Py_Void();
55040 return resultobj;
55041 fail:
55042 return NULL;
55043 }
55044
55045
55046 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55047 PyObject *resultobj = 0;
55048 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
55049 PyObject *arg2 = (PyObject *) 0 ;
55050 bool result;
55051 void *argp1 = 0 ;
55052 int res1 = 0 ;
55053 PyObject * obj0 = 0 ;
55054 PyObject * obj1 = 0 ;
55055 char * kwnames[] = {
55056 (char *) "self",(char *) "other", NULL
55057 };
55058
55059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
55060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
55061 if (!SWIG_IsOK(res1)) {
55062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
55063 }
55064 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
55065 arg2 = obj1;
55066 {
55067 result = (bool)wxGBSpan___eq__(arg1,arg2);
55068 if (PyErr_Occurred()) SWIG_fail;
55069 }
55070 {
55071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55072 }
55073 return resultobj;
55074 fail:
55075 return NULL;
55076 }
55077
55078
55079 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55080 PyObject *resultobj = 0;
55081 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
55082 PyObject *arg2 = (PyObject *) 0 ;
55083 bool result;
55084 void *argp1 = 0 ;
55085 int res1 = 0 ;
55086 PyObject * obj0 = 0 ;
55087 PyObject * obj1 = 0 ;
55088 char * kwnames[] = {
55089 (char *) "self",(char *) "other", NULL
55090 };
55091
55092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
55093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
55094 if (!SWIG_IsOK(res1)) {
55095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
55096 }
55097 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
55098 arg2 = obj1;
55099 {
55100 result = (bool)wxGBSpan___ne__(arg1,arg2);
55101 if (PyErr_Occurred()) SWIG_fail;
55102 }
55103 {
55104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55105 }
55106 return resultobj;
55107 fail:
55108 return NULL;
55109 }
55110
55111
55112 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55113 PyObject *resultobj = 0;
55114 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
55115 int arg2 = (int) 1 ;
55116 int arg3 = (int) 1 ;
55117 void *argp1 = 0 ;
55118 int res1 = 0 ;
55119 int val2 ;
55120 int ecode2 = 0 ;
55121 int val3 ;
55122 int ecode3 = 0 ;
55123 PyObject * obj0 = 0 ;
55124 PyObject * obj1 = 0 ;
55125 PyObject * obj2 = 0 ;
55126 char * kwnames[] = {
55127 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
55128 };
55129
55130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) 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_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
55134 }
55135 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
55136 if (obj1) {
55137 ecode2 = SWIG_AsVal_int(obj1, &val2);
55138 if (!SWIG_IsOK(ecode2)) {
55139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
55140 }
55141 arg2 = static_cast< int >(val2);
55142 }
55143 if (obj2) {
55144 ecode3 = SWIG_AsVal_int(obj2, &val3);
55145 if (!SWIG_IsOK(ecode3)) {
55146 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
55147 }
55148 arg3 = static_cast< int >(val3);
55149 }
55150 {
55151 PyThreadState* __tstate = wxPyBeginAllowThreads();
55152 wxGBSpan_Set(arg1,arg2,arg3);
55153 wxPyEndAllowThreads(__tstate);
55154 if (PyErr_Occurred()) SWIG_fail;
55155 }
55156 resultobj = SWIG_Py_Void();
55157 return resultobj;
55158 fail:
55159 return NULL;
55160 }
55161
55162
55163 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55164 PyObject *resultobj = 0;
55165 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
55166 PyObject *result = 0 ;
55167 void *argp1 = 0 ;
55168 int res1 = 0 ;
55169 PyObject *swig_obj[1] ;
55170
55171 if (!args) SWIG_fail;
55172 swig_obj[0] = args;
55173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
55174 if (!SWIG_IsOK(res1)) {
55175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
55176 }
55177 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
55178 {
55179 PyThreadState* __tstate = wxPyBeginAllowThreads();
55180 result = (PyObject *)wxGBSpan_Get(arg1);
55181 wxPyEndAllowThreads(__tstate);
55182 if (PyErr_Occurred()) SWIG_fail;
55183 }
55184 resultobj = result;
55185 return resultobj;
55186 fail:
55187 return NULL;
55188 }
55189
55190
55191 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55192 PyObject *obj;
55193 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
55194 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
55195 return SWIG_Py_Void();
55196 }
55197
55198 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55199 return SWIG_Python_InitShadowInstance(args);
55200 }
55201
55202 SWIGINTERN int DefaultSpan_set(PyObject *) {
55203 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
55204 return 1;
55205 }
55206
55207
55208 SWIGINTERN PyObject *DefaultSpan_get(void) {
55209 PyObject *pyobj = 0;
55210
55211 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
55212 return pyobj;
55213 }
55214
55215
55216 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55217 PyObject *resultobj = 0;
55218 wxGBSizerItem *result = 0 ;
55219
55220 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
55221 {
55222 PyThreadState* __tstate = wxPyBeginAllowThreads();
55223 result = (wxGBSizerItem *)new wxGBSizerItem();
55224 wxPyEndAllowThreads(__tstate);
55225 if (PyErr_Occurred()) SWIG_fail;
55226 }
55227 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
55228 return resultobj;
55229 fail:
55230 return NULL;
55231 }
55232
55233
55234 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55235 PyObject *resultobj = 0;
55236 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55237 void *argp1 = 0 ;
55238 int res1 = 0 ;
55239 PyObject *swig_obj[1] ;
55240
55241 if (!args) SWIG_fail;
55242 swig_obj[0] = args;
55243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
55244 if (!SWIG_IsOK(res1)) {
55245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55246 }
55247 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55248 {
55249 PyThreadState* __tstate = wxPyBeginAllowThreads();
55250 delete arg1;
55251
55252 wxPyEndAllowThreads(__tstate);
55253 if (PyErr_Occurred()) SWIG_fail;
55254 }
55255 resultobj = SWIG_Py_Void();
55256 return resultobj;
55257 fail:
55258 return NULL;
55259 }
55260
55261
55262 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55263 PyObject *resultobj = 0;
55264 wxWindow *arg1 = (wxWindow *) 0 ;
55265 wxGBPosition *arg2 = 0 ;
55266 wxGBSpan *arg3 = 0 ;
55267 int arg4 ;
55268 int arg5 ;
55269 PyObject *arg6 = (PyObject *) NULL ;
55270 wxGBSizerItem *result = 0 ;
55271 void *argp1 = 0 ;
55272 int res1 = 0 ;
55273 wxGBPosition temp2 ;
55274 wxGBSpan temp3 ;
55275 int val4 ;
55276 int ecode4 = 0 ;
55277 int val5 ;
55278 int ecode5 = 0 ;
55279 PyObject * obj0 = 0 ;
55280 PyObject * obj1 = 0 ;
55281 PyObject * obj2 = 0 ;
55282 PyObject * obj3 = 0 ;
55283 PyObject * obj4 = 0 ;
55284 PyObject * obj5 = 0 ;
55285 char * kwnames[] = {
55286 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
55287 };
55288
55289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
55290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
55291 if (!SWIG_IsOK(res1)) {
55292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
55293 }
55294 arg1 = reinterpret_cast< wxWindow * >(argp1);
55295 {
55296 arg2 = &temp2;
55297 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55298 }
55299 {
55300 arg3 = &temp3;
55301 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
55302 }
55303 ecode4 = SWIG_AsVal_int(obj3, &val4);
55304 if (!SWIG_IsOK(ecode4)) {
55305 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
55306 }
55307 arg4 = static_cast< int >(val4);
55308 ecode5 = SWIG_AsVal_int(obj4, &val5);
55309 if (!SWIG_IsOK(ecode5)) {
55310 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
55311 }
55312 arg5 = static_cast< int >(val5);
55313 if (obj5) {
55314 arg6 = obj5;
55315 }
55316 {
55317 PyThreadState* __tstate = wxPyBeginAllowThreads();
55318 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
55319 wxPyEndAllowThreads(__tstate);
55320 if (PyErr_Occurred()) SWIG_fail;
55321 }
55322 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
55323 return resultobj;
55324 fail:
55325 return NULL;
55326 }
55327
55328
55329 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55330 PyObject *resultobj = 0;
55331 wxSizer *arg1 = (wxSizer *) 0 ;
55332 wxGBPosition *arg2 = 0 ;
55333 wxGBSpan *arg3 = 0 ;
55334 int arg4 ;
55335 int arg5 ;
55336 PyObject *arg6 = (PyObject *) NULL ;
55337 wxGBSizerItem *result = 0 ;
55338 int res1 = 0 ;
55339 wxGBPosition temp2 ;
55340 wxGBSpan temp3 ;
55341 int val4 ;
55342 int ecode4 = 0 ;
55343 int val5 ;
55344 int ecode5 = 0 ;
55345 PyObject * obj0 = 0 ;
55346 PyObject * obj1 = 0 ;
55347 PyObject * obj2 = 0 ;
55348 PyObject * obj3 = 0 ;
55349 PyObject * obj4 = 0 ;
55350 PyObject * obj5 = 0 ;
55351 char * kwnames[] = {
55352 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
55353 };
55354
55355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
55356 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
55357 if (!SWIG_IsOK(res1)) {
55358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
55359 }
55360 {
55361 arg2 = &temp2;
55362 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55363 }
55364 {
55365 arg3 = &temp3;
55366 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
55367 }
55368 ecode4 = SWIG_AsVal_int(obj3, &val4);
55369 if (!SWIG_IsOK(ecode4)) {
55370 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
55371 }
55372 arg4 = static_cast< int >(val4);
55373 ecode5 = SWIG_AsVal_int(obj4, &val5);
55374 if (!SWIG_IsOK(ecode5)) {
55375 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
55376 }
55377 arg5 = static_cast< int >(val5);
55378 if (obj5) {
55379 arg6 = obj5;
55380 }
55381 {
55382 PyThreadState* __tstate = wxPyBeginAllowThreads();
55383 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
55384 wxPyEndAllowThreads(__tstate);
55385 if (PyErr_Occurred()) SWIG_fail;
55386 }
55387 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
55388 return resultobj;
55389 fail:
55390 return NULL;
55391 }
55392
55393
55394 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55395 PyObject *resultobj = 0;
55396 int arg1 ;
55397 int arg2 ;
55398 wxGBPosition *arg3 = 0 ;
55399 wxGBSpan *arg4 = 0 ;
55400 int arg5 ;
55401 int arg6 ;
55402 PyObject *arg7 = (PyObject *) NULL ;
55403 wxGBSizerItem *result = 0 ;
55404 int val1 ;
55405 int ecode1 = 0 ;
55406 int val2 ;
55407 int ecode2 = 0 ;
55408 wxGBPosition temp3 ;
55409 wxGBSpan temp4 ;
55410 int val5 ;
55411 int ecode5 = 0 ;
55412 int val6 ;
55413 int ecode6 = 0 ;
55414 PyObject * obj0 = 0 ;
55415 PyObject * obj1 = 0 ;
55416 PyObject * obj2 = 0 ;
55417 PyObject * obj3 = 0 ;
55418 PyObject * obj4 = 0 ;
55419 PyObject * obj5 = 0 ;
55420 PyObject * obj6 = 0 ;
55421 char * kwnames[] = {
55422 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
55423 };
55424
55425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
55426 ecode1 = SWIG_AsVal_int(obj0, &val1);
55427 if (!SWIG_IsOK(ecode1)) {
55428 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
55429 }
55430 arg1 = static_cast< int >(val1);
55431 ecode2 = SWIG_AsVal_int(obj1, &val2);
55432 if (!SWIG_IsOK(ecode2)) {
55433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
55434 }
55435 arg2 = static_cast< int >(val2);
55436 {
55437 arg3 = &temp3;
55438 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
55439 }
55440 {
55441 arg4 = &temp4;
55442 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
55443 }
55444 ecode5 = SWIG_AsVal_int(obj4, &val5);
55445 if (!SWIG_IsOK(ecode5)) {
55446 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
55447 }
55448 arg5 = static_cast< int >(val5);
55449 ecode6 = SWIG_AsVal_int(obj5, &val6);
55450 if (!SWIG_IsOK(ecode6)) {
55451 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
55452 }
55453 arg6 = static_cast< int >(val6);
55454 if (obj6) {
55455 arg7 = obj6;
55456 }
55457 {
55458 PyThreadState* __tstate = wxPyBeginAllowThreads();
55459 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
55460 wxPyEndAllowThreads(__tstate);
55461 if (PyErr_Occurred()) SWIG_fail;
55462 }
55463 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
55464 return resultobj;
55465 fail:
55466 return NULL;
55467 }
55468
55469
55470 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55471 PyObject *resultobj = 0;
55472 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55473 wxGBPosition result;
55474 void *argp1 = 0 ;
55475 int res1 = 0 ;
55476 PyObject *swig_obj[1] ;
55477
55478 if (!args) SWIG_fail;
55479 swig_obj[0] = args;
55480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55481 if (!SWIG_IsOK(res1)) {
55482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
55483 }
55484 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55485 {
55486 PyThreadState* __tstate = wxPyBeginAllowThreads();
55487 result = ((wxGBSizerItem const *)arg1)->GetPos();
55488 wxPyEndAllowThreads(__tstate);
55489 if (PyErr_Occurred()) SWIG_fail;
55490 }
55491 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
55492 return resultobj;
55493 fail:
55494 return NULL;
55495 }
55496
55497
55498 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55499 PyObject *resultobj = 0;
55500 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55501 wxGBSpan result;
55502 void *argp1 = 0 ;
55503 int res1 = 0 ;
55504 PyObject *swig_obj[1] ;
55505
55506 if (!args) SWIG_fail;
55507 swig_obj[0] = args;
55508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55509 if (!SWIG_IsOK(res1)) {
55510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
55511 }
55512 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55513 {
55514 PyThreadState* __tstate = wxPyBeginAllowThreads();
55515 result = ((wxGBSizerItem const *)arg1)->GetSpan();
55516 wxPyEndAllowThreads(__tstate);
55517 if (PyErr_Occurred()) SWIG_fail;
55518 }
55519 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
55520 return resultobj;
55521 fail:
55522 return NULL;
55523 }
55524
55525
55526 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55527 PyObject *resultobj = 0;
55528 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55529 wxGBPosition *arg2 = 0 ;
55530 bool result;
55531 void *argp1 = 0 ;
55532 int res1 = 0 ;
55533 wxGBPosition temp2 ;
55534 PyObject * obj0 = 0 ;
55535 PyObject * obj1 = 0 ;
55536 char * kwnames[] = {
55537 (char *) "self",(char *) "pos", NULL
55538 };
55539
55540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
55541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55542 if (!SWIG_IsOK(res1)) {
55543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55544 }
55545 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55546 {
55547 arg2 = &temp2;
55548 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55549 }
55550 {
55551 PyThreadState* __tstate = wxPyBeginAllowThreads();
55552 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
55553 wxPyEndAllowThreads(__tstate);
55554 if (PyErr_Occurred()) SWIG_fail;
55555 }
55556 {
55557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55558 }
55559 return resultobj;
55560 fail:
55561 return NULL;
55562 }
55563
55564
55565 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55566 PyObject *resultobj = 0;
55567 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55568 wxGBSpan *arg2 = 0 ;
55569 bool result;
55570 void *argp1 = 0 ;
55571 int res1 = 0 ;
55572 wxGBSpan temp2 ;
55573 PyObject * obj0 = 0 ;
55574 PyObject * obj1 = 0 ;
55575 char * kwnames[] = {
55576 (char *) "self",(char *) "span", NULL
55577 };
55578
55579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
55580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55581 if (!SWIG_IsOK(res1)) {
55582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55583 }
55584 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55585 {
55586 arg2 = &temp2;
55587 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
55588 }
55589 {
55590 PyThreadState* __tstate = wxPyBeginAllowThreads();
55591 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
55592 wxPyEndAllowThreads(__tstate);
55593 if (PyErr_Occurred()) SWIG_fail;
55594 }
55595 {
55596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55597 }
55598 return resultobj;
55599 fail:
55600 return NULL;
55601 }
55602
55603
55604 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55605 PyObject *resultobj = 0;
55606 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55607 wxGBSizerItem *arg2 = 0 ;
55608 bool result;
55609 void *argp1 = 0 ;
55610 int res1 = 0 ;
55611 void *argp2 = 0 ;
55612 int res2 = 0 ;
55613 PyObject * obj0 = 0 ;
55614 PyObject * obj1 = 0 ;
55615 char * kwnames[] = {
55616 (char *) "self",(char *) "other", NULL
55617 };
55618
55619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
55620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55621 if (!SWIG_IsOK(res1)) {
55622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55623 }
55624 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55625 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
55626 if (!SWIG_IsOK(res2)) {
55627 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
55628 }
55629 if (!argp2) {
55630 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
55631 }
55632 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
55633 {
55634 PyThreadState* __tstate = wxPyBeginAllowThreads();
55635 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
55636 wxPyEndAllowThreads(__tstate);
55637 if (PyErr_Occurred()) SWIG_fail;
55638 }
55639 {
55640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55641 }
55642 return resultobj;
55643 fail:
55644 return NULL;
55645 }
55646
55647
55648 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55649 PyObject *resultobj = 0;
55650 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55651 wxGBPosition *arg2 = 0 ;
55652 wxGBSpan *arg3 = 0 ;
55653 bool result;
55654 void *argp1 = 0 ;
55655 int res1 = 0 ;
55656 wxGBPosition temp2 ;
55657 wxGBSpan temp3 ;
55658 PyObject * obj0 = 0 ;
55659 PyObject * obj1 = 0 ;
55660 PyObject * obj2 = 0 ;
55661 char * kwnames[] = {
55662 (char *) "self",(char *) "pos",(char *) "span", NULL
55663 };
55664
55665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55667 if (!SWIG_IsOK(res1)) {
55668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55669 }
55670 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55671 {
55672 arg2 = &temp2;
55673 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55674 }
55675 {
55676 arg3 = &temp3;
55677 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
55678 }
55679 {
55680 PyThreadState* __tstate = wxPyBeginAllowThreads();
55681 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
55682 wxPyEndAllowThreads(__tstate);
55683 if (PyErr_Occurred()) SWIG_fail;
55684 }
55685 {
55686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55687 }
55688 return resultobj;
55689 fail:
55690 return NULL;
55691 }
55692
55693
55694 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55695 PyObject *resultobj = 0;
55696 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55697 wxGBPosition result;
55698 void *argp1 = 0 ;
55699 int res1 = 0 ;
55700 PyObject *swig_obj[1] ;
55701
55702 if (!args) SWIG_fail;
55703 swig_obj[0] = args;
55704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55705 if (!SWIG_IsOK(res1)) {
55706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55707 }
55708 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55709 {
55710 PyThreadState* __tstate = wxPyBeginAllowThreads();
55711 result = wxGBSizerItem_GetEndPos(arg1);
55712 wxPyEndAllowThreads(__tstate);
55713 if (PyErr_Occurred()) SWIG_fail;
55714 }
55715 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
55716 return resultobj;
55717 fail:
55718 return NULL;
55719 }
55720
55721
55722 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55723 PyObject *resultobj = 0;
55724 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55725 wxGridBagSizer *result = 0 ;
55726 void *argp1 = 0 ;
55727 int res1 = 0 ;
55728 PyObject *swig_obj[1] ;
55729
55730 if (!args) SWIG_fail;
55731 swig_obj[0] = args;
55732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55733 if (!SWIG_IsOK(res1)) {
55734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
55735 }
55736 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55737 {
55738 PyThreadState* __tstate = wxPyBeginAllowThreads();
55739 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
55740 wxPyEndAllowThreads(__tstate);
55741 if (PyErr_Occurred()) SWIG_fail;
55742 }
55743 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55744 return resultobj;
55745 fail:
55746 return NULL;
55747 }
55748
55749
55750 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55751 PyObject *resultobj = 0;
55752 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55753 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
55754 void *argp1 = 0 ;
55755 int res1 = 0 ;
55756 void *argp2 = 0 ;
55757 int res2 = 0 ;
55758 PyObject * obj0 = 0 ;
55759 PyObject * obj1 = 0 ;
55760 char * kwnames[] = {
55761 (char *) "self",(char *) "sizer", NULL
55762 };
55763
55764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
55765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55766 if (!SWIG_IsOK(res1)) {
55767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55768 }
55769 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55770 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55771 if (!SWIG_IsOK(res2)) {
55772 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
55773 }
55774 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
55775 {
55776 PyThreadState* __tstate = wxPyBeginAllowThreads();
55777 (arg1)->SetGBSizer(arg2);
55778 wxPyEndAllowThreads(__tstate);
55779 if (PyErr_Occurred()) SWIG_fail;
55780 }
55781 resultobj = SWIG_Py_Void();
55782 return resultobj;
55783 fail:
55784 return NULL;
55785 }
55786
55787
55788 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55789 PyObject *obj;
55790 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
55791 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
55792 return SWIG_Py_Void();
55793 }
55794
55795 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55796 return SWIG_Python_InitShadowInstance(args);
55797 }
55798
55799 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55800 PyObject *resultobj = 0;
55801 int arg1 = (int) 0 ;
55802 int arg2 = (int) 0 ;
55803 wxGridBagSizer *result = 0 ;
55804 int val1 ;
55805 int ecode1 = 0 ;
55806 int val2 ;
55807 int ecode2 = 0 ;
55808 PyObject * obj0 = 0 ;
55809 PyObject * obj1 = 0 ;
55810 char * kwnames[] = {
55811 (char *) "vgap",(char *) "hgap", NULL
55812 };
55813
55814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
55815 if (obj0) {
55816 ecode1 = SWIG_AsVal_int(obj0, &val1);
55817 if (!SWIG_IsOK(ecode1)) {
55818 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
55819 }
55820 arg1 = static_cast< int >(val1);
55821 }
55822 if (obj1) {
55823 ecode2 = SWIG_AsVal_int(obj1, &val2);
55824 if (!SWIG_IsOK(ecode2)) {
55825 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
55826 }
55827 arg2 = static_cast< int >(val2);
55828 }
55829 {
55830 PyThreadState* __tstate = wxPyBeginAllowThreads();
55831 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
55832 wxPyEndAllowThreads(__tstate);
55833 if (PyErr_Occurred()) SWIG_fail;
55834 }
55835 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
55836 return resultobj;
55837 fail:
55838 return NULL;
55839 }
55840
55841
55842 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55843 PyObject *resultobj = 0;
55844 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55845 PyObject *arg2 = (PyObject *) 0 ;
55846 wxGBPosition *arg3 = 0 ;
55847 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
55848 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
55849 int arg5 = (int) 0 ;
55850 int arg6 = (int) 0 ;
55851 PyObject *arg7 = (PyObject *) NULL ;
55852 wxGBSizerItem *result = 0 ;
55853 void *argp1 = 0 ;
55854 int res1 = 0 ;
55855 wxGBPosition temp3 ;
55856 wxGBSpan temp4 ;
55857 int val5 ;
55858 int ecode5 = 0 ;
55859 int val6 ;
55860 int ecode6 = 0 ;
55861 PyObject * obj0 = 0 ;
55862 PyObject * obj1 = 0 ;
55863 PyObject * obj2 = 0 ;
55864 PyObject * obj3 = 0 ;
55865 PyObject * obj4 = 0 ;
55866 PyObject * obj5 = 0 ;
55867 PyObject * obj6 = 0 ;
55868 char * kwnames[] = {
55869 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
55870 };
55871
55872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
55873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55874 if (!SWIG_IsOK(res1)) {
55875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55876 }
55877 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55878 arg2 = obj1;
55879 {
55880 arg3 = &temp3;
55881 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
55882 }
55883 if (obj3) {
55884 {
55885 arg4 = &temp4;
55886 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
55887 }
55888 }
55889 if (obj4) {
55890 ecode5 = SWIG_AsVal_int(obj4, &val5);
55891 if (!SWIG_IsOK(ecode5)) {
55892 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
55893 }
55894 arg5 = static_cast< int >(val5);
55895 }
55896 if (obj5) {
55897 ecode6 = SWIG_AsVal_int(obj5, &val6);
55898 if (!SWIG_IsOK(ecode6)) {
55899 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
55900 }
55901 arg6 = static_cast< int >(val6);
55902 }
55903 if (obj6) {
55904 arg7 = obj6;
55905 }
55906 {
55907 PyThreadState* __tstate = wxPyBeginAllowThreads();
55908 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
55909 wxPyEndAllowThreads(__tstate);
55910 if (PyErr_Occurred()) SWIG_fail;
55911 }
55912 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55913 return resultobj;
55914 fail:
55915 return NULL;
55916 }
55917
55918
55919 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55920 PyObject *resultobj = 0;
55921 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55922 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
55923 wxGBSizerItem *result = 0 ;
55924 void *argp1 = 0 ;
55925 int res1 = 0 ;
55926 int res2 = 0 ;
55927 PyObject * obj0 = 0 ;
55928 PyObject * obj1 = 0 ;
55929 char * kwnames[] = {
55930 (char *) "self",(char *) "item", NULL
55931 };
55932
55933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
55934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55935 if (!SWIG_IsOK(res1)) {
55936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55937 }
55938 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55939 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
55940 if (!SWIG_IsOK(res2)) {
55941 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
55942 }
55943 {
55944 PyThreadState* __tstate = wxPyBeginAllowThreads();
55945 result = (wxGBSizerItem *)(arg1)->Add(arg2);
55946 wxPyEndAllowThreads(__tstate);
55947 if (PyErr_Occurred()) SWIG_fail;
55948 }
55949 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55950 return resultobj;
55951 fail:
55952 return NULL;
55953 }
55954
55955
55956 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55957 PyObject *resultobj = 0;
55958 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55959 int arg2 ;
55960 int arg3 ;
55961 wxSize result;
55962 void *argp1 = 0 ;
55963 int res1 = 0 ;
55964 int val2 ;
55965 int ecode2 = 0 ;
55966 int val3 ;
55967 int ecode3 = 0 ;
55968 PyObject * obj0 = 0 ;
55969 PyObject * obj1 = 0 ;
55970 PyObject * obj2 = 0 ;
55971 char * kwnames[] = {
55972 (char *) "self",(char *) "row",(char *) "col", NULL
55973 };
55974
55975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55977 if (!SWIG_IsOK(res1)) {
55978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
55979 }
55980 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55981 ecode2 = SWIG_AsVal_int(obj1, &val2);
55982 if (!SWIG_IsOK(ecode2)) {
55983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
55984 }
55985 arg2 = static_cast< int >(val2);
55986 ecode3 = SWIG_AsVal_int(obj2, &val3);
55987 if (!SWIG_IsOK(ecode3)) {
55988 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
55989 }
55990 arg3 = static_cast< int >(val3);
55991 {
55992 PyThreadState* __tstate = wxPyBeginAllowThreads();
55993 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
55994 wxPyEndAllowThreads(__tstate);
55995 if (PyErr_Occurred()) SWIG_fail;
55996 }
55997 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
55998 return resultobj;
55999 fail:
56000 return NULL;
56001 }
56002
56003
56004 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56005 PyObject *resultobj = 0;
56006 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56007 wxSize result;
56008 void *argp1 = 0 ;
56009 int res1 = 0 ;
56010 PyObject *swig_obj[1] ;
56011
56012 if (!args) SWIG_fail;
56013 swig_obj[0] = args;
56014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56015 if (!SWIG_IsOK(res1)) {
56016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
56017 }
56018 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56019 {
56020 PyThreadState* __tstate = wxPyBeginAllowThreads();
56021 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
56022 wxPyEndAllowThreads(__tstate);
56023 if (PyErr_Occurred()) SWIG_fail;
56024 }
56025 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
56026 return resultobj;
56027 fail:
56028 return NULL;
56029 }
56030
56031
56032 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56033 PyObject *resultobj = 0;
56034 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56035 wxSize *arg2 = 0 ;
56036 void *argp1 = 0 ;
56037 int res1 = 0 ;
56038 wxSize temp2 ;
56039 PyObject * obj0 = 0 ;
56040 PyObject * obj1 = 0 ;
56041 char * kwnames[] = {
56042 (char *) "self",(char *) "sz", NULL
56043 };
56044
56045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
56046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56047 if (!SWIG_IsOK(res1)) {
56048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56049 }
56050 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56051 {
56052 arg2 = &temp2;
56053 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
56054 }
56055 {
56056 PyThreadState* __tstate = wxPyBeginAllowThreads();
56057 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
56058 wxPyEndAllowThreads(__tstate);
56059 if (PyErr_Occurred()) SWIG_fail;
56060 }
56061 resultobj = SWIG_Py_Void();
56062 return resultobj;
56063 fail:
56064 return NULL;
56065 }
56066
56067
56068 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56069 PyObject *resultobj = 0;
56070 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56071 wxWindow *arg2 = (wxWindow *) 0 ;
56072 wxGBPosition result;
56073 void *argp1 = 0 ;
56074 int res1 = 0 ;
56075 void *argp2 = 0 ;
56076 int res2 = 0 ;
56077
56078 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56080 if (!SWIG_IsOK(res1)) {
56081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56082 }
56083 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56084 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56085 if (!SWIG_IsOK(res2)) {
56086 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
56087 }
56088 arg2 = reinterpret_cast< wxWindow * >(argp2);
56089 {
56090 PyThreadState* __tstate = wxPyBeginAllowThreads();
56091 result = (arg1)->GetItemPosition(arg2);
56092 wxPyEndAllowThreads(__tstate);
56093 if (PyErr_Occurred()) SWIG_fail;
56094 }
56095 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
56096 return resultobj;
56097 fail:
56098 return NULL;
56099 }
56100
56101
56102 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56103 PyObject *resultobj = 0;
56104 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56105 wxSizer *arg2 = (wxSizer *) 0 ;
56106 wxGBPosition result;
56107 void *argp1 = 0 ;
56108 int res1 = 0 ;
56109 void *argp2 = 0 ;
56110 int res2 = 0 ;
56111
56112 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56114 if (!SWIG_IsOK(res1)) {
56115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56116 }
56117 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56118 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
56119 if (!SWIG_IsOK(res2)) {
56120 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
56121 }
56122 arg2 = reinterpret_cast< wxSizer * >(argp2);
56123 {
56124 PyThreadState* __tstate = wxPyBeginAllowThreads();
56125 result = (arg1)->GetItemPosition(arg2);
56126 wxPyEndAllowThreads(__tstate);
56127 if (PyErr_Occurred()) SWIG_fail;
56128 }
56129 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
56130 return resultobj;
56131 fail:
56132 return NULL;
56133 }
56134
56135
56136 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56137 PyObject *resultobj = 0;
56138 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56139 size_t arg2 ;
56140 wxGBPosition result;
56141 void *argp1 = 0 ;
56142 int res1 = 0 ;
56143 size_t val2 ;
56144 int ecode2 = 0 ;
56145
56146 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56148 if (!SWIG_IsOK(res1)) {
56149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56150 }
56151 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56152 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
56153 if (!SWIG_IsOK(ecode2)) {
56154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
56155 }
56156 arg2 = static_cast< size_t >(val2);
56157 {
56158 PyThreadState* __tstate = wxPyBeginAllowThreads();
56159 result = (arg1)->GetItemPosition(arg2);
56160 wxPyEndAllowThreads(__tstate);
56161 if (PyErr_Occurred()) SWIG_fail;
56162 }
56163 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
56164 return resultobj;
56165 fail:
56166 return NULL;
56167 }
56168
56169
56170 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
56171 int argc;
56172 PyObject *argv[3];
56173
56174 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
56175 --argc;
56176 if (argc == 2) {
56177 int _v = 0;
56178 {
56179 void *vptr = 0;
56180 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
56181 _v = SWIG_CheckState(res);
56182 }
56183 if (!_v) goto check_1;
56184 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
56185 }
56186 check_1:
56187
56188 if (argc == 2) {
56189 int _v = 0;
56190 {
56191 void *vptr = 0;
56192 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
56193 _v = SWIG_CheckState(res);
56194 }
56195 if (!_v) goto check_2;
56196 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
56197 }
56198 check_2:
56199
56200 if (argc == 2) {
56201 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
56202 }
56203
56204 fail:
56205 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
56206 return NULL;
56207 }
56208
56209
56210 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56211 PyObject *resultobj = 0;
56212 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56213 wxWindow *arg2 = (wxWindow *) 0 ;
56214 wxGBPosition *arg3 = 0 ;
56215 bool result;
56216 void *argp1 = 0 ;
56217 int res1 = 0 ;
56218 void *argp2 = 0 ;
56219 int res2 = 0 ;
56220 wxGBPosition temp3 ;
56221
56222 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56224 if (!SWIG_IsOK(res1)) {
56225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56226 }
56227 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56228 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56229 if (!SWIG_IsOK(res2)) {
56230 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
56231 }
56232 arg2 = reinterpret_cast< wxWindow * >(argp2);
56233 {
56234 arg3 = &temp3;
56235 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
56236 }
56237 {
56238 PyThreadState* __tstate = wxPyBeginAllowThreads();
56239 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
56240 wxPyEndAllowThreads(__tstate);
56241 if (PyErr_Occurred()) SWIG_fail;
56242 }
56243 {
56244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56245 }
56246 return resultobj;
56247 fail:
56248 return NULL;
56249 }
56250
56251
56252 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56253 PyObject *resultobj = 0;
56254 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56255 wxSizer *arg2 = (wxSizer *) 0 ;
56256 wxGBPosition *arg3 = 0 ;
56257 bool result;
56258 void *argp1 = 0 ;
56259 int res1 = 0 ;
56260 void *argp2 = 0 ;
56261 int res2 = 0 ;
56262 wxGBPosition temp3 ;
56263
56264 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56266 if (!SWIG_IsOK(res1)) {
56267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56268 }
56269 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56270 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
56271 if (!SWIG_IsOK(res2)) {
56272 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
56273 }
56274 arg2 = reinterpret_cast< wxSizer * >(argp2);
56275 {
56276 arg3 = &temp3;
56277 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
56278 }
56279 {
56280 PyThreadState* __tstate = wxPyBeginAllowThreads();
56281 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
56282 wxPyEndAllowThreads(__tstate);
56283 if (PyErr_Occurred()) SWIG_fail;
56284 }
56285 {
56286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56287 }
56288 return resultobj;
56289 fail:
56290 return NULL;
56291 }
56292
56293
56294 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56295 PyObject *resultobj = 0;
56296 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56297 size_t arg2 ;
56298 wxGBPosition *arg3 = 0 ;
56299 bool result;
56300 void *argp1 = 0 ;
56301 int res1 = 0 ;
56302 size_t val2 ;
56303 int ecode2 = 0 ;
56304 wxGBPosition temp3 ;
56305
56306 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56308 if (!SWIG_IsOK(res1)) {
56309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56310 }
56311 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56312 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
56313 if (!SWIG_IsOK(ecode2)) {
56314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
56315 }
56316 arg2 = static_cast< size_t >(val2);
56317 {
56318 arg3 = &temp3;
56319 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
56320 }
56321 {
56322 PyThreadState* __tstate = wxPyBeginAllowThreads();
56323 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
56324 wxPyEndAllowThreads(__tstate);
56325 if (PyErr_Occurred()) SWIG_fail;
56326 }
56327 {
56328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56329 }
56330 return resultobj;
56331 fail:
56332 return NULL;
56333 }
56334
56335
56336 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
56337 int argc;
56338 PyObject *argv[4];
56339
56340 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
56341 --argc;
56342 if (argc == 3) {
56343 int _v = 0;
56344 {
56345 void *vptr = 0;
56346 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
56347 _v = SWIG_CheckState(res);
56348 }
56349 if (!_v) goto check_1;
56350 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
56351 }
56352 check_1:
56353
56354 if (argc == 3) {
56355 int _v = 0;
56356 {
56357 void *vptr = 0;
56358 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
56359 _v = SWIG_CheckState(res);
56360 }
56361 if (!_v) goto check_2;
56362 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
56363 }
56364 check_2:
56365
56366 if (argc == 3) {
56367 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
56368 }
56369
56370 fail:
56371 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
56372 return NULL;
56373 }
56374
56375
56376 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56377 PyObject *resultobj = 0;
56378 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56379 wxWindow *arg2 = (wxWindow *) 0 ;
56380 wxGBSpan result;
56381 void *argp1 = 0 ;
56382 int res1 = 0 ;
56383 void *argp2 = 0 ;
56384 int res2 = 0 ;
56385
56386 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56388 if (!SWIG_IsOK(res1)) {
56389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56390 }
56391 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56392 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56393 if (!SWIG_IsOK(res2)) {
56394 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
56395 }
56396 arg2 = reinterpret_cast< wxWindow * >(argp2);
56397 {
56398 PyThreadState* __tstate = wxPyBeginAllowThreads();
56399 result = (arg1)->GetItemSpan(arg2);
56400 wxPyEndAllowThreads(__tstate);
56401 if (PyErr_Occurred()) SWIG_fail;
56402 }
56403 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
56404 return resultobj;
56405 fail:
56406 return NULL;
56407 }
56408
56409
56410 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56411 PyObject *resultobj = 0;
56412 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56413 wxSizer *arg2 = (wxSizer *) 0 ;
56414 wxGBSpan result;
56415 void *argp1 = 0 ;
56416 int res1 = 0 ;
56417 void *argp2 = 0 ;
56418 int res2 = 0 ;
56419
56420 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56422 if (!SWIG_IsOK(res1)) {
56423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56424 }
56425 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56426 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
56427 if (!SWIG_IsOK(res2)) {
56428 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
56429 }
56430 arg2 = reinterpret_cast< wxSizer * >(argp2);
56431 {
56432 PyThreadState* __tstate = wxPyBeginAllowThreads();
56433 result = (arg1)->GetItemSpan(arg2);
56434 wxPyEndAllowThreads(__tstate);
56435 if (PyErr_Occurred()) SWIG_fail;
56436 }
56437 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
56438 return resultobj;
56439 fail:
56440 return NULL;
56441 }
56442
56443
56444 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56445 PyObject *resultobj = 0;
56446 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56447 size_t arg2 ;
56448 wxGBSpan result;
56449 void *argp1 = 0 ;
56450 int res1 = 0 ;
56451 size_t val2 ;
56452 int ecode2 = 0 ;
56453
56454 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56456 if (!SWIG_IsOK(res1)) {
56457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56458 }
56459 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56460 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
56461 if (!SWIG_IsOK(ecode2)) {
56462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
56463 }
56464 arg2 = static_cast< size_t >(val2);
56465 {
56466 PyThreadState* __tstate = wxPyBeginAllowThreads();
56467 result = (arg1)->GetItemSpan(arg2);
56468 wxPyEndAllowThreads(__tstate);
56469 if (PyErr_Occurred()) SWIG_fail;
56470 }
56471 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
56472 return resultobj;
56473 fail:
56474 return NULL;
56475 }
56476
56477
56478 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
56479 int argc;
56480 PyObject *argv[3];
56481
56482 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
56483 --argc;
56484 if (argc == 2) {
56485 int _v = 0;
56486 {
56487 void *vptr = 0;
56488 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
56489 _v = SWIG_CheckState(res);
56490 }
56491 if (!_v) goto check_1;
56492 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
56493 }
56494 check_1:
56495
56496 if (argc == 2) {
56497 int _v = 0;
56498 {
56499 void *vptr = 0;
56500 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
56501 _v = SWIG_CheckState(res);
56502 }
56503 if (!_v) goto check_2;
56504 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
56505 }
56506 check_2:
56507
56508 if (argc == 2) {
56509 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
56510 }
56511
56512 fail:
56513 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
56514 return NULL;
56515 }
56516
56517
56518 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56519 PyObject *resultobj = 0;
56520 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56521 wxWindow *arg2 = (wxWindow *) 0 ;
56522 wxGBSpan *arg3 = 0 ;
56523 bool result;
56524 void *argp1 = 0 ;
56525 int res1 = 0 ;
56526 void *argp2 = 0 ;
56527 int res2 = 0 ;
56528 wxGBSpan temp3 ;
56529
56530 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56532 if (!SWIG_IsOK(res1)) {
56533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56534 }
56535 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56536 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56537 if (!SWIG_IsOK(res2)) {
56538 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
56539 }
56540 arg2 = reinterpret_cast< wxWindow * >(argp2);
56541 {
56542 arg3 = &temp3;
56543 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
56544 }
56545 {
56546 PyThreadState* __tstate = wxPyBeginAllowThreads();
56547 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
56548 wxPyEndAllowThreads(__tstate);
56549 if (PyErr_Occurred()) SWIG_fail;
56550 }
56551 {
56552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56553 }
56554 return resultobj;
56555 fail:
56556 return NULL;
56557 }
56558
56559
56560 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56561 PyObject *resultobj = 0;
56562 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56563 wxSizer *arg2 = (wxSizer *) 0 ;
56564 wxGBSpan *arg3 = 0 ;
56565 bool result;
56566 void *argp1 = 0 ;
56567 int res1 = 0 ;
56568 void *argp2 = 0 ;
56569 int res2 = 0 ;
56570 wxGBSpan temp3 ;
56571
56572 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56574 if (!SWIG_IsOK(res1)) {
56575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56576 }
56577 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56578 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
56579 if (!SWIG_IsOK(res2)) {
56580 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
56581 }
56582 arg2 = reinterpret_cast< wxSizer * >(argp2);
56583 {
56584 arg3 = &temp3;
56585 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
56586 }
56587 {
56588 PyThreadState* __tstate = wxPyBeginAllowThreads();
56589 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
56590 wxPyEndAllowThreads(__tstate);
56591 if (PyErr_Occurred()) SWIG_fail;
56592 }
56593 {
56594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56595 }
56596 return resultobj;
56597 fail:
56598 return NULL;
56599 }
56600
56601
56602 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56603 PyObject *resultobj = 0;
56604 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56605 size_t arg2 ;
56606 wxGBSpan *arg3 = 0 ;
56607 bool result;
56608 void *argp1 = 0 ;
56609 int res1 = 0 ;
56610 size_t val2 ;
56611 int ecode2 = 0 ;
56612 wxGBSpan temp3 ;
56613
56614 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56616 if (!SWIG_IsOK(res1)) {
56617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56618 }
56619 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56620 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
56621 if (!SWIG_IsOK(ecode2)) {
56622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
56623 }
56624 arg2 = static_cast< size_t >(val2);
56625 {
56626 arg3 = &temp3;
56627 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
56628 }
56629 {
56630 PyThreadState* __tstate = wxPyBeginAllowThreads();
56631 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
56632 wxPyEndAllowThreads(__tstate);
56633 if (PyErr_Occurred()) SWIG_fail;
56634 }
56635 {
56636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56637 }
56638 return resultobj;
56639 fail:
56640 return NULL;
56641 }
56642
56643
56644 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
56645 int argc;
56646 PyObject *argv[4];
56647
56648 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
56649 --argc;
56650 if (argc == 3) {
56651 int _v = 0;
56652 {
56653 void *vptr = 0;
56654 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
56655 _v = SWIG_CheckState(res);
56656 }
56657 if (!_v) goto check_1;
56658 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
56659 }
56660 check_1:
56661
56662 if (argc == 3) {
56663 int _v = 0;
56664 {
56665 void *vptr = 0;
56666 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
56667 _v = SWIG_CheckState(res);
56668 }
56669 if (!_v) goto check_2;
56670 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
56671 }
56672 check_2:
56673
56674 if (argc == 3) {
56675 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
56676 }
56677
56678 fail:
56679 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
56680 return NULL;
56681 }
56682
56683
56684 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56685 PyObject *resultobj = 0;
56686 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56687 wxWindow *arg2 = (wxWindow *) 0 ;
56688 wxGBSizerItem *result = 0 ;
56689 void *argp1 = 0 ;
56690 int res1 = 0 ;
56691 void *argp2 = 0 ;
56692 int res2 = 0 ;
56693
56694 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56696 if (!SWIG_IsOK(res1)) {
56697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56698 }
56699 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56700 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56701 if (!SWIG_IsOK(res2)) {
56702 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
56703 }
56704 arg2 = reinterpret_cast< wxWindow * >(argp2);
56705 {
56706 PyThreadState* __tstate = wxPyBeginAllowThreads();
56707 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
56708 wxPyEndAllowThreads(__tstate);
56709 if (PyErr_Occurred()) SWIG_fail;
56710 }
56711 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56712 return resultobj;
56713 fail:
56714 return NULL;
56715 }
56716
56717
56718 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56719 PyObject *resultobj = 0;
56720 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56721 wxSizer *arg2 = (wxSizer *) 0 ;
56722 wxGBSizerItem *result = 0 ;
56723 void *argp1 = 0 ;
56724 int res1 = 0 ;
56725 void *argp2 = 0 ;
56726 int res2 = 0 ;
56727
56728 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56730 if (!SWIG_IsOK(res1)) {
56731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56732 }
56733 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56734 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
56735 if (!SWIG_IsOK(res2)) {
56736 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
56737 }
56738 arg2 = reinterpret_cast< wxSizer * >(argp2);
56739 {
56740 PyThreadState* __tstate = wxPyBeginAllowThreads();
56741 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
56742 wxPyEndAllowThreads(__tstate);
56743 if (PyErr_Occurred()) SWIG_fail;
56744 }
56745 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56746 return resultobj;
56747 fail:
56748 return NULL;
56749 }
56750
56751
56752 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
56753 int argc;
56754 PyObject *argv[3];
56755
56756 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
56757 --argc;
56758 if (argc == 2) {
56759 int _v = 0;
56760 {
56761 void *vptr = 0;
56762 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
56763 _v = SWIG_CheckState(res);
56764 }
56765 if (!_v) goto check_1;
56766 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
56767 }
56768 check_1:
56769
56770 if (argc == 2) {
56771 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
56772 }
56773
56774 fail:
56775 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
56776 return NULL;
56777 }
56778
56779
56780 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56781 PyObject *resultobj = 0;
56782 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56783 wxGBPosition *arg2 = 0 ;
56784 wxGBSizerItem *result = 0 ;
56785 void *argp1 = 0 ;
56786 int res1 = 0 ;
56787 wxGBPosition temp2 ;
56788 PyObject * obj0 = 0 ;
56789 PyObject * obj1 = 0 ;
56790 char * kwnames[] = {
56791 (char *) "self",(char *) "pos", NULL
56792 };
56793
56794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
56795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56796 if (!SWIG_IsOK(res1)) {
56797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56798 }
56799 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56800 {
56801 arg2 = &temp2;
56802 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
56803 }
56804 {
56805 PyThreadState* __tstate = wxPyBeginAllowThreads();
56806 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
56807 wxPyEndAllowThreads(__tstate);
56808 if (PyErr_Occurred()) SWIG_fail;
56809 }
56810 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56811 return resultobj;
56812 fail:
56813 return NULL;
56814 }
56815
56816
56817 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56818 PyObject *resultobj = 0;
56819 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56820 wxPoint *arg2 = 0 ;
56821 wxGBSizerItem *result = 0 ;
56822 void *argp1 = 0 ;
56823 int res1 = 0 ;
56824 wxPoint temp2 ;
56825 PyObject * obj0 = 0 ;
56826 PyObject * obj1 = 0 ;
56827 char * kwnames[] = {
56828 (char *) "self",(char *) "pt", NULL
56829 };
56830
56831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
56832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56833 if (!SWIG_IsOK(res1)) {
56834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56835 }
56836 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56837 {
56838 arg2 = &temp2;
56839 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
56840 }
56841 {
56842 PyThreadState* __tstate = wxPyBeginAllowThreads();
56843 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
56844 wxPyEndAllowThreads(__tstate);
56845 if (PyErr_Occurred()) SWIG_fail;
56846 }
56847 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56848 return resultobj;
56849 fail:
56850 return NULL;
56851 }
56852
56853
56854 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56855 PyObject *resultobj = 0;
56856 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56857 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
56858 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
56859 bool result;
56860 void *argp1 = 0 ;
56861 int res1 = 0 ;
56862 void *argp2 = 0 ;
56863 int res2 = 0 ;
56864 void *argp3 = 0 ;
56865 int res3 = 0 ;
56866 PyObject * obj0 = 0 ;
56867 PyObject * obj1 = 0 ;
56868 PyObject * obj2 = 0 ;
56869 char * kwnames[] = {
56870 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
56871 };
56872
56873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56875 if (!SWIG_IsOK(res1)) {
56876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56877 }
56878 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56879 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56880 if (!SWIG_IsOK(res2)) {
56881 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
56882 }
56883 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
56884 if (obj2) {
56885 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56886 if (!SWIG_IsOK(res3)) {
56887 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
56888 }
56889 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
56890 }
56891 {
56892 PyThreadState* __tstate = wxPyBeginAllowThreads();
56893 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
56894 wxPyEndAllowThreads(__tstate);
56895 if (PyErr_Occurred()) SWIG_fail;
56896 }
56897 {
56898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56899 }
56900 return resultobj;
56901 fail:
56902 return NULL;
56903 }
56904
56905
56906 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56907 PyObject *resultobj = 0;
56908 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56909 wxGBPosition *arg2 = 0 ;
56910 wxGBSpan *arg3 = 0 ;
56911 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
56912 bool result;
56913 void *argp1 = 0 ;
56914 int res1 = 0 ;
56915 wxGBPosition temp2 ;
56916 wxGBSpan temp3 ;
56917 void *argp4 = 0 ;
56918 int res4 = 0 ;
56919 PyObject * obj0 = 0 ;
56920 PyObject * obj1 = 0 ;
56921 PyObject * obj2 = 0 ;
56922 PyObject * obj3 = 0 ;
56923 char * kwnames[] = {
56924 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
56925 };
56926
56927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
56928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56929 if (!SWIG_IsOK(res1)) {
56930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56931 }
56932 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56933 {
56934 arg2 = &temp2;
56935 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
56936 }
56937 {
56938 arg3 = &temp3;
56939 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
56940 }
56941 if (obj3) {
56942 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56943 if (!SWIG_IsOK(res4)) {
56944 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
56945 }
56946 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
56947 }
56948 {
56949 PyThreadState* __tstate = wxPyBeginAllowThreads();
56950 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
56951 wxPyEndAllowThreads(__tstate);
56952 if (PyErr_Occurred()) SWIG_fail;
56953 }
56954 {
56955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56956 }
56957 return resultobj;
56958 fail:
56959 return NULL;
56960 }
56961
56962
56963 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56964 PyObject *obj;
56965 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56966 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
56967 return SWIG_Py_Void();
56968 }
56969
56970 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56971 return SWIG_Python_InitShadowInstance(args);
56972 }
56973
56974 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56975 PyObject *resultobj = 0;
56976 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56977 wxRelationship arg2 ;
56978 wxWindow *arg3 = (wxWindow *) 0 ;
56979 wxEdge arg4 ;
56980 int arg5 = (int) 0 ;
56981 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
56982 void *argp1 = 0 ;
56983 int res1 = 0 ;
56984 int val2 ;
56985 int ecode2 = 0 ;
56986 void *argp3 = 0 ;
56987 int res3 = 0 ;
56988 int val4 ;
56989 int ecode4 = 0 ;
56990 int val5 ;
56991 int ecode5 = 0 ;
56992 int val6 ;
56993 int ecode6 = 0 ;
56994 PyObject * obj0 = 0 ;
56995 PyObject * obj1 = 0 ;
56996 PyObject * obj2 = 0 ;
56997 PyObject * obj3 = 0 ;
56998 PyObject * obj4 = 0 ;
56999 PyObject * obj5 = 0 ;
57000 char * kwnames[] = {
57001 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
57002 };
57003
57004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
57005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57006 if (!SWIG_IsOK(res1)) {
57007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57008 }
57009 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57010 ecode2 = SWIG_AsVal_int(obj1, &val2);
57011 if (!SWIG_IsOK(ecode2)) {
57012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
57013 }
57014 arg2 = static_cast< wxRelationship >(val2);
57015 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
57016 if (!SWIG_IsOK(res3)) {
57017 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
57018 }
57019 arg3 = reinterpret_cast< wxWindow * >(argp3);
57020 ecode4 = SWIG_AsVal_int(obj3, &val4);
57021 if (!SWIG_IsOK(ecode4)) {
57022 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
57023 }
57024 arg4 = static_cast< wxEdge >(val4);
57025 if (obj4) {
57026 ecode5 = SWIG_AsVal_int(obj4, &val5);
57027 if (!SWIG_IsOK(ecode5)) {
57028 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
57029 }
57030 arg5 = static_cast< int >(val5);
57031 }
57032 if (obj5) {
57033 ecode6 = SWIG_AsVal_int(obj5, &val6);
57034 if (!SWIG_IsOK(ecode6)) {
57035 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
57036 }
57037 arg6 = static_cast< int >(val6);
57038 }
57039 {
57040 PyThreadState* __tstate = wxPyBeginAllowThreads();
57041 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
57042 wxPyEndAllowThreads(__tstate);
57043 if (PyErr_Occurred()) SWIG_fail;
57044 }
57045 resultobj = SWIG_Py_Void();
57046 return resultobj;
57047 fail:
57048 return NULL;
57049 }
57050
57051
57052 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57053 PyObject *resultobj = 0;
57054 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57055 wxWindow *arg2 = (wxWindow *) 0 ;
57056 int arg3 = (int) 0 ;
57057 void *argp1 = 0 ;
57058 int res1 = 0 ;
57059 void *argp2 = 0 ;
57060 int res2 = 0 ;
57061 int val3 ;
57062 int ecode3 = 0 ;
57063 PyObject * obj0 = 0 ;
57064 PyObject * obj1 = 0 ;
57065 PyObject * obj2 = 0 ;
57066 char * kwnames[] = {
57067 (char *) "self",(char *) "sibling",(char *) "marg", NULL
57068 };
57069
57070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
57071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57072 if (!SWIG_IsOK(res1)) {
57073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57074 }
57075 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57076 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57077 if (!SWIG_IsOK(res2)) {
57078 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
57079 }
57080 arg2 = reinterpret_cast< wxWindow * >(argp2);
57081 if (obj2) {
57082 ecode3 = SWIG_AsVal_int(obj2, &val3);
57083 if (!SWIG_IsOK(ecode3)) {
57084 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
57085 }
57086 arg3 = static_cast< int >(val3);
57087 }
57088 {
57089 PyThreadState* __tstate = wxPyBeginAllowThreads();
57090 (arg1)->LeftOf(arg2,arg3);
57091 wxPyEndAllowThreads(__tstate);
57092 if (PyErr_Occurred()) SWIG_fail;
57093 }
57094 resultobj = SWIG_Py_Void();
57095 return resultobj;
57096 fail:
57097 return NULL;
57098 }
57099
57100
57101 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57102 PyObject *resultobj = 0;
57103 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57104 wxWindow *arg2 = (wxWindow *) 0 ;
57105 int arg3 = (int) 0 ;
57106 void *argp1 = 0 ;
57107 int res1 = 0 ;
57108 void *argp2 = 0 ;
57109 int res2 = 0 ;
57110 int val3 ;
57111 int ecode3 = 0 ;
57112 PyObject * obj0 = 0 ;
57113 PyObject * obj1 = 0 ;
57114 PyObject * obj2 = 0 ;
57115 char * kwnames[] = {
57116 (char *) "self",(char *) "sibling",(char *) "marg", NULL
57117 };
57118
57119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
57120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57121 if (!SWIG_IsOK(res1)) {
57122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57123 }
57124 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57125 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57126 if (!SWIG_IsOK(res2)) {
57127 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
57128 }
57129 arg2 = reinterpret_cast< wxWindow * >(argp2);
57130 if (obj2) {
57131 ecode3 = SWIG_AsVal_int(obj2, &val3);
57132 if (!SWIG_IsOK(ecode3)) {
57133 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
57134 }
57135 arg3 = static_cast< int >(val3);
57136 }
57137 {
57138 PyThreadState* __tstate = wxPyBeginAllowThreads();
57139 (arg1)->RightOf(arg2,arg3);
57140 wxPyEndAllowThreads(__tstate);
57141 if (PyErr_Occurred()) SWIG_fail;
57142 }
57143 resultobj = SWIG_Py_Void();
57144 return resultobj;
57145 fail:
57146 return NULL;
57147 }
57148
57149
57150 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57151 PyObject *resultobj = 0;
57152 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57153 wxWindow *arg2 = (wxWindow *) 0 ;
57154 int arg3 = (int) 0 ;
57155 void *argp1 = 0 ;
57156 int res1 = 0 ;
57157 void *argp2 = 0 ;
57158 int res2 = 0 ;
57159 int val3 ;
57160 int ecode3 = 0 ;
57161 PyObject * obj0 = 0 ;
57162 PyObject * obj1 = 0 ;
57163 PyObject * obj2 = 0 ;
57164 char * kwnames[] = {
57165 (char *) "self",(char *) "sibling",(char *) "marg", NULL
57166 };
57167
57168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
57169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57170 if (!SWIG_IsOK(res1)) {
57171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57172 }
57173 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57174 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57175 if (!SWIG_IsOK(res2)) {
57176 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
57177 }
57178 arg2 = reinterpret_cast< wxWindow * >(argp2);
57179 if (obj2) {
57180 ecode3 = SWIG_AsVal_int(obj2, &val3);
57181 if (!SWIG_IsOK(ecode3)) {
57182 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
57183 }
57184 arg3 = static_cast< int >(val3);
57185 }
57186 {
57187 PyThreadState* __tstate = wxPyBeginAllowThreads();
57188 (arg1)->Above(arg2,arg3);
57189 wxPyEndAllowThreads(__tstate);
57190 if (PyErr_Occurred()) SWIG_fail;
57191 }
57192 resultobj = SWIG_Py_Void();
57193 return resultobj;
57194 fail:
57195 return NULL;
57196 }
57197
57198
57199 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57200 PyObject *resultobj = 0;
57201 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57202 wxWindow *arg2 = (wxWindow *) 0 ;
57203 int arg3 = (int) 0 ;
57204 void *argp1 = 0 ;
57205 int res1 = 0 ;
57206 void *argp2 = 0 ;
57207 int res2 = 0 ;
57208 int val3 ;
57209 int ecode3 = 0 ;
57210 PyObject * obj0 = 0 ;
57211 PyObject * obj1 = 0 ;
57212 PyObject * obj2 = 0 ;
57213 char * kwnames[] = {
57214 (char *) "self",(char *) "sibling",(char *) "marg", NULL
57215 };
57216
57217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
57218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57219 if (!SWIG_IsOK(res1)) {
57220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57221 }
57222 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57223 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57224 if (!SWIG_IsOK(res2)) {
57225 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
57226 }
57227 arg2 = reinterpret_cast< wxWindow * >(argp2);
57228 if (obj2) {
57229 ecode3 = SWIG_AsVal_int(obj2, &val3);
57230 if (!SWIG_IsOK(ecode3)) {
57231 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
57232 }
57233 arg3 = static_cast< int >(val3);
57234 }
57235 {
57236 PyThreadState* __tstate = wxPyBeginAllowThreads();
57237 (arg1)->Below(arg2,arg3);
57238 wxPyEndAllowThreads(__tstate);
57239 if (PyErr_Occurred()) SWIG_fail;
57240 }
57241 resultobj = SWIG_Py_Void();
57242 return resultobj;
57243 fail:
57244 return NULL;
57245 }
57246
57247
57248 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57249 PyObject *resultobj = 0;
57250 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57251 wxWindow *arg2 = (wxWindow *) 0 ;
57252 wxEdge arg3 ;
57253 int arg4 = (int) 0 ;
57254 void *argp1 = 0 ;
57255 int res1 = 0 ;
57256 void *argp2 = 0 ;
57257 int res2 = 0 ;
57258 int val3 ;
57259 int ecode3 = 0 ;
57260 int val4 ;
57261 int ecode4 = 0 ;
57262 PyObject * obj0 = 0 ;
57263 PyObject * obj1 = 0 ;
57264 PyObject * obj2 = 0 ;
57265 PyObject * obj3 = 0 ;
57266 char * kwnames[] = {
57267 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
57268 };
57269
57270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
57271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57272 if (!SWIG_IsOK(res1)) {
57273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57274 }
57275 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57276 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57277 if (!SWIG_IsOK(res2)) {
57278 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
57279 }
57280 arg2 = reinterpret_cast< wxWindow * >(argp2);
57281 ecode3 = SWIG_AsVal_int(obj2, &val3);
57282 if (!SWIG_IsOK(ecode3)) {
57283 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
57284 }
57285 arg3 = static_cast< wxEdge >(val3);
57286 if (obj3) {
57287 ecode4 = SWIG_AsVal_int(obj3, &val4);
57288 if (!SWIG_IsOK(ecode4)) {
57289 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
57290 }
57291 arg4 = static_cast< int >(val4);
57292 }
57293 {
57294 PyThreadState* __tstate = wxPyBeginAllowThreads();
57295 (arg1)->SameAs(arg2,arg3,arg4);
57296 wxPyEndAllowThreads(__tstate);
57297 if (PyErr_Occurred()) SWIG_fail;
57298 }
57299 resultobj = SWIG_Py_Void();
57300 return resultobj;
57301 fail:
57302 return NULL;
57303 }
57304
57305
57306 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57307 PyObject *resultobj = 0;
57308 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57309 wxWindow *arg2 = (wxWindow *) 0 ;
57310 wxEdge arg3 ;
57311 int arg4 ;
57312 void *argp1 = 0 ;
57313 int res1 = 0 ;
57314 void *argp2 = 0 ;
57315 int res2 = 0 ;
57316 int val3 ;
57317 int ecode3 = 0 ;
57318 int val4 ;
57319 int ecode4 = 0 ;
57320 PyObject * obj0 = 0 ;
57321 PyObject * obj1 = 0 ;
57322 PyObject * obj2 = 0 ;
57323 PyObject * obj3 = 0 ;
57324 char * kwnames[] = {
57325 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
57326 };
57327
57328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
57329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57330 if (!SWIG_IsOK(res1)) {
57331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57332 }
57333 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57334 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57335 if (!SWIG_IsOK(res2)) {
57336 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
57337 }
57338 arg2 = reinterpret_cast< wxWindow * >(argp2);
57339 ecode3 = SWIG_AsVal_int(obj2, &val3);
57340 if (!SWIG_IsOK(ecode3)) {
57341 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
57342 }
57343 arg3 = static_cast< wxEdge >(val3);
57344 ecode4 = SWIG_AsVal_int(obj3, &val4);
57345 if (!SWIG_IsOK(ecode4)) {
57346 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
57347 }
57348 arg4 = static_cast< int >(val4);
57349 {
57350 PyThreadState* __tstate = wxPyBeginAllowThreads();
57351 (arg1)->PercentOf(arg2,arg3,arg4);
57352 wxPyEndAllowThreads(__tstate);
57353 if (PyErr_Occurred()) SWIG_fail;
57354 }
57355 resultobj = SWIG_Py_Void();
57356 return resultobj;
57357 fail:
57358 return NULL;
57359 }
57360
57361
57362 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57363 PyObject *resultobj = 0;
57364 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57365 int arg2 ;
57366 void *argp1 = 0 ;
57367 int res1 = 0 ;
57368 int val2 ;
57369 int ecode2 = 0 ;
57370 PyObject * obj0 = 0 ;
57371 PyObject * obj1 = 0 ;
57372 char * kwnames[] = {
57373 (char *) "self",(char *) "val", NULL
57374 };
57375
57376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
57377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57378 if (!SWIG_IsOK(res1)) {
57379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57380 }
57381 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57382 ecode2 = SWIG_AsVal_int(obj1, &val2);
57383 if (!SWIG_IsOK(ecode2)) {
57384 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
57385 }
57386 arg2 = static_cast< int >(val2);
57387 {
57388 PyThreadState* __tstate = wxPyBeginAllowThreads();
57389 (arg1)->Absolute(arg2);
57390 wxPyEndAllowThreads(__tstate);
57391 if (PyErr_Occurred()) SWIG_fail;
57392 }
57393 resultobj = SWIG_Py_Void();
57394 return resultobj;
57395 fail:
57396 return NULL;
57397 }
57398
57399
57400 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57401 PyObject *resultobj = 0;
57402 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57403 void *argp1 = 0 ;
57404 int res1 = 0 ;
57405 PyObject *swig_obj[1] ;
57406
57407 if (!args) SWIG_fail;
57408 swig_obj[0] = args;
57409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57410 if (!SWIG_IsOK(res1)) {
57411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57412 }
57413 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57414 {
57415 PyThreadState* __tstate = wxPyBeginAllowThreads();
57416 (arg1)->Unconstrained();
57417 wxPyEndAllowThreads(__tstate);
57418 if (PyErr_Occurred()) SWIG_fail;
57419 }
57420 resultobj = SWIG_Py_Void();
57421 return resultobj;
57422 fail:
57423 return NULL;
57424 }
57425
57426
57427 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57428 PyObject *resultobj = 0;
57429 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57430 void *argp1 = 0 ;
57431 int res1 = 0 ;
57432 PyObject *swig_obj[1] ;
57433
57434 if (!args) SWIG_fail;
57435 swig_obj[0] = args;
57436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57437 if (!SWIG_IsOK(res1)) {
57438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57439 }
57440 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57441 {
57442 PyThreadState* __tstate = wxPyBeginAllowThreads();
57443 (arg1)->AsIs();
57444 wxPyEndAllowThreads(__tstate);
57445 if (PyErr_Occurred()) SWIG_fail;
57446 }
57447 resultobj = SWIG_Py_Void();
57448 return resultobj;
57449 fail:
57450 return NULL;
57451 }
57452
57453
57454 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57455 PyObject *resultobj = 0;
57456 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57457 wxWindow *result = 0 ;
57458 void *argp1 = 0 ;
57459 int res1 = 0 ;
57460 PyObject *swig_obj[1] ;
57461
57462 if (!args) SWIG_fail;
57463 swig_obj[0] = args;
57464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57465 if (!SWIG_IsOK(res1)) {
57466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57467 }
57468 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57469 {
57470 PyThreadState* __tstate = wxPyBeginAllowThreads();
57471 result = (wxWindow *)(arg1)->GetOtherWindow();
57472 wxPyEndAllowThreads(__tstate);
57473 if (PyErr_Occurred()) SWIG_fail;
57474 }
57475 {
57476 resultobj = wxPyMake_wxObject(result, 0);
57477 }
57478 return resultobj;
57479 fail:
57480 return NULL;
57481 }
57482
57483
57484 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57485 PyObject *resultobj = 0;
57486 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57487 wxEdge result;
57488 void *argp1 = 0 ;
57489 int res1 = 0 ;
57490 PyObject *swig_obj[1] ;
57491
57492 if (!args) SWIG_fail;
57493 swig_obj[0] = args;
57494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57495 if (!SWIG_IsOK(res1)) {
57496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57497 }
57498 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57499 {
57500 PyThreadState* __tstate = wxPyBeginAllowThreads();
57501 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
57502 wxPyEndAllowThreads(__tstate);
57503 if (PyErr_Occurred()) SWIG_fail;
57504 }
57505 resultobj = SWIG_From_int(static_cast< int >(result));
57506 return resultobj;
57507 fail:
57508 return NULL;
57509 }
57510
57511
57512 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57513 PyObject *resultobj = 0;
57514 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57515 wxEdge arg2 ;
57516 void *argp1 = 0 ;
57517 int res1 = 0 ;
57518 int val2 ;
57519 int ecode2 = 0 ;
57520 PyObject * obj0 = 0 ;
57521 PyObject * obj1 = 0 ;
57522 char * kwnames[] = {
57523 (char *) "self",(char *) "which", NULL
57524 };
57525
57526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
57527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57528 if (!SWIG_IsOK(res1)) {
57529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57530 }
57531 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57532 ecode2 = SWIG_AsVal_int(obj1, &val2);
57533 if (!SWIG_IsOK(ecode2)) {
57534 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
57535 }
57536 arg2 = static_cast< wxEdge >(val2);
57537 {
57538 PyThreadState* __tstate = wxPyBeginAllowThreads();
57539 (arg1)->SetEdge(arg2);
57540 wxPyEndAllowThreads(__tstate);
57541 if (PyErr_Occurred()) SWIG_fail;
57542 }
57543 resultobj = SWIG_Py_Void();
57544 return resultobj;
57545 fail:
57546 return NULL;
57547 }
57548
57549
57550 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57551 PyObject *resultobj = 0;
57552 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57553 int arg2 ;
57554 void *argp1 = 0 ;
57555 int res1 = 0 ;
57556 int val2 ;
57557 int ecode2 = 0 ;
57558 PyObject * obj0 = 0 ;
57559 PyObject * obj1 = 0 ;
57560 char * kwnames[] = {
57561 (char *) "self",(char *) "v", NULL
57562 };
57563
57564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
57565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57566 if (!SWIG_IsOK(res1)) {
57567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57568 }
57569 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57570 ecode2 = SWIG_AsVal_int(obj1, &val2);
57571 if (!SWIG_IsOK(ecode2)) {
57572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
57573 }
57574 arg2 = static_cast< int >(val2);
57575 {
57576 PyThreadState* __tstate = wxPyBeginAllowThreads();
57577 (arg1)->SetValue(arg2);
57578 wxPyEndAllowThreads(__tstate);
57579 if (PyErr_Occurred()) SWIG_fail;
57580 }
57581 resultobj = SWIG_Py_Void();
57582 return resultobj;
57583 fail:
57584 return NULL;
57585 }
57586
57587
57588 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57589 PyObject *resultobj = 0;
57590 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57591 int result;
57592 void *argp1 = 0 ;
57593 int res1 = 0 ;
57594 PyObject *swig_obj[1] ;
57595
57596 if (!args) SWIG_fail;
57597 swig_obj[0] = args;
57598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57599 if (!SWIG_IsOK(res1)) {
57600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57601 }
57602 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57603 {
57604 PyThreadState* __tstate = wxPyBeginAllowThreads();
57605 result = (int)(arg1)->GetMargin();
57606 wxPyEndAllowThreads(__tstate);
57607 if (PyErr_Occurred()) SWIG_fail;
57608 }
57609 resultobj = SWIG_From_int(static_cast< int >(result));
57610 return resultobj;
57611 fail:
57612 return NULL;
57613 }
57614
57615
57616 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57617 PyObject *resultobj = 0;
57618 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57619 int arg2 ;
57620 void *argp1 = 0 ;
57621 int res1 = 0 ;
57622 int val2 ;
57623 int ecode2 = 0 ;
57624 PyObject * obj0 = 0 ;
57625 PyObject * obj1 = 0 ;
57626 char * kwnames[] = {
57627 (char *) "self",(char *) "m", NULL
57628 };
57629
57630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
57631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57632 if (!SWIG_IsOK(res1)) {
57633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57634 }
57635 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57636 ecode2 = SWIG_AsVal_int(obj1, &val2);
57637 if (!SWIG_IsOK(ecode2)) {
57638 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
57639 }
57640 arg2 = static_cast< int >(val2);
57641 {
57642 PyThreadState* __tstate = wxPyBeginAllowThreads();
57643 (arg1)->SetMargin(arg2);
57644 wxPyEndAllowThreads(__tstate);
57645 if (PyErr_Occurred()) SWIG_fail;
57646 }
57647 resultobj = SWIG_Py_Void();
57648 return resultobj;
57649 fail:
57650 return NULL;
57651 }
57652
57653
57654 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57655 PyObject *resultobj = 0;
57656 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57657 int result;
57658 void *argp1 = 0 ;
57659 int res1 = 0 ;
57660 PyObject *swig_obj[1] ;
57661
57662 if (!args) SWIG_fail;
57663 swig_obj[0] = args;
57664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57665 if (!SWIG_IsOK(res1)) {
57666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57667 }
57668 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57669 {
57670 PyThreadState* __tstate = wxPyBeginAllowThreads();
57671 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
57672 wxPyEndAllowThreads(__tstate);
57673 if (PyErr_Occurred()) SWIG_fail;
57674 }
57675 resultobj = SWIG_From_int(static_cast< int >(result));
57676 return resultobj;
57677 fail:
57678 return NULL;
57679 }
57680
57681
57682 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57683 PyObject *resultobj = 0;
57684 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57685 int result;
57686 void *argp1 = 0 ;
57687 int res1 = 0 ;
57688 PyObject *swig_obj[1] ;
57689
57690 if (!args) SWIG_fail;
57691 swig_obj[0] = args;
57692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57693 if (!SWIG_IsOK(res1)) {
57694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57695 }
57696 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57697 {
57698 PyThreadState* __tstate = wxPyBeginAllowThreads();
57699 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
57700 wxPyEndAllowThreads(__tstate);
57701 if (PyErr_Occurred()) SWIG_fail;
57702 }
57703 resultobj = SWIG_From_int(static_cast< int >(result));
57704 return resultobj;
57705 fail:
57706 return NULL;
57707 }
57708
57709
57710 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57711 PyObject *resultobj = 0;
57712 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57713 int result;
57714 void *argp1 = 0 ;
57715 int res1 = 0 ;
57716 PyObject *swig_obj[1] ;
57717
57718 if (!args) SWIG_fail;
57719 swig_obj[0] = args;
57720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57721 if (!SWIG_IsOK(res1)) {
57722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57723 }
57724 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57725 {
57726 PyThreadState* __tstate = wxPyBeginAllowThreads();
57727 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
57728 wxPyEndAllowThreads(__tstate);
57729 if (PyErr_Occurred()) SWIG_fail;
57730 }
57731 resultobj = SWIG_From_int(static_cast< int >(result));
57732 return resultobj;
57733 fail:
57734 return NULL;
57735 }
57736
57737
57738 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57739 PyObject *resultobj = 0;
57740 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57741 bool result;
57742 void *argp1 = 0 ;
57743 int res1 = 0 ;
57744 PyObject *swig_obj[1] ;
57745
57746 if (!args) SWIG_fail;
57747 swig_obj[0] = args;
57748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57749 if (!SWIG_IsOK(res1)) {
57750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57751 }
57752 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57753 {
57754 PyThreadState* __tstate = wxPyBeginAllowThreads();
57755 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
57756 wxPyEndAllowThreads(__tstate);
57757 if (PyErr_Occurred()) SWIG_fail;
57758 }
57759 {
57760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57761 }
57762 return resultobj;
57763 fail:
57764 return NULL;
57765 }
57766
57767
57768 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57769 PyObject *resultobj = 0;
57770 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57771 bool arg2 ;
57772 void *argp1 = 0 ;
57773 int res1 = 0 ;
57774 bool val2 ;
57775 int ecode2 = 0 ;
57776 PyObject * obj0 = 0 ;
57777 PyObject * obj1 = 0 ;
57778 char * kwnames[] = {
57779 (char *) "self",(char *) "d", NULL
57780 };
57781
57782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
57783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57784 if (!SWIG_IsOK(res1)) {
57785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57786 }
57787 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57788 ecode2 = SWIG_AsVal_bool(obj1, &val2);
57789 if (!SWIG_IsOK(ecode2)) {
57790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
57791 }
57792 arg2 = static_cast< bool >(val2);
57793 {
57794 PyThreadState* __tstate = wxPyBeginAllowThreads();
57795 (arg1)->SetDone(arg2);
57796 wxPyEndAllowThreads(__tstate);
57797 if (PyErr_Occurred()) SWIG_fail;
57798 }
57799 resultobj = SWIG_Py_Void();
57800 return resultobj;
57801 fail:
57802 return NULL;
57803 }
57804
57805
57806 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57807 PyObject *resultobj = 0;
57808 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57809 wxRelationship result;
57810 void *argp1 = 0 ;
57811 int res1 = 0 ;
57812 PyObject *swig_obj[1] ;
57813
57814 if (!args) SWIG_fail;
57815 swig_obj[0] = args;
57816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57817 if (!SWIG_IsOK(res1)) {
57818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57819 }
57820 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57821 {
57822 PyThreadState* __tstate = wxPyBeginAllowThreads();
57823 result = (wxRelationship)(arg1)->GetRelationship();
57824 wxPyEndAllowThreads(__tstate);
57825 if (PyErr_Occurred()) SWIG_fail;
57826 }
57827 resultobj = SWIG_From_int(static_cast< int >(result));
57828 return resultobj;
57829 fail:
57830 return NULL;
57831 }
57832
57833
57834 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57835 PyObject *resultobj = 0;
57836 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57837 wxRelationship arg2 ;
57838 void *argp1 = 0 ;
57839 int res1 = 0 ;
57840 int val2 ;
57841 int ecode2 = 0 ;
57842 PyObject * obj0 = 0 ;
57843 PyObject * obj1 = 0 ;
57844 char * kwnames[] = {
57845 (char *) "self",(char *) "r", NULL
57846 };
57847
57848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
57849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57850 if (!SWIG_IsOK(res1)) {
57851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57852 }
57853 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57854 ecode2 = SWIG_AsVal_int(obj1, &val2);
57855 if (!SWIG_IsOK(ecode2)) {
57856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
57857 }
57858 arg2 = static_cast< wxRelationship >(val2);
57859 {
57860 PyThreadState* __tstate = wxPyBeginAllowThreads();
57861 (arg1)->SetRelationship(arg2);
57862 wxPyEndAllowThreads(__tstate);
57863 if (PyErr_Occurred()) SWIG_fail;
57864 }
57865 resultobj = SWIG_Py_Void();
57866 return resultobj;
57867 fail:
57868 return NULL;
57869 }
57870
57871
57872 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57873 PyObject *resultobj = 0;
57874 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57875 wxWindow *arg2 = (wxWindow *) 0 ;
57876 bool result;
57877 void *argp1 = 0 ;
57878 int res1 = 0 ;
57879 void *argp2 = 0 ;
57880 int res2 = 0 ;
57881 PyObject * obj0 = 0 ;
57882 PyObject * obj1 = 0 ;
57883 char * kwnames[] = {
57884 (char *) "self",(char *) "otherW", NULL
57885 };
57886
57887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
57888 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57889 if (!SWIG_IsOK(res1)) {
57890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57891 }
57892 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57893 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57894 if (!SWIG_IsOK(res2)) {
57895 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
57896 }
57897 arg2 = reinterpret_cast< wxWindow * >(argp2);
57898 {
57899 PyThreadState* __tstate = wxPyBeginAllowThreads();
57900 result = (bool)(arg1)->ResetIfWin(arg2);
57901 wxPyEndAllowThreads(__tstate);
57902 if (PyErr_Occurred()) SWIG_fail;
57903 }
57904 {
57905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57906 }
57907 return resultobj;
57908 fail:
57909 return NULL;
57910 }
57911
57912
57913 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57914 PyObject *resultobj = 0;
57915 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57916 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
57917 wxWindow *arg3 = (wxWindow *) 0 ;
57918 bool result;
57919 void *argp1 = 0 ;
57920 int res1 = 0 ;
57921 void *argp2 = 0 ;
57922 int res2 = 0 ;
57923 void *argp3 = 0 ;
57924 int res3 = 0 ;
57925 PyObject * obj0 = 0 ;
57926 PyObject * obj1 = 0 ;
57927 PyObject * obj2 = 0 ;
57928 char * kwnames[] = {
57929 (char *) "self",(char *) "constraints",(char *) "win", NULL
57930 };
57931
57932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
57933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57934 if (!SWIG_IsOK(res1)) {
57935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57936 }
57937 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57938 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57939 if (!SWIG_IsOK(res2)) {
57940 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
57941 }
57942 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
57943 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
57944 if (!SWIG_IsOK(res3)) {
57945 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
57946 }
57947 arg3 = reinterpret_cast< wxWindow * >(argp3);
57948 {
57949 PyThreadState* __tstate = wxPyBeginAllowThreads();
57950 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
57951 wxPyEndAllowThreads(__tstate);
57952 if (PyErr_Occurred()) SWIG_fail;
57953 }
57954 {
57955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57956 }
57957 return resultobj;
57958 fail:
57959 return NULL;
57960 }
57961
57962
57963 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57964 PyObject *resultobj = 0;
57965 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57966 wxEdge arg2 ;
57967 wxWindow *arg3 = (wxWindow *) 0 ;
57968 wxWindow *arg4 = (wxWindow *) 0 ;
57969 int result;
57970 void *argp1 = 0 ;
57971 int res1 = 0 ;
57972 int val2 ;
57973 int ecode2 = 0 ;
57974 void *argp3 = 0 ;
57975 int res3 = 0 ;
57976 void *argp4 = 0 ;
57977 int res4 = 0 ;
57978 PyObject * obj0 = 0 ;
57979 PyObject * obj1 = 0 ;
57980 PyObject * obj2 = 0 ;
57981 PyObject * obj3 = 0 ;
57982 char * kwnames[] = {
57983 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
57984 };
57985
57986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
57987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57988 if (!SWIG_IsOK(res1)) {
57989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57990 }
57991 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57992 ecode2 = SWIG_AsVal_int(obj1, &val2);
57993 if (!SWIG_IsOK(ecode2)) {
57994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
57995 }
57996 arg2 = static_cast< wxEdge >(val2);
57997 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
57998 if (!SWIG_IsOK(res3)) {
57999 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
58000 }
58001 arg3 = reinterpret_cast< wxWindow * >(argp3);
58002 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
58003 if (!SWIG_IsOK(res4)) {
58004 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
58005 }
58006 arg4 = reinterpret_cast< wxWindow * >(argp4);
58007 {
58008 PyThreadState* __tstate = wxPyBeginAllowThreads();
58009 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
58010 wxPyEndAllowThreads(__tstate);
58011 if (PyErr_Occurred()) SWIG_fail;
58012 }
58013 resultobj = SWIG_From_int(static_cast< int >(result));
58014 return resultobj;
58015 fail:
58016 return NULL;
58017 }
58018
58019
58020 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58021 PyObject *obj;
58022 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
58023 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
58024 return SWIG_Py_Void();
58025 }
58026
58027 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58028 PyObject *resultobj = 0;
58029 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58030 wxIndividualLayoutConstraint *result = 0 ;
58031 void *argp1 = 0 ;
58032 int res1 = 0 ;
58033 PyObject *swig_obj[1] ;
58034
58035 if (!args) SWIG_fail;
58036 swig_obj[0] = args;
58037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58038 if (!SWIG_IsOK(res1)) {
58039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58040 }
58041 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58042 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
58043 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58044 return resultobj;
58045 fail:
58046 return NULL;
58047 }
58048
58049
58050 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58051 PyObject *resultobj = 0;
58052 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58053 wxIndividualLayoutConstraint *result = 0 ;
58054 void *argp1 = 0 ;
58055 int res1 = 0 ;
58056 PyObject *swig_obj[1] ;
58057
58058 if (!args) SWIG_fail;
58059 swig_obj[0] = args;
58060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58061 if (!SWIG_IsOK(res1)) {
58062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58063 }
58064 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58065 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
58066 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58067 return resultobj;
58068 fail:
58069 return NULL;
58070 }
58071
58072
58073 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58074 PyObject *resultobj = 0;
58075 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58076 wxIndividualLayoutConstraint *result = 0 ;
58077 void *argp1 = 0 ;
58078 int res1 = 0 ;
58079 PyObject *swig_obj[1] ;
58080
58081 if (!args) SWIG_fail;
58082 swig_obj[0] = args;
58083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58084 if (!SWIG_IsOK(res1)) {
58085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58086 }
58087 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58088 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
58089 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58090 return resultobj;
58091 fail:
58092 return NULL;
58093 }
58094
58095
58096 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58097 PyObject *resultobj = 0;
58098 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58099 wxIndividualLayoutConstraint *result = 0 ;
58100 void *argp1 = 0 ;
58101 int res1 = 0 ;
58102 PyObject *swig_obj[1] ;
58103
58104 if (!args) SWIG_fail;
58105 swig_obj[0] = args;
58106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58107 if (!SWIG_IsOK(res1)) {
58108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58109 }
58110 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58111 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
58112 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58113 return resultobj;
58114 fail:
58115 return NULL;
58116 }
58117
58118
58119 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58120 PyObject *resultobj = 0;
58121 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58122 wxIndividualLayoutConstraint *result = 0 ;
58123 void *argp1 = 0 ;
58124 int res1 = 0 ;
58125 PyObject *swig_obj[1] ;
58126
58127 if (!args) SWIG_fail;
58128 swig_obj[0] = args;
58129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58130 if (!SWIG_IsOK(res1)) {
58131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58132 }
58133 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58134 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
58135 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58136 return resultobj;
58137 fail:
58138 return NULL;
58139 }
58140
58141
58142 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58143 PyObject *resultobj = 0;
58144 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58145 wxIndividualLayoutConstraint *result = 0 ;
58146 void *argp1 = 0 ;
58147 int res1 = 0 ;
58148 PyObject *swig_obj[1] ;
58149
58150 if (!args) SWIG_fail;
58151 swig_obj[0] = args;
58152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58153 if (!SWIG_IsOK(res1)) {
58154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58155 }
58156 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58157 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
58158 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58159 return resultobj;
58160 fail:
58161 return NULL;
58162 }
58163
58164
58165 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58166 PyObject *resultobj = 0;
58167 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58168 wxIndividualLayoutConstraint *result = 0 ;
58169 void *argp1 = 0 ;
58170 int res1 = 0 ;
58171 PyObject *swig_obj[1] ;
58172
58173 if (!args) SWIG_fail;
58174 swig_obj[0] = args;
58175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58176 if (!SWIG_IsOK(res1)) {
58177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58178 }
58179 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58180 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
58181 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58182 return resultobj;
58183 fail:
58184 return NULL;
58185 }
58186
58187
58188 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58189 PyObject *resultobj = 0;
58190 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58191 wxIndividualLayoutConstraint *result = 0 ;
58192 void *argp1 = 0 ;
58193 int res1 = 0 ;
58194 PyObject *swig_obj[1] ;
58195
58196 if (!args) SWIG_fail;
58197 swig_obj[0] = args;
58198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58199 if (!SWIG_IsOK(res1)) {
58200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58201 }
58202 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58203 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
58204 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58205 return resultobj;
58206 fail:
58207 return NULL;
58208 }
58209
58210
58211 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58212 PyObject *resultobj = 0;
58213 wxLayoutConstraints *result = 0 ;
58214
58215 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
58216 {
58217 PyThreadState* __tstate = wxPyBeginAllowThreads();
58218 result = (wxLayoutConstraints *)new wxLayoutConstraints();
58219 wxPyEndAllowThreads(__tstate);
58220 if (PyErr_Occurred()) SWIG_fail;
58221 }
58222 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
58223 return resultobj;
58224 fail:
58225 return NULL;
58226 }
58227
58228
58229 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58230 PyObject *resultobj = 0;
58231 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58232 void *argp1 = 0 ;
58233 int res1 = 0 ;
58234 PyObject *swig_obj[1] ;
58235
58236 if (!args) SWIG_fail;
58237 swig_obj[0] = args;
58238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
58239 if (!SWIG_IsOK(res1)) {
58240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58241 }
58242 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58243 {
58244 PyThreadState* __tstate = wxPyBeginAllowThreads();
58245 delete arg1;
58246
58247 wxPyEndAllowThreads(__tstate);
58248 if (PyErr_Occurred()) SWIG_fail;
58249 }
58250 resultobj = SWIG_Py_Void();
58251 return resultobj;
58252 fail:
58253 return NULL;
58254 }
58255
58256
58257 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
58258 PyObject *resultobj = 0;
58259 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58260 wxWindow *arg2 = (wxWindow *) 0 ;
58261 int *arg3 = (int *) 0 ;
58262 bool result;
58263 void *argp1 = 0 ;
58264 int res1 = 0 ;
58265 void *argp2 = 0 ;
58266 int res2 = 0 ;
58267 int temp3 ;
58268 int res3 = SWIG_TMPOBJ ;
58269 PyObject * obj0 = 0 ;
58270 PyObject * obj1 = 0 ;
58271 char * kwnames[] = {
58272 (char *) "self",(char *) "win", NULL
58273 };
58274
58275 arg3 = &temp3;
58276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
58277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58278 if (!SWIG_IsOK(res1)) {
58279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58280 }
58281 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58282 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
58283 if (!SWIG_IsOK(res2)) {
58284 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
58285 }
58286 arg2 = reinterpret_cast< wxWindow * >(argp2);
58287 {
58288 PyThreadState* __tstate = wxPyBeginAllowThreads();
58289 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
58290 wxPyEndAllowThreads(__tstate);
58291 if (PyErr_Occurred()) SWIG_fail;
58292 }
58293 {
58294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
58295 }
58296 if (SWIG_IsTmpObj(res3)) {
58297 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
58298 } else {
58299 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
58300 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
58301 }
58302 return resultobj;
58303 fail:
58304 return NULL;
58305 }
58306
58307
58308 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58309 PyObject *resultobj = 0;
58310 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58311 bool result;
58312 void *argp1 = 0 ;
58313 int res1 = 0 ;
58314 PyObject *swig_obj[1] ;
58315
58316 if (!args) SWIG_fail;
58317 swig_obj[0] = args;
58318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58319 if (!SWIG_IsOK(res1)) {
58320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
58321 }
58322 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58323 {
58324 PyThreadState* __tstate = wxPyBeginAllowThreads();
58325 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
58326 wxPyEndAllowThreads(__tstate);
58327 if (PyErr_Occurred()) SWIG_fail;
58328 }
58329 {
58330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
58331 }
58332 return resultobj;
58333 fail:
58334 return NULL;
58335 }
58336
58337
58338 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58339 PyObject *obj;
58340 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
58341 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
58342 return SWIG_Py_Void();
58343 }
58344
58345 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58346 return SWIG_Python_InitShadowInstance(args);
58347 }
58348
58349 static PyMethodDef SwigMethods[] = {
58350 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
58351 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
58352 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
58353 { (char *)"Object_IsSameAs", (PyCFunction) _wrap_Object_IsSameAs, METH_VARARGS | METH_KEYWORDS, NULL},
58354 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
58355 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
58356 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
58357 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
58358 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
58359 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
58360 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
58361 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58362 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58363 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
58364 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
58365 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
58366 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
58367 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
58368 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
58369 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
58370 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58371 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
58372 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
58373 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
58374 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
58375 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
58376 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
58377 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
58378 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
58379 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
58380 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
58381 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
58382 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
58383 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
58384 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
58385 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
58386 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58387 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58388 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
58389 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
58390 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58391 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
58392 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
58393 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
58394 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
58395 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
58396 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
58397 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
58398 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
58399 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
58400 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58401 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58402 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
58403 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
58404 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
58405 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
58406 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58407 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
58408 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
58409 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
58410 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
58411 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
58412 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
58413 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
58414 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
58415 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
58416 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
58417 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
58418 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
58419 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
58420 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
58421 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
58422 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
58423 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
58424 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58425 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
58426 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
58427 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
58428 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
58429 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
58430 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
58431 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
58432 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
58433 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
58434 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
58435 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
58436 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
58437 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
58438 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
58439 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
58440 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
58441 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
58442 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
58443 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
58444 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
58445 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
58446 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
58447 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
58448 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
58449 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
58450 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
58451 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
58452 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58453 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58454 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
58455 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
58456 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
58457 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
58458 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
58459 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
58460 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
58461 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
58462 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
58463 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
58464 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
58465 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
58466 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
58467 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58468 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
58469 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
58470 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
58471 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
58472 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
58473 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
58474 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
58475 { (char *)"delete_Point2D", (PyCFunction)_wrap_delete_Point2D, METH_O, NULL},
58476 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
58477 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
58478 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
58479 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
58480 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
58481 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
58482 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
58483 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
58484 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
58485 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
58486 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
58487 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
58488 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
58489 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
58490 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
58491 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58492 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58493 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
58494 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
58495 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
58496 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
58497 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58498 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
58499 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
58500 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
58501 { (char *)"new_Rect2D", (PyCFunction) _wrap_new_Rect2D, METH_VARARGS | METH_KEYWORDS, NULL},
58502 { (char *)"delete_Rect2D", (PyCFunction)_wrap_delete_Rect2D, METH_O, NULL},
58503 { (char *)"Rect2D_GetPosition", (PyCFunction)_wrap_Rect2D_GetPosition, METH_O, NULL},
58504 { (char *)"Rect2D_GetSize", (PyCFunction)_wrap_Rect2D_GetSize, METH_O, NULL},
58505 { (char *)"Rect2D_GetLeft", (PyCFunction)_wrap_Rect2D_GetLeft, METH_O, NULL},
58506 { (char *)"Rect2D_SetLeft", (PyCFunction) _wrap_Rect2D_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
58507 { (char *)"Rect2D_MoveLeftTo", (PyCFunction) _wrap_Rect2D_MoveLeftTo, METH_VARARGS | METH_KEYWORDS, NULL},
58508 { (char *)"Rect2D_GetTop", (PyCFunction)_wrap_Rect2D_GetTop, METH_O, NULL},
58509 { (char *)"Rect2D_SetTop", (PyCFunction) _wrap_Rect2D_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
58510 { (char *)"Rect2D_MoveTopTo", (PyCFunction) _wrap_Rect2D_MoveTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
58511 { (char *)"Rect2D_GetBottom", (PyCFunction)_wrap_Rect2D_GetBottom, METH_O, NULL},
58512 { (char *)"Rect2D_SetBottom", (PyCFunction) _wrap_Rect2D_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
58513 { (char *)"Rect2D_MoveBottomTo", (PyCFunction) _wrap_Rect2D_MoveBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
58514 { (char *)"Rect2D_GetRight", (PyCFunction)_wrap_Rect2D_GetRight, METH_O, NULL},
58515 { (char *)"Rect2D_SetRight", (PyCFunction) _wrap_Rect2D_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
58516 { (char *)"Rect2D_MoveRightTo", (PyCFunction) _wrap_Rect2D_MoveRightTo, METH_VARARGS | METH_KEYWORDS, NULL},
58517 { (char *)"Rect2D_GetLeftTop", (PyCFunction)_wrap_Rect2D_GetLeftTop, METH_O, NULL},
58518 { (char *)"Rect2D_SetLeftTop", (PyCFunction) _wrap_Rect2D_SetLeftTop, METH_VARARGS | METH_KEYWORDS, NULL},
58519 { (char *)"Rect2D_MoveLeftTopTo", (PyCFunction) _wrap_Rect2D_MoveLeftTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
58520 { (char *)"Rect2D_GetLeftBottom", (PyCFunction)_wrap_Rect2D_GetLeftBottom, METH_O, NULL},
58521 { (char *)"Rect2D_SetLeftBottom", (PyCFunction) _wrap_Rect2D_SetLeftBottom, METH_VARARGS | METH_KEYWORDS, NULL},
58522 { (char *)"Rect2D_MoveLeftBottomTo", (PyCFunction) _wrap_Rect2D_MoveLeftBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
58523 { (char *)"Rect2D_GetRightTop", (PyCFunction)_wrap_Rect2D_GetRightTop, METH_O, NULL},
58524 { (char *)"Rect2D_SetRightTop", (PyCFunction) _wrap_Rect2D_SetRightTop, METH_VARARGS | METH_KEYWORDS, NULL},
58525 { (char *)"Rect2D_MoveRightTopTo", (PyCFunction) _wrap_Rect2D_MoveRightTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
58526 { (char *)"Rect2D_GetRightBottom", (PyCFunction)_wrap_Rect2D_GetRightBottom, METH_O, NULL},
58527 { (char *)"Rect2D_SetRightBottom", (PyCFunction) _wrap_Rect2D_SetRightBottom, METH_VARARGS | METH_KEYWORDS, NULL},
58528 { (char *)"Rect2D_MoveRightBottomTo", (PyCFunction) _wrap_Rect2D_MoveRightBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
58529 { (char *)"Rect2D_GetCentre", (PyCFunction)_wrap_Rect2D_GetCentre, METH_O, NULL},
58530 { (char *)"Rect2D_SetCentre", (PyCFunction) _wrap_Rect2D_SetCentre, METH_VARARGS | METH_KEYWORDS, NULL},
58531 { (char *)"Rect2D_MoveCentreTo", (PyCFunction) _wrap_Rect2D_MoveCentreTo, METH_VARARGS | METH_KEYWORDS, NULL},
58532 { (char *)"Rect2D_GetOutcode", (PyCFunction) _wrap_Rect2D_GetOutcode, METH_VARARGS | METH_KEYWORDS, NULL},
58533 { (char *)"Rect2D_Contains", (PyCFunction) _wrap_Rect2D_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
58534 { (char *)"Rect2D_ContainsRect", (PyCFunction) _wrap_Rect2D_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
58535 { (char *)"Rect2D_IsEmpty", (PyCFunction)_wrap_Rect2D_IsEmpty, METH_O, NULL},
58536 { (char *)"Rect2D_HaveEqualSize", (PyCFunction) _wrap_Rect2D_HaveEqualSize, METH_VARARGS | METH_KEYWORDS, NULL},
58537 { (char *)"Rect2D_Inset", _wrap_Rect2D_Inset, METH_VARARGS, NULL},
58538 { (char *)"Rect2D_Offset", (PyCFunction) _wrap_Rect2D_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
58539 { (char *)"Rect2D_ConstrainTo", (PyCFunction) _wrap_Rect2D_ConstrainTo, METH_VARARGS | METH_KEYWORDS, NULL},
58540 { (char *)"Rect2D_Interpolate", (PyCFunction) _wrap_Rect2D_Interpolate, METH_VARARGS | METH_KEYWORDS, NULL},
58541 { (char *)"Rect2D_Intersect", (PyCFunction) _wrap_Rect2D_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
58542 { (char *)"Rect2D_CreateIntersection", (PyCFunction) _wrap_Rect2D_CreateIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
58543 { (char *)"Rect2D_Intersects", (PyCFunction) _wrap_Rect2D_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
58544 { (char *)"Rect2D_Union", (PyCFunction) _wrap_Rect2D_Union, METH_VARARGS | METH_KEYWORDS, NULL},
58545 { (char *)"Rect2D_CreateUnion", (PyCFunction) _wrap_Rect2D_CreateUnion, METH_VARARGS | METH_KEYWORDS, NULL},
58546 { (char *)"Rect2D_Scale", _wrap_Rect2D_Scale, METH_VARARGS, NULL},
58547 { (char *)"Rect2D___eq__", (PyCFunction) _wrap_Rect2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58548 { (char *)"Rect2D___ne__", (PyCFunction) _wrap_Rect2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58549 { (char *)"Rect2D_x_set", _wrap_Rect2D_x_set, METH_VARARGS, NULL},
58550 { (char *)"Rect2D_x_get", (PyCFunction)_wrap_Rect2D_x_get, METH_O, NULL},
58551 { (char *)"Rect2D_y_set", _wrap_Rect2D_y_set, METH_VARARGS, NULL},
58552 { (char *)"Rect2D_y_get", (PyCFunction)_wrap_Rect2D_y_get, METH_O, NULL},
58553 { (char *)"Rect2D_width_set", _wrap_Rect2D_width_set, METH_VARARGS, NULL},
58554 { (char *)"Rect2D_width_get", (PyCFunction)_wrap_Rect2D_width_get, METH_O, NULL},
58555 { (char *)"Rect2D_height_set", _wrap_Rect2D_height_set, METH_VARARGS, NULL},
58556 { (char *)"Rect2D_height_get", (PyCFunction)_wrap_Rect2D_height_get, METH_O, NULL},
58557 { (char *)"Rect2D_Set", (PyCFunction) _wrap_Rect2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58558 { (char *)"Rect2D_Get", (PyCFunction)_wrap_Rect2D_Get, METH_O, NULL},
58559 { (char *)"Rect2D_swigregister", Rect2D_swigregister, METH_VARARGS, NULL},
58560 { (char *)"Rect2D_swiginit", Rect2D_swiginit, METH_VARARGS, NULL},
58561 { (char *)"new_Position", (PyCFunction) _wrap_new_Position, METH_VARARGS | METH_KEYWORDS, NULL},
58562 { (char *)"delete_Position", (PyCFunction)_wrap_delete_Position, METH_O, NULL},
58563 { (char *)"Position_GetRow", (PyCFunction)_wrap_Position_GetRow, METH_O, NULL},
58564 { (char *)"Position_GetColumn", (PyCFunction)_wrap_Position_GetColumn, METH_O, NULL},
58565 { (char *)"Position_GetCol", (PyCFunction)_wrap_Position_GetCol, METH_O, NULL},
58566 { (char *)"Position_SetRow", (PyCFunction) _wrap_Position_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
58567 { (char *)"Position_SetColumn", (PyCFunction) _wrap_Position_SetColumn, METH_VARARGS | METH_KEYWORDS, NULL},
58568 { (char *)"Position_SetCol", (PyCFunction) _wrap_Position_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
58569 { (char *)"Position___eq__", (PyCFunction) _wrap_Position___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58570 { (char *)"Position___ne__", (PyCFunction) _wrap_Position___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58571 { (char *)"Position___add__", _wrap_Position___add__, METH_VARARGS, NULL},
58572 { (char *)"Position___sub__", _wrap_Position___sub__, METH_VARARGS, NULL},
58573 { (char *)"Position_swigregister", Position_swigregister, METH_VARARGS, NULL},
58574 { (char *)"Position_swiginit", Position_swiginit, METH_VARARGS, NULL},
58575 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
58576 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
58577 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
58578 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
58579 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
58580 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
58581 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
58582 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
58583 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
58584 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
58585 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
58586 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
58587 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
58588 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
58589 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
58590 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
58591 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
58592 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
58593 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
58594 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
58595 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
58596 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
58597 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
58598 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
58599 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
58600 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
58601 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
58602 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
58603 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
58604 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
58605 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
58606 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
58607 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
58608 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
58609 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
58610 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
58611 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
58612 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
58613 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58614 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
58615 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
58616 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
58617 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
58618 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
58619 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
58620 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
58621 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
58622 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
58623 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
58624 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
58625 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
58626 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
58627 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58628 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
58629 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
58630 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58631 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58632 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
58633 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
58634 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
58635 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
58636 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
58637 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
58638 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
58639 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58640 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
58641 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
58642 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
58643 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
58644 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58645 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
58646 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
58647 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
58648 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
58649 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
58650 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58651 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
58652 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
58653 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
58654 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
58655 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58656 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
58657 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
58658 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
58659 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
58660 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
58661 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
58662 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
58663 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
58664 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
58665 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
58666 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
58667 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
58668 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
58669 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
58670 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
58671 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
58672 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
58673 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
58674 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
58675 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
58676 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
58677 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
58678 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
58679 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
58680 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
58681 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
58682 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
58683 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
58684 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
58685 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
58686 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
58687 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
58688 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
58689 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
58690 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
58691 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
58692 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
58693 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
58694 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
58695 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
58696 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
58697 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
58698 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
58699 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
58700 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
58701 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
58702 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
58703 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
58704 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
58705 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
58706 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
58707 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58708 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
58709 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58710 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
58711 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
58712 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
58713 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
58714 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
58715 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
58716 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
58717 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
58718 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
58719 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
58720 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
58721 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
58722 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
58723 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
58724 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
58725 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
58726 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58727 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58728 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
58729 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
58730 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
58731 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
58732 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
58733 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58734 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
58735 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
58736 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
58737 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
58738 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
58739 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
58740 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
58741 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
58742 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
58743 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
58744 { (char *)"Image_IsOk", (PyCFunction)_wrap_Image_IsOk, METH_O, NULL},
58745 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
58746 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
58747 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
58748 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
58749 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
58750 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
58751 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
58752 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
58753 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
58754 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
58755 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
58756 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
58757 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
58758 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
58759 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
58760 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
58761 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
58762 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
58763 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
58764 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
58765 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
58766 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
58767 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
58768 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
58769 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
58770 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
58771 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
58772 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
58773 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
58774 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
58775 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
58776 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
58777 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
58778 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
58779 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
58780 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58781 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58782 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58783 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
58784 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
58785 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58786 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58787 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
58788 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
58789 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
58790 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
58791 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
58792 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
58793 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
58794 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
58795 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
58796 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
58797 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
58798 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
58799 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
58800 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
58801 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
58802 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
58803 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
58804 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
58805 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
58806 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
58807 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
58808 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
58809 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
58810 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
58811 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
58812 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
58813 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
58814 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
58815 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
58816 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
58817 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
58818 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
58819 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
58820 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
58821 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
58822 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
58823 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
58824 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
58825 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
58826 { (char *)"new_TGAHandler", (PyCFunction)_wrap_new_TGAHandler, METH_NOARGS, NULL},
58827 { (char *)"TGAHandler_swigregister", TGAHandler_swigregister, METH_VARARGS, NULL},
58828 { (char *)"TGAHandler_swiginit", TGAHandler_swiginit, METH_VARARGS, NULL},
58829 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
58830 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
58831 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
58832 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
58833 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
58834 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58835 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58836 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
58837 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
58838 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58839 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58840 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
58841 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
58842 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
58843 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
58844 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
58845 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
58846 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
58847 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
58848 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
58849 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
58850 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
58851 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
58852 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
58853 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
58854 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
58855 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
58856 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
58857 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
58858 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
58859 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
58860 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
58861 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
58862 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
58863 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
58864 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
58865 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
58866 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
58867 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
58868 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
58869 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
58870 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
58871 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
58872 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58873 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
58874 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
58875 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
58876 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
58877 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
58878 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
58879 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
58880 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
58881 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
58882 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
58883 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
58884 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
58885 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
58886 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
58887 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58888 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
58889 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
58890 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
58891 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
58892 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
58893 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58894 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
58895 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
58896 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
58897 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58898 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
58899 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
58900 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58901 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
58902 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
58903 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
58904 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58905 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
58906 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
58907 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58908 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
58909 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
58910 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
58911 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
58912 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
58913 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
58914 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
58915 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
58916 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
58917 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
58918 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
58919 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
58920 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
58921 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
58922 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
58923 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
58924 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
58925 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
58926 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
58927 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
58928 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
58929 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
58930 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
58931 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
58932 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
58933 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
58934 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
58935 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
58936 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
58937 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
58938 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58939 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
58940 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
58941 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
58942 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
58943 { (char *)"MouseEvent_GetWheelAxis", (PyCFunction)_wrap_MouseEvent_GetWheelAxis, METH_O, NULL},
58944 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
58945 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
58946 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
58947 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
58948 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
58949 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
58950 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
58951 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
58952 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
58953 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
58954 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
58955 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
58956 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
58957 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
58958 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
58959 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
58960 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
58961 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
58962 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
58963 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
58964 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
58965 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
58966 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
58967 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
58968 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
58969 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
58970 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
58971 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
58972 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58973 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
58974 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
58975 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
58976 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
58977 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
58978 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
58979 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
58980 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58981 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
58982 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
58983 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
58984 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
58985 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
58986 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
58987 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
58988 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
58989 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
58990 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
58991 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
58992 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
58993 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
58994 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
58995 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
58996 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
58997 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
58998 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
58999 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
59000 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
59001 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
59002 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
59003 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
59004 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
59005 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
59006 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
59007 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
59008 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
59009 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
59010 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
59011 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
59012 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
59013 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
59014 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
59015 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
59016 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
59017 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
59018 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
59019 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59020 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
59021 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
59022 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
59023 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
59024 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
59025 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
59026 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
59027 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
59028 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
59029 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
59030 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59031 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
59032 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
59033 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
59034 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59035 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
59036 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
59037 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59038 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
59039 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
59040 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59041 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
59042 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
59043 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59044 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
59045 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
59046 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
59047 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59048 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
59049 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59050 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
59051 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
59052 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59053 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
59054 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
59055 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
59056 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59057 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
59058 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
59059 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
59060 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59061 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
59062 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
59063 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59064 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
59065 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
59066 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
59067 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
59068 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
59069 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59070 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
59071 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
59072 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
59073 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
59074 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
59075 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
59076 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
59077 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
59078 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59079 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
59080 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
59081 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
59082 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
59083 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59084 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
59085 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
59086 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
59087 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59088 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
59089 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
59090 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
59091 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
59092 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
59093 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
59094 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59095 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
59096 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
59097 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
59098 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
59099 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
59100 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
59101 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
59102 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
59103 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
59104 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
59105 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
59106 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
59107 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
59108 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
59109 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
59110 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
59111 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
59112 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
59113 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
59114 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
59115 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
59116 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
59117 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
59118 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59119 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
59120 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
59121 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
59122 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59123 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
59124 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
59125 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
59126 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
59127 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
59128 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59129 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59130 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
59131 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
59132 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
59133 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59134 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
59135 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
59136 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
59137 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
59138 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
59139 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
59140 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
59141 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
59142 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
59143 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
59144 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
59145 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
59146 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
59147 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
59148 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
59149 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
59150 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59151 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
59152 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
59153 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
59154 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59155 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
59156 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
59157 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
59158 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59159 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
59160 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59161 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
59162 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
59163 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
59164 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
59165 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
59166 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
59167 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
59168 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
59169 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
59170 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
59171 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59172 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
59173 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
59174 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59175 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
59176 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
59177 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
59178 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
59179 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
59180 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59181 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
59182 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
59183 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
59184 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
59185 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
59186 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59187 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
59188 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
59189 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
59190 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
59191 { (char *)"new_EventBlocker", (PyCFunction) _wrap_new_EventBlocker, METH_VARARGS | METH_KEYWORDS, NULL},
59192 { (char *)"delete_EventBlocker", (PyCFunction)_wrap_delete_EventBlocker, METH_O, NULL},
59193 { (char *)"EventBlocker_Block", (PyCFunction) _wrap_EventBlocker_Block, METH_VARARGS | METH_KEYWORDS, NULL},
59194 { (char *)"EventBlocker_swigregister", EventBlocker_swigregister, METH_VARARGS, NULL},
59195 { (char *)"EventBlocker_swiginit", EventBlocker_swiginit, METH_VARARGS, NULL},
59196 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
59197 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
59198 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
59199 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
59200 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
59201 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
59202 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
59203 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
59204 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
59205 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
59206 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
59207 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
59208 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
59209 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
59210 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
59211 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
59212 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
59213 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
59214 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
59215 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
59216 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
59217 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
59218 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
59219 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59220 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
59221 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
59222 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
59223 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
59224 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
59225 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
59226 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
59227 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
59228 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
59229 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
59230 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
59231 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
59232 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
59233 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
59234 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
59235 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
59236 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
59237 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
59238 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
59239 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
59240 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
59241 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
59242 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
59243 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
59244 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
59245 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
59246 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
59247 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
59248 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
59249 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59250 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
59251 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
59252 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
59253 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
59254 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
59255 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
59256 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
59257 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
59258 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
59259 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
59260 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
59261 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
59262 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
59263 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
59264 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
59265 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
59266 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
59267 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
59268 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
59269 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
59270 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
59271 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
59272 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
59273 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
59274 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
59275 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
59276 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
59277 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
59278 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
59279 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
59280 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
59281 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
59282 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
59283 { (char *)"AcceleratorTable_IsOk", (PyCFunction)_wrap_AcceleratorTable_IsOk, METH_O, NULL},
59284 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
59285 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
59286 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
59287 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
59288 { (char *)"VisualAttributes__get_font", (PyCFunction)_wrap_VisualAttributes__get_font, METH_O, NULL},
59289 { (char *)"VisualAttributes__get_colFg", (PyCFunction)_wrap_VisualAttributes__get_colFg, METH_O, NULL},
59290 { (char *)"VisualAttributes__get_colBg", (PyCFunction)_wrap_VisualAttributes__get_colBg, METH_O, NULL},
59291 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
59292 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
59293 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
59294 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
59295 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
59296 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
59297 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
59298 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
59299 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
59300 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59301 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
59302 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
59303 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
59304 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
59305 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
59306 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
59307 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
59308 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
59309 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
59310 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
59311 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
59312 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
59313 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
59314 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
59315 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
59316 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
59317 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
59318 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
59319 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
59320 { (char *)"Window_SetInitialSize", (PyCFunction) _wrap_Window_SetInitialSize, METH_VARARGS | METH_KEYWORDS, NULL},
59321 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
59322 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
59323 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
59324 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
59325 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
59326 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
59327 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
59328 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
59329 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
59330 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
59331 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
59332 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
59333 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
59334 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
59335 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
59336 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
59337 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
59338 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
59339 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
59340 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
59341 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
59342 { (char *)"Window_GetEffectiveMinSize", (PyCFunction)_wrap_Window_GetEffectiveMinSize, METH_O, NULL},
59343 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
59344 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
59345 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
59346 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
59347 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
59348 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
59349 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
59350 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
59351 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
59352 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
59353 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
59354 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
59355 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
59356 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
59357 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
59358 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
59359 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
59360 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
59361 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
59362 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
59363 { (char *)"Window_GetWindowBorderSize", (PyCFunction)_wrap_Window_GetWindowBorderSize, METH_O, NULL},
59364 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
59365 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
59366 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
59367 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
59368 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
59369 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
59370 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
59371 { (char *)"Window_IsThisEnabled", (PyCFunction)_wrap_Window_IsThisEnabled, METH_O, NULL},
59372 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
59373 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
59374 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
59375 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
59376 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
59377 { (char *)"Window_ToggleWindowStyle", (PyCFunction) _wrap_Window_ToggleWindowStyle, METH_VARARGS | METH_KEYWORDS, NULL},
59378 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
59379 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
59380 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
59381 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
59382 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
59383 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
59384 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
59385 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
59386 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
59387 { (char *)"Window_CanAcceptFocus", (PyCFunction)_wrap_Window_CanAcceptFocus, METH_O, NULL},
59388 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
59389 { (char *)"Window_CanAcceptFocusFromKeyboard", (PyCFunction)_wrap_Window_CanAcceptFocusFromKeyboard, METH_O, NULL},
59390 { (char *)"Window_SetCanFocus", (PyCFunction) _wrap_Window_SetCanFocus, METH_VARARGS | METH_KEYWORDS, NULL},
59391 { (char *)"Window_NavigateIn", (PyCFunction) _wrap_Window_NavigateIn, METH_VARARGS | METH_KEYWORDS, NULL},
59392 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
59393 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
59394 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
59395 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
59396 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
59397 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
59398 { (char *)"Window_GetTopLevelParent", (PyCFunction)_wrap_Window_GetTopLevelParent, METH_O, NULL},
59399 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
59400 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
59401 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
59402 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
59403 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
59404 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
59405 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
59406 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
59407 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
59408 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
59409 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
59410 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
59411 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
59412 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
59413 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
59414 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
59415 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
59416 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
59417 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
59418 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
59419 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
59420 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
59421 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
59422 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
59423 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
59424 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
59425 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
59426 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
59427 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
59428 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
59429 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
59430 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
59431 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
59432 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
59433 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
59434 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
59435 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
59436 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
59437 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
59438 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
59439 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
59440 { (char *)"Window_IsDoubleBuffered", (PyCFunction)_wrap_Window_IsDoubleBuffered, METH_O, NULL},
59441 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
59442 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
59443 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
59444 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
59445 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
59446 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
59447 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
59448 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
59449 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
59450 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
59451 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
59452 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
59453 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
59454 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
59455 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
59456 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
59457 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
59458 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
59459 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
59460 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
59461 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
59462 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
59463 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
59464 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
59465 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
59466 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
59467 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
59468 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
59469 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
59470 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
59471 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
59472 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
59473 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
59474 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
59475 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
59476 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
59477 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
59478 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
59479 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59480 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
59481 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
59482 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
59483 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
59484 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
59485 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
59486 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
59487 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
59488 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
59489 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
59490 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59491 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
59492 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
59493 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
59494 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
59495 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
59496 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
59497 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
59498 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
59499 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
59500 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
59501 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
59502 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
59503 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
59504 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
59505 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
59506 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
59507 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
59508 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
59509 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
59510 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
59511 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
59512 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59513 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
59514 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
59515 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59516 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
59517 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
59518 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
59519 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
59520 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
59521 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
59522 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
59523 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
59524 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
59525 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59526 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
59527 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
59528 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
59529 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
59530 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
59531 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
59532 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
59533 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
59534 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59535 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
59536 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
59537 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
59538 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
59539 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
59540 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
59541 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
59542 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
59543 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
59544 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
59545 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
59546 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
59547 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
59548 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59549 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59550 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
59551 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
59552 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
59553 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
59554 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
59555 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
59556 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
59557 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
59558 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59559 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
59560 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
59561 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
59562 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
59563 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59564 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
59565 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
59566 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
59567 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
59568 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
59569 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
59570 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
59571 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
59572 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
59573 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
59574 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
59575 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59576 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
59577 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
59578 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
59579 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
59580 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59581 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59582 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
59583 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
59584 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
59585 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
59586 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
59587 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
59588 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59589 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
59590 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
59591 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
59592 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
59593 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
59594 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
59595 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
59596 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
59597 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
59598 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
59599 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
59600 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
59601 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
59602 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
59603 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
59604 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59605 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
59606 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
59607 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
59608 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
59609 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
59610 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
59611 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
59612 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
59613 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59614 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
59615 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
59616 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
59617 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
59618 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59619 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59620 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
59621 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
59622 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
59623 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
59624 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
59625 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
59626 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
59627 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59628 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
59629 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
59630 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
59631 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
59632 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
59633 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
59634 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59635 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
59636 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
59637 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
59638 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
59639 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
59640 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
59641 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
59642 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
59643 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
59644 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
59645 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
59646 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
59647 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59648 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
59649 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
59650 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
59651 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
59652 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
59653 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
59654 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
59655 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
59656 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
59657 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
59658 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
59659 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
59660 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
59661 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
59662 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
59663 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
59664 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
59665 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
59666 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
59667 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
59668 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
59669 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
59670 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
59671 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
59672 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
59673 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
59674 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
59675 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
59676 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
59677 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
59678 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
59679 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
59680 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
59681 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
59682 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
59683 { (char *)"Control_RemoveMnemonics", (PyCFunction) _wrap_Control_RemoveMnemonics, METH_VARARGS | METH_KEYWORDS, NULL},
59684 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
59685 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
59686 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
59687 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
59688 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
59689 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
59690 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
59691 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
59692 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
59693 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
59694 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
59695 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
59696 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
59697 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
59698 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
59699 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
59700 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
59701 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
59702 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
59703 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
59704 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
59705 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
59706 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
59707 { (char *)"new_SizerFlags", (PyCFunction) _wrap_new_SizerFlags, METH_VARARGS | METH_KEYWORDS, NULL},
59708 { (char *)"delete_SizerFlags", (PyCFunction)_wrap_delete_SizerFlags, METH_O, NULL},
59709 { (char *)"SizerFlags_Proportion", (PyCFunction) _wrap_SizerFlags_Proportion, METH_VARARGS | METH_KEYWORDS, NULL},
59710 { (char *)"SizerFlags_Align", (PyCFunction) _wrap_SizerFlags_Align, METH_VARARGS | METH_KEYWORDS, NULL},
59711 { (char *)"SizerFlags_Expand", (PyCFunction)_wrap_SizerFlags_Expand, METH_O, NULL},
59712 { (char *)"SizerFlags_Centre", (PyCFunction)_wrap_SizerFlags_Centre, METH_O, NULL},
59713 { (char *)"SizerFlags_Center", (PyCFunction)_wrap_SizerFlags_Center, METH_O, NULL},
59714 { (char *)"SizerFlags_Left", (PyCFunction)_wrap_SizerFlags_Left, METH_O, NULL},
59715 { (char *)"SizerFlags_Right", (PyCFunction)_wrap_SizerFlags_Right, METH_O, NULL},
59716 { (char *)"SizerFlags_Top", (PyCFunction)_wrap_SizerFlags_Top, METH_O, NULL},
59717 { (char *)"SizerFlags_Bottom", (PyCFunction)_wrap_SizerFlags_Bottom, METH_O, NULL},
59718 { (char *)"SizerFlags_Shaped", (PyCFunction)_wrap_SizerFlags_Shaped, METH_O, NULL},
59719 { (char *)"SizerFlags_FixedMinSize", (PyCFunction)_wrap_SizerFlags_FixedMinSize, METH_O, NULL},
59720 { (char *)"SizerFlags_Border", (PyCFunction) _wrap_SizerFlags_Border, METH_VARARGS | METH_KEYWORDS, NULL},
59721 { (char *)"SizerFlags_DoubleBorder", (PyCFunction) _wrap_SizerFlags_DoubleBorder, METH_VARARGS | METH_KEYWORDS, NULL},
59722 { (char *)"SizerFlags_TripleBorder", (PyCFunction) _wrap_SizerFlags_TripleBorder, METH_VARARGS | METH_KEYWORDS, NULL},
59723 { (char *)"SizerFlags_HorzBorder", (PyCFunction)_wrap_SizerFlags_HorzBorder, METH_O, NULL},
59724 { (char *)"SizerFlags_DoubleHorzBorder", (PyCFunction)_wrap_SizerFlags_DoubleHorzBorder, METH_O, NULL},
59725 { (char *)"SizerFlags_GetDefaultBorder", (PyCFunction)_wrap_SizerFlags_GetDefaultBorder, METH_NOARGS, NULL},
59726 { (char *)"SizerFlags_GetProportion", (PyCFunction)_wrap_SizerFlags_GetProportion, METH_O, NULL},
59727 { (char *)"SizerFlags_GetFlags", (PyCFunction)_wrap_SizerFlags_GetFlags, METH_O, NULL},
59728 { (char *)"SizerFlags_GetBorderInPixels", (PyCFunction)_wrap_SizerFlags_GetBorderInPixels, METH_O, NULL},
59729 { (char *)"SizerFlags_swigregister", SizerFlags_swigregister, METH_VARARGS, NULL},
59730 { (char *)"SizerFlags_swiginit", SizerFlags_swiginit, METH_VARARGS, NULL},
59731 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
59732 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
59733 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59734 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59735 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59736 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
59737 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
59738 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
59739 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
59740 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
59741 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
59742 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
59743 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
59744 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
59745 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
59746 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
59747 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
59748 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
59749 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
59750 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
59751 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
59752 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
59753 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
59754 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
59755 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
59756 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
59757 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
59758 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
59759 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
59760 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
59761 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59762 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59763 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59764 { (char *)"SizerItem_AssignWindow", (PyCFunction) _wrap_SizerItem_AssignWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59765 { (char *)"SizerItem_AssignSizer", (PyCFunction) _wrap_SizerItem_AssignSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59766 { (char *)"SizerItem_AssignSpacer", (PyCFunction) _wrap_SizerItem_AssignSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59767 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
59768 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
59769 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
59770 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
59771 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
59772 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
59773 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
59774 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
59775 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
59776 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
59777 { (char *)"Sizer_AddF", (PyCFunction) _wrap_Sizer_AddF, METH_VARARGS | METH_KEYWORDS, NULL},
59778 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
59779 { (char *)"Sizer_InsertF", (PyCFunction) _wrap_Sizer_InsertF, METH_VARARGS | METH_KEYWORDS, NULL},
59780 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
59781 { (char *)"Sizer_PrependF", (PyCFunction) _wrap_Sizer_PrependF, METH_VARARGS | METH_KEYWORDS, NULL},
59782 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
59783 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
59784 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
59785 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
59786 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
59787 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59788 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
59789 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59790 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
59791 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
59792 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
59793 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
59794 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
59795 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
59796 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
59797 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
59798 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
59799 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
59800 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
59801 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
59802 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
59803 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
59804 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
59805 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
59806 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
59807 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
59808 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
59809 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
59810 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
59811 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
59812 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
59813 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
59814 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
59815 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
59816 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
59817 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59818 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
59819 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
59820 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
59821 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
59822 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59823 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
59824 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
59825 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
59826 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59827 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
59828 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
59829 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
59830 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
59831 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
59832 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
59833 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
59834 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
59835 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
59836 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
59837 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59838 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
59839 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
59840 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
59841 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
59842 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
59843 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
59844 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
59845 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
59846 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
59847 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
59848 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
59849 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
59850 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
59851 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
59852 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
59853 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
59854 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
59855 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
59856 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
59857 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
59858 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
59859 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
59860 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
59861 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
59862 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
59863 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59864 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
59865 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
59866 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
59867 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
59868 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
59869 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
59870 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
59871 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
59872 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
59873 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
59874 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
59875 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
59876 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
59877 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
59878 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
59879 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
59880 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
59881 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
59882 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
59883 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
59884 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
59885 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
59886 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
59887 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
59888 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
59889 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59890 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59891 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59892 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
59893 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
59894 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
59895 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
59896 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
59897 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
59898 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
59899 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
59900 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59901 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
59902 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
59903 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59904 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
59905 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
59906 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
59907 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
59908 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
59909 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
59910 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
59911 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
59912 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
59913 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
59914 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59915 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
59916 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
59917 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
59918 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
59919 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
59920 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
59921 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
59922 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
59923 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
59924 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
59925 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
59926 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
59927 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
59928 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
59929 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
59930 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
59931 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
59932 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
59933 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
59934 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
59935 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
59936 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
59937 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
59938 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
59939 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
59940 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
59941 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
59942 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
59943 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
59944 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
59945 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
59946 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
59947 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
59948 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
59949 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
59950 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
59951 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
59952 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
59953 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
59954 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
59955 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
59956 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
59957 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
59958 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
59959 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
59960 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
59961 { NULL, NULL, 0, NULL }
59962 };
59963
59964
59965 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
59966
59967 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
59968 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
59969 }
59970 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
59971 return (void *)((wxEvent *) ((wxMenuEvent *) x));
59972 }
59973 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
59974 return (void *)((wxEvent *) ((wxCloseEvent *) x));
59975 }
59976 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
59977 return (void *)((wxEvent *) ((wxMouseEvent *) x));
59978 }
59979 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
59980 return (void *)((wxEvent *) ((wxEraseEvent *) x));
59981 }
59982 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
59983 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
59984 }
59985 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
59986 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
59987 }
59988 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
59989 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
59990 }
59991 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
59992 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
59993 }
59994 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
59995 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
59996 }
59997 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
59998 return (void *)((wxEvent *) ((wxPyEvent *) x));
59999 }
60000 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
60001 return (void *)((wxEvent *) ((wxIdleEvent *) x));
60002 }
60003 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
60004 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
60005 }
60006 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
60007 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
60008 }
60009 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
60010 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
60011 }
60012 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
60013 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
60014 }
60015 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
60016 return (void *)((wxEvent *) ((wxActivateEvent *) x));
60017 }
60018 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
60019 return (void *)((wxEvent *) ((wxSizeEvent *) x));
60020 }
60021 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
60022 return (void *)((wxEvent *) ((wxMoveEvent *) x));
60023 }
60024 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
60025 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
60026 }
60027 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
60028 return (void *)((wxEvent *) ((wxPaintEvent *) x));
60029 }
60030 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
60031 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
60032 }
60033 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
60034 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
60035 }
60036 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
60037 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
60038 }
60039 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
60040 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
60041 }
60042 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
60043 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
60044 }
60045 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
60046 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
60047 }
60048 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
60049 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
60050 }
60051 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
60052 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
60053 }
60054 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
60055 return (void *)((wxEvent *) ((wxFocusEvent *) x));
60056 }
60057 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
60058 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
60059 }
60060 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
60061 return (void *)((wxEvent *) ((wxShowEvent *) x));
60062 }
60063 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
60064 return (void *)((wxEvent *) ((wxCommandEvent *) x));
60065 }
60066 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
60067 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
60068 }
60069 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
60070 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
60071 }
60072 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
60073 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
60074 }
60075 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
60076 return (void *)((wxEvent *) ((wxKeyEvent *) x));
60077 }
60078 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
60079 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
60080 }
60081 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
60082 return (void *)((wxValidator *) ((wxPyValidator *) x));
60083 }
60084 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
60085 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
60086 }
60087 static void *_p_wxEventBlockerTo_p_wxObject(void *x) {
60088 return (void *)((wxObject *) (wxEvtHandler *) ((wxEventBlocker *) x));
60089 }
60090 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
60091 return (void *)((wxObject *) ((wxSizerItem *) x));
60092 }
60093 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
60094 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
60095 }
60096 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
60097 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
60098 }
60099 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
60100 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
60101 }
60102 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
60103 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
60104 }
60105 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
60106 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
60107 }
60108 static void *_p_wxSizerTo_p_wxObject(void *x) {
60109 return (void *)((wxObject *) ((wxSizer *) x));
60110 }
60111 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
60112 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
60113 }
60114 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
60115 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
60116 }
60117 static void *_p_wxEventTo_p_wxObject(void *x) {
60118 return (void *)((wxObject *) ((wxEvent *) x));
60119 }
60120 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
60121 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
60122 }
60123 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
60124 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
60125 }
60126 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
60127 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
60128 }
60129 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
60130 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
60131 }
60132 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
60133 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
60134 }
60135 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
60136 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
60137 }
60138 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
60139 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
60140 }
60141 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
60142 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
60143 }
60144 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
60145 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
60146 }
60147 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
60148 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
60149 }
60150 static void *_p_wxControlTo_p_wxObject(void *x) {
60151 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
60152 }
60153 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
60154 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
60155 }
60156 static void *_p_wxFSFileTo_p_wxObject(void *x) {
60157 return (void *)((wxObject *) ((wxFSFile *) x));
60158 }
60159 static void *_p_wxPySizerTo_p_wxObject(void *x) {
60160 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
60161 }
60162 static void *_p_wxPyEventTo_p_wxObject(void *x) {
60163 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
60164 }
60165 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
60166 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
60167 }
60168 static void *_p_wxShowEventTo_p_wxObject(void *x) {
60169 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
60170 }
60171 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
60172 return (void *)((wxObject *) ((wxMenuItem *) x));
60173 }
60174 static void *_p_wxDateEventTo_p_wxObject(void *x) {
60175 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
60176 }
60177 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
60178 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
60179 }
60180 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
60181 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
60182 }
60183 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
60184 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
60185 }
60186 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
60187 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
60188 }
60189 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
60190 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
60191 }
60192 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
60193 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
60194 }
60195 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
60196 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
60197 }
60198 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
60199 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
60200 }
60201 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
60202 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
60203 }
60204 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
60205 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
60206 }
60207 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
60208 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
60209 }
60210 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
60211 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
60212 }
60213 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
60214 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
60215 }
60216 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
60217 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
60218 }
60219 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
60220 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
60221 }
60222 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
60223 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
60224 }
60225 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
60226 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
60227 }
60228 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
60229 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
60230 }
60231 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
60232 return (void *)((wxObject *) ((wxImageHandler *) x));
60233 }
60234 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
60235 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
60236 }
60237 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
60238 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
60239 }
60240 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
60241 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
60242 }
60243 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
60244 return (void *)((wxObject *) ((wxEvtHandler *) x));
60245 }
60246 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
60247 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
60248 }
60249 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
60250 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
60251 }
60252 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
60253 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
60254 }
60255 static void *_p_wxImageTo_p_wxObject(void *x) {
60256 return (void *)((wxObject *) ((wxImage *) x));
60257 }
60258 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
60259 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
60260 }
60261 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
60262 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
60263 }
60264 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
60265 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
60266 }
60267 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
60268 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
60269 }
60270 static void *_p_wxWindowTo_p_wxObject(void *x) {
60271 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
60272 }
60273 static void *_p_wxMenuTo_p_wxObject(void *x) {
60274 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
60275 }
60276 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
60277 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
60278 }
60279 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
60280 return (void *)((wxObject *) ((wxFileSystem *) x));
60281 }
60282 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
60283 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
60284 }
60285 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
60286 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
60287 }
60288 static void *_p_wxPyAppTo_p_wxObject(void *x) {
60289 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
60290 }
60291 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
60292 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
60293 }
60294 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
60295 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
60296 }
60297 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
60298 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
60299 }
60300 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
60301 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
60302 }
60303 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
60304 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
60305 }
60306 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
60307 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
60308 }
60309 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
60310 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
60311 }
60312 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
60313 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
60314 }
60315 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
60316 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
60317 }
60318 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
60319 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
60320 }
60321 static void *_p_wxValidatorTo_p_wxObject(void *x) {
60322 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
60323 }
60324 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
60325 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
60326 }
60327 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
60328 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
60329 }
60330 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
60331 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
60332 }
60333 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
60334 return (void *)((wxControl *) ((wxControlWithItems *) x));
60335 }
60336 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
60337 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
60338 }
60339 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
60340 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
60341 }
60342 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
60343 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
60344 }
60345 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
60346 return (void *)((wxSizer *) ((wxBoxSizer *) x));
60347 }
60348 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
60349 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
60350 }
60351 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
60352 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
60353 }
60354 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
60355 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
60356 }
60357 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
60358 return (void *)((wxSizer *) ((wxGridSizer *) x));
60359 }
60360 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
60361 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
60362 }
60363 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
60364 return (void *)((wxSizer *) ((wxPySizer *) x));
60365 }
60366 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
60367 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
60368 }
60369 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
60370 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
60371 }
60372 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
60373 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
60374 }
60375 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
60376 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
60377 }
60378 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
60379 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
60380 }
60381 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
60382 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
60383 }
60384 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
60385 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
60386 }
60387 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
60388 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
60389 }
60390 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
60391 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
60392 }
60393 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
60394 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
60395 }
60396 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
60397 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
60398 }
60399 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
60400 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
60401 }
60402 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
60403 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
60404 }
60405 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
60406 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
60407 }
60408 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
60409 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
60410 }
60411 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
60412 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
60413 }
60414 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
60415 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
60416 }
60417 static void *_p_wxTGAHandlerTo_p_wxImageHandler(void *x) {
60418 return (void *)((wxImageHandler *) ((wxTGAHandler *) x));
60419 }
60420 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
60421 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
60422 }
60423 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
60424 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
60425 }
60426 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
60427 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
60428 }
60429 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
60430 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
60431 }
60432 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
60433 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
60434 }
60435 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
60436 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
60437 }
60438 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
60439 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
60440 }
60441 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
60442 return (void *)((wxEvtHandler *) ((wxWindow *) x));
60443 }
60444 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
60445 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
60446 }
60447 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
60448 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
60449 }
60450 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
60451 return (void *)((wxEvtHandler *) ((wxValidator *) x));
60452 }
60453 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
60454 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
60455 }
60456 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
60457 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
60458 }
60459 static void *_p_wxEventBlockerTo_p_wxEvtHandler(void *x) {
60460 return (void *)((wxEvtHandler *) ((wxEventBlocker *) x));
60461 }
60462 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
60463 return (void *)((wxEvtHandler *) ((wxMenu *) x));
60464 }
60465 static void *_p_wxControlTo_p_wxWindow(void *x) {
60466 return (void *)((wxWindow *) ((wxControl *) x));
60467 }
60468 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
60469 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
60470 }
60471 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
60472 return (void *)((wxWindow *) ((wxMenuBar *) x));
60473 }
60474 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
60475 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
60476 }
60477 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
60478 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
60479 }
60480 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
60481 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
60482 }
60483 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
60484 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
60485 }
60486 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
60487 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
60488 }
60489 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
60490 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
60491 }
60492 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
60493 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
60494 }
60495 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
60496 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
60497 }
60498 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
60499 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
60500 }
60501 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
60502 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
60503 }
60504 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
60505 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
60506 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};
60507 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
60508 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
60509 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
60510 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
60511 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
60512 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
60513 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
60514 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
60515 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
60516 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
60517 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
60518 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
60519 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
60520 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
60521 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
60522 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
60523 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
60524 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
60525 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
60526 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
60527 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
60528 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
60529 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
60530 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
60531 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
60532 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
60533 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
60534 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
60535 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
60536 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
60537 static swig_type_info _swigt__p_wxDouble = {"_p_wxDouble", "wxDouble *", 0, 0, (void*)0, 0};
60538 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
60539 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
60540 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
60541 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
60542 static swig_type_info _swigt__p_wxEventBlocker = {"_p_wxEventBlocker", "wxEventBlocker *", 0, 0, (void*)0, 0};
60543 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
60544 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
60545 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
60546 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
60547 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
60548 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
60549 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
60550 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
60551 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
60552 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
60553 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
60554 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
60555 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
60556 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
60557 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
60558 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
60559 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
60560 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
60561 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
60562 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
60563 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
60564 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
60565 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
60566 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
60567 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
60568 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
60569 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
60570 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
60571 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
60572 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
60573 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
60574 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
60575 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
60576 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
60577 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
60578 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
60579 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
60580 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
60581 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
60582 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
60583 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
60584 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
60585 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
60586 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
60587 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
60588 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
60589 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
60590 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
60591 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
60592 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
60593 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
60594 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
60595 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
60596 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
60597 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
60598 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
60599 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
60600 static swig_type_info _swigt__p_wxPosition = {"_p_wxPosition", "wxPosition *", 0, 0, (void*)0, 0};
60601 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
60602 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
60603 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
60604 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
60605 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
60606 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
60607 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
60608 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
60609 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
60610 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
60611 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
60612 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
60613 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
60614 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
60615 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
60616 static swig_type_info _swigt__p_wxRect2D = {"_p_wxRect2D", "wxRect2D *", 0, 0, (void*)0, 0};
60617 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
60618 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
60619 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
60620 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
60621 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
60622 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
60623 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
60624 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
60625 static swig_type_info _swigt__p_wxSizerFlags = {"_p_wxSizerFlags", "wxSizerFlags *", 0, 0, (void*)0, 0};
60626 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
60627 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
60628 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
60629 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
60630 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
60631 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", "wxTGAHandler *", 0, 0, (void*)0, 0};
60632 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
60633 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
60634 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
60635 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
60636 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
60637 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
60638 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
60639 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
60640 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
60641 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
60642
60643 static swig_type_info *swig_type_initial[] = {
60644 &_swigt__p_buffer,
60645 &_swigt__p_char,
60646 &_swigt__p_form_ops_t,
60647 &_swigt__p_int,
60648 &_swigt__p_long,
60649 &_swigt__p_unsigned_char,
60650 &_swigt__p_unsigned_int,
60651 &_swigt__p_unsigned_long,
60652 &_swigt__p_wxANIHandler,
60653 &_swigt__p_wxAcceleratorEntry,
60654 &_swigt__p_wxAcceleratorTable,
60655 &_swigt__p_wxActivateEvent,
60656 &_swigt__p_wxAppTraits,
60657 &_swigt__p_wxArrayString,
60658 &_swigt__p_wxBMPHandler,
60659 &_swigt__p_wxBitmap,
60660 &_swigt__p_wxBoxSizer,
60661 &_swigt__p_wxButton,
60662 &_swigt__p_wxCURHandler,
60663 &_swigt__p_wxCaret,
60664 &_swigt__p_wxChildFocusEvent,
60665 &_swigt__p_wxClipboardTextEvent,
60666 &_swigt__p_wxCloseEvent,
60667 &_swigt__p_wxColour,
60668 &_swigt__p_wxCommandEvent,
60669 &_swigt__p_wxContextMenuEvent,
60670 &_swigt__p_wxControl,
60671 &_swigt__p_wxControlWithItems,
60672 &_swigt__p_wxCursor,
60673 &_swigt__p_wxDC,
60674 &_swigt__p_wxDateEvent,
60675 &_swigt__p_wxDateTime,
60676 &_swigt__p_wxDisplayChangedEvent,
60677 &_swigt__p_wxDouble,
60678 &_swigt__p_wxDropFilesEvent,
60679 &_swigt__p_wxDuplexMode,
60680 &_swigt__p_wxEraseEvent,
60681 &_swigt__p_wxEvent,
60682 &_swigt__p_wxEventBlocker,
60683 &_swigt__p_wxEventLoop,
60684 &_swigt__p_wxEventLoopActivator,
60685 &_swigt__p_wxEvtHandler,
60686 &_swigt__p_wxFSFile,
60687 &_swigt__p_wxFileSystem,
60688 &_swigt__p_wxFileSystemHandler,
60689 &_swigt__p_wxFlexGridSizer,
60690 &_swigt__p_wxFocusEvent,
60691 &_swigt__p_wxFont,
60692 &_swigt__p_wxFrame,
60693 &_swigt__p_wxGBPosition,
60694 &_swigt__p_wxGBSizerItem,
60695 &_swigt__p_wxGBSpan,
60696 &_swigt__p_wxGIFHandler,
60697 &_swigt__p_wxGridBagSizer,
60698 &_swigt__p_wxGridSizer,
60699 &_swigt__p_wxHelpEvent__Origin,
60700 &_swigt__p_wxICOHandler,
60701 &_swigt__p_wxIconizeEvent,
60702 &_swigt__p_wxIdleEvent,
60703 &_swigt__p_wxImage,
60704 &_swigt__p_wxImageHandler,
60705 &_swigt__p_wxImageHistogram,
60706 &_swigt__p_wxImage_HSVValue,
60707 &_swigt__p_wxImage_RGBValue,
60708 &_swigt__p_wxIndividualLayoutConstraint,
60709 &_swigt__p_wxInitDialogEvent,
60710 &_swigt__p_wxInputStream,
60711 &_swigt__p_wxInternetFSHandler,
60712 &_swigt__p_wxItemContainer,
60713 &_swigt__p_wxJPEGHandler,
60714 &_swigt__p_wxKeyEvent,
60715 &_swigt__p_wxLayoutConstraints,
60716 &_swigt__p_wxMaximizeEvent,
60717 &_swigt__p_wxMemoryFSHandler,
60718 &_swigt__p_wxMenu,
60719 &_swigt__p_wxMenuBar,
60720 &_swigt__p_wxMenuBarBase,
60721 &_swigt__p_wxMenuEvent,
60722 &_swigt__p_wxMenuItem,
60723 &_swigt__p_wxMouseCaptureChangedEvent,
60724 &_swigt__p_wxMouseCaptureLostEvent,
60725 &_swigt__p_wxMouseEvent,
60726 &_swigt__p_wxMoveEvent,
60727 &_swigt__p_wxNavigationKeyEvent,
60728 &_swigt__p_wxNcPaintEvent,
60729 &_swigt__p_wxNotifyEvent,
60730 &_swigt__p_wxObject,
60731 &_swigt__p_wxOutputStream,
60732 &_swigt__p_wxPCXHandler,
60733 &_swigt__p_wxPNGHandler,
60734 &_swigt__p_wxPNMHandler,
60735 &_swigt__p_wxPaintEvent,
60736 &_swigt__p_wxPaletteChangedEvent,
60737 &_swigt__p_wxPaperSize,
60738 &_swigt__p_wxPoint,
60739 &_swigt__p_wxPoint2D,
60740 &_swigt__p_wxPosition,
60741 &_swigt__p_wxPropagateOnce,
60742 &_swigt__p_wxPropagationDisabler,
60743 &_swigt__p_wxPyApp,
60744 &_swigt__p_wxPyCommandEvent,
60745 &_swigt__p_wxPyDropTarget,
60746 &_swigt__p_wxPyEvent,
60747 &_swigt__p_wxPyFileSystemHandler,
60748 &_swigt__p_wxPyImageHandler,
60749 &_swigt__p_wxPyInputStream,
60750 &_swigt__p_wxPySizer,
60751 &_swigt__p_wxPyValidator,
60752 &_swigt__p_wxQuantize,
60753 &_swigt__p_wxQueryNewPaletteEvent,
60754 &_swigt__p_wxRealPoint,
60755 &_swigt__p_wxRect,
60756 &_swigt__p_wxRect2D,
60757 &_swigt__p_wxRegion,
60758 &_swigt__p_wxScrollEvent,
60759 &_swigt__p_wxScrollWinEvent,
60760 &_swigt__p_wxSetCursorEvent,
60761 &_swigt__p_wxShowEvent,
60762 &_swigt__p_wxSize,
60763 &_swigt__p_wxSizeEvent,
60764 &_swigt__p_wxSizer,
60765 &_swigt__p_wxSizerFlags,
60766 &_swigt__p_wxSizerItem,
60767 &_swigt__p_wxStaticBox,
60768 &_swigt__p_wxStaticBoxSizer,
60769 &_swigt__p_wxStdDialogButtonSizer,
60770 &_swigt__p_wxSysColourChangedEvent,
60771 &_swigt__p_wxTGAHandler,
60772 &_swigt__p_wxTIFFHandler,
60773 &_swigt__p_wxToolTip,
60774 &_swigt__p_wxUpdateUIEvent,
60775 &_swigt__p_wxValidator,
60776 &_swigt__p_wxVisualAttributes,
60777 &_swigt__p_wxWindow,
60778 &_swigt__p_wxWindowCreateEvent,
60779 &_swigt__p_wxWindowDestroyEvent,
60780 &_swigt__p_wxXPMHandler,
60781 &_swigt__p_wxZipFSHandler,
60782 };
60783
60784 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
60785 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
60786 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
60787 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
60788 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
60789 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
60790 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
60791 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
60792 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
60793 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
60794 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
60795 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
60796 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
60797 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
60798 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}};
60799 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
60800 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}};
60801 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
60802 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}};
60803 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
60804 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
60805 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
60806 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
60807 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
60808 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}};
60809 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
60810 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}};
60811 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
60812 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
60813 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
60814 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
60815 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
60816 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60817 static swig_cast_info _swigc__p_wxDouble[] = { {&_swigt__p_wxDouble, 0, 0, 0},{0, 0, 0, 0}};
60818 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
60819 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
60820 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
60821 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}};
60822 static swig_cast_info _swigc__p_wxEventBlocker[] = { {&_swigt__p_wxEventBlocker, 0, 0, 0},{0, 0, 0, 0}};
60823 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
60824 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
60825 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}};
60826 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
60827 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
60828 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}};
60829 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}};
60830 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
60831 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
60832 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
60833 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
60834 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
60835 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
60836 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
60837 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
60838 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}};
60839 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
60840 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}};
60841 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
60842 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
60843 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
60844 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}};
60845 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
60846 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
60847 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
60848 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
60849 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
60850 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
60851 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
60852 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}};
60853 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
60854 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
60855 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
60856 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
60857 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
60858 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
60859 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
60860 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
60861 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
60862 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
60863 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60864 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
60865 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
60866 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
60867 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
60868 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
60869 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
60870 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}};
60871 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
60872 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
60873 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
60874 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
60875 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
60876 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60877 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
60878 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
60879 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
60880 static swig_cast_info _swigc__p_wxPosition[] = { {&_swigt__p_wxPosition, 0, 0, 0},{0, 0, 0, 0}};
60881 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
60882 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
60883 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
60884 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
60885 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
60886 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
60887 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
60888 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
60889 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
60890 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
60891 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
60892 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
60893 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
60894 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
60895 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
60896 static swig_cast_info _swigc__p_wxRect2D[] = { {&_swigt__p_wxRect2D, 0, 0, 0},{0, 0, 0, 0}};
60897 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
60898 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
60899 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
60900 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
60901 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
60902 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
60903 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
60904 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}};
60905 static swig_cast_info _swigc__p_wxSizerFlags[] = { {&_swigt__p_wxSizerFlags, 0, 0, 0},{0, 0, 0, 0}};
60906 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}};
60907 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
60908 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
60909 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
60910 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60911 static swig_cast_info _swigc__p_wxTGAHandler[] = { {&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
60912 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
60913 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
60914 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
60915 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}};
60916 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
60917 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}};
60918 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
60919 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
60920 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
60921 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
60922
60923 static swig_cast_info *swig_cast_initial[] = {
60924 _swigc__p_buffer,
60925 _swigc__p_char,
60926 _swigc__p_form_ops_t,
60927 _swigc__p_int,
60928 _swigc__p_long,
60929 _swigc__p_unsigned_char,
60930 _swigc__p_unsigned_int,
60931 _swigc__p_unsigned_long,
60932 _swigc__p_wxANIHandler,
60933 _swigc__p_wxAcceleratorEntry,
60934 _swigc__p_wxAcceleratorTable,
60935 _swigc__p_wxActivateEvent,
60936 _swigc__p_wxAppTraits,
60937 _swigc__p_wxArrayString,
60938 _swigc__p_wxBMPHandler,
60939 _swigc__p_wxBitmap,
60940 _swigc__p_wxBoxSizer,
60941 _swigc__p_wxButton,
60942 _swigc__p_wxCURHandler,
60943 _swigc__p_wxCaret,
60944 _swigc__p_wxChildFocusEvent,
60945 _swigc__p_wxClipboardTextEvent,
60946 _swigc__p_wxCloseEvent,
60947 _swigc__p_wxColour,
60948 _swigc__p_wxCommandEvent,
60949 _swigc__p_wxContextMenuEvent,
60950 _swigc__p_wxControl,
60951 _swigc__p_wxControlWithItems,
60952 _swigc__p_wxCursor,
60953 _swigc__p_wxDC,
60954 _swigc__p_wxDateEvent,
60955 _swigc__p_wxDateTime,
60956 _swigc__p_wxDisplayChangedEvent,
60957 _swigc__p_wxDouble,
60958 _swigc__p_wxDropFilesEvent,
60959 _swigc__p_wxDuplexMode,
60960 _swigc__p_wxEraseEvent,
60961 _swigc__p_wxEvent,
60962 _swigc__p_wxEventBlocker,
60963 _swigc__p_wxEventLoop,
60964 _swigc__p_wxEventLoopActivator,
60965 _swigc__p_wxEvtHandler,
60966 _swigc__p_wxFSFile,
60967 _swigc__p_wxFileSystem,
60968 _swigc__p_wxFileSystemHandler,
60969 _swigc__p_wxFlexGridSizer,
60970 _swigc__p_wxFocusEvent,
60971 _swigc__p_wxFont,
60972 _swigc__p_wxFrame,
60973 _swigc__p_wxGBPosition,
60974 _swigc__p_wxGBSizerItem,
60975 _swigc__p_wxGBSpan,
60976 _swigc__p_wxGIFHandler,
60977 _swigc__p_wxGridBagSizer,
60978 _swigc__p_wxGridSizer,
60979 _swigc__p_wxHelpEvent__Origin,
60980 _swigc__p_wxICOHandler,
60981 _swigc__p_wxIconizeEvent,
60982 _swigc__p_wxIdleEvent,
60983 _swigc__p_wxImage,
60984 _swigc__p_wxImageHandler,
60985 _swigc__p_wxImageHistogram,
60986 _swigc__p_wxImage_HSVValue,
60987 _swigc__p_wxImage_RGBValue,
60988 _swigc__p_wxIndividualLayoutConstraint,
60989 _swigc__p_wxInitDialogEvent,
60990 _swigc__p_wxInputStream,
60991 _swigc__p_wxInternetFSHandler,
60992 _swigc__p_wxItemContainer,
60993 _swigc__p_wxJPEGHandler,
60994 _swigc__p_wxKeyEvent,
60995 _swigc__p_wxLayoutConstraints,
60996 _swigc__p_wxMaximizeEvent,
60997 _swigc__p_wxMemoryFSHandler,
60998 _swigc__p_wxMenu,
60999 _swigc__p_wxMenuBar,
61000 _swigc__p_wxMenuBarBase,
61001 _swigc__p_wxMenuEvent,
61002 _swigc__p_wxMenuItem,
61003 _swigc__p_wxMouseCaptureChangedEvent,
61004 _swigc__p_wxMouseCaptureLostEvent,
61005 _swigc__p_wxMouseEvent,
61006 _swigc__p_wxMoveEvent,
61007 _swigc__p_wxNavigationKeyEvent,
61008 _swigc__p_wxNcPaintEvent,
61009 _swigc__p_wxNotifyEvent,
61010 _swigc__p_wxObject,
61011 _swigc__p_wxOutputStream,
61012 _swigc__p_wxPCXHandler,
61013 _swigc__p_wxPNGHandler,
61014 _swigc__p_wxPNMHandler,
61015 _swigc__p_wxPaintEvent,
61016 _swigc__p_wxPaletteChangedEvent,
61017 _swigc__p_wxPaperSize,
61018 _swigc__p_wxPoint,
61019 _swigc__p_wxPoint2D,
61020 _swigc__p_wxPosition,
61021 _swigc__p_wxPropagateOnce,
61022 _swigc__p_wxPropagationDisabler,
61023 _swigc__p_wxPyApp,
61024 _swigc__p_wxPyCommandEvent,
61025 _swigc__p_wxPyDropTarget,
61026 _swigc__p_wxPyEvent,
61027 _swigc__p_wxPyFileSystemHandler,
61028 _swigc__p_wxPyImageHandler,
61029 _swigc__p_wxPyInputStream,
61030 _swigc__p_wxPySizer,
61031 _swigc__p_wxPyValidator,
61032 _swigc__p_wxQuantize,
61033 _swigc__p_wxQueryNewPaletteEvent,
61034 _swigc__p_wxRealPoint,
61035 _swigc__p_wxRect,
61036 _swigc__p_wxRect2D,
61037 _swigc__p_wxRegion,
61038 _swigc__p_wxScrollEvent,
61039 _swigc__p_wxScrollWinEvent,
61040 _swigc__p_wxSetCursorEvent,
61041 _swigc__p_wxShowEvent,
61042 _swigc__p_wxSize,
61043 _swigc__p_wxSizeEvent,
61044 _swigc__p_wxSizer,
61045 _swigc__p_wxSizerFlags,
61046 _swigc__p_wxSizerItem,
61047 _swigc__p_wxStaticBox,
61048 _swigc__p_wxStaticBoxSizer,
61049 _swigc__p_wxStdDialogButtonSizer,
61050 _swigc__p_wxSysColourChangedEvent,
61051 _swigc__p_wxTGAHandler,
61052 _swigc__p_wxTIFFHandler,
61053 _swigc__p_wxToolTip,
61054 _swigc__p_wxUpdateUIEvent,
61055 _swigc__p_wxValidator,
61056 _swigc__p_wxVisualAttributes,
61057 _swigc__p_wxWindow,
61058 _swigc__p_wxWindowCreateEvent,
61059 _swigc__p_wxWindowDestroyEvent,
61060 _swigc__p_wxXPMHandler,
61061 _swigc__p_wxZipFSHandler,
61062 };
61063
61064
61065 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
61066
61067 static swig_const_info swig_const_table[] = {
61068 {0, 0, 0, 0.0, 0, 0}};
61069
61070 #ifdef __cplusplus
61071 }
61072 #endif
61073 /* -----------------------------------------------------------------------------
61074 * Type initialization:
61075 * This problem is tough by the requirement that no dynamic
61076 * memory is used. Also, since swig_type_info structures store pointers to
61077 * swig_cast_info structures and swig_cast_info structures store pointers back
61078 * to swig_type_info structures, we need some lookup code at initialization.
61079 * The idea is that swig generates all the structures that are needed.
61080 * The runtime then collects these partially filled structures.
61081 * The SWIG_InitializeModule function takes these initial arrays out of
61082 * swig_module, and does all the lookup, filling in the swig_module.types
61083 * array with the correct data and linking the correct swig_cast_info
61084 * structures together.
61085 *
61086 * The generated swig_type_info structures are assigned staticly to an initial
61087 * array. We just loop though that array, and handle each type individually.
61088 * First we lookup if this type has been already loaded, and if so, use the
61089 * loaded structure instead of the generated one. Then we have to fill in the
61090 * cast linked list. The cast data is initially stored in something like a
61091 * two-dimensional array. Each row corresponds to a type (there are the same
61092 * number of rows as there are in the swig_type_initial array). Each entry in
61093 * a column is one of the swig_cast_info structures for that type.
61094 * The cast_initial array is actually an array of arrays, because each row has
61095 * a variable number of columns. So to actually build the cast linked list,
61096 * we find the array of casts associated with the type, and loop through it
61097 * adding the casts to the list. The one last trick we need to do is making
61098 * sure the type pointer in the swig_cast_info struct is correct.
61099 *
61100 * First off, we lookup the cast->type name to see if it is already loaded.
61101 * There are three cases to handle:
61102 * 1) If the cast->type has already been loaded AND the type we are adding
61103 * casting info to has not been loaded (it is in this module), THEN we
61104 * replace the cast->type pointer with the type pointer that has already
61105 * been loaded.
61106 * 2) If BOTH types (the one we are adding casting info to, and the
61107 * cast->type) are loaded, THEN the cast info has already been loaded by
61108 * the previous module so we just ignore it.
61109 * 3) Finally, if cast->type has not already been loaded, then we add that
61110 * swig_cast_info to the linked list (because the cast->type) pointer will
61111 * be correct.
61112 * ----------------------------------------------------------------------------- */
61113
61114 #ifdef __cplusplus
61115 extern "C" {
61116 #if 0
61117 } /* c-mode */
61118 #endif
61119 #endif
61120
61121 #if 0
61122 #define SWIGRUNTIME_DEBUG
61123 #endif
61124
61125 SWIGRUNTIME void
61126 SWIG_InitializeModule(void *clientdata) {
61127 size_t i;
61128 swig_module_info *module_head;
61129 static int init_run = 0;
61130
61131 clientdata = clientdata;
61132
61133 if (init_run) return;
61134 init_run = 1;
61135
61136 /* Initialize the swig_module */
61137 swig_module.type_initial = swig_type_initial;
61138 swig_module.cast_initial = swig_cast_initial;
61139
61140 /* Try and load any already created modules */
61141 module_head = SWIG_GetModule(clientdata);
61142 if (module_head) {
61143 swig_module.next = module_head->next;
61144 module_head->next = &swig_module;
61145 } else {
61146 /* This is the first module loaded */
61147 swig_module.next = &swig_module;
61148 SWIG_SetModule(clientdata, &swig_module);
61149 }
61150
61151 /* Now work on filling in swig_module.types */
61152 #ifdef SWIGRUNTIME_DEBUG
61153 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
61154 #endif
61155 for (i = 0; i < swig_module.size; ++i) {
61156 swig_type_info *type = 0;
61157 swig_type_info *ret;
61158 swig_cast_info *cast;
61159
61160 #ifdef SWIGRUNTIME_DEBUG
61161 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
61162 #endif
61163
61164 /* if there is another module already loaded */
61165 if (swig_module.next != &swig_module) {
61166 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
61167 }
61168 if (type) {
61169 /* Overwrite clientdata field */
61170 #ifdef SWIGRUNTIME_DEBUG
61171 printf("SWIG_InitializeModule: found type %s\n", type->name);
61172 #endif
61173 if (swig_module.type_initial[i]->clientdata) {
61174 type->clientdata = swig_module.type_initial[i]->clientdata;
61175 #ifdef SWIGRUNTIME_DEBUG
61176 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
61177 #endif
61178 }
61179 } else {
61180 type = swig_module.type_initial[i];
61181 }
61182
61183 /* Insert casting types */
61184 cast = swig_module.cast_initial[i];
61185 while (cast->type) {
61186 /* Don't need to add information already in the list */
61187 ret = 0;
61188 #ifdef SWIGRUNTIME_DEBUG
61189 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
61190 #endif
61191 if (swig_module.next != &swig_module) {
61192 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
61193 #ifdef SWIGRUNTIME_DEBUG
61194 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
61195 #endif
61196 }
61197 if (ret) {
61198 if (type == swig_module.type_initial[i]) {
61199 #ifdef SWIGRUNTIME_DEBUG
61200 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
61201 #endif
61202 cast->type = ret;
61203 ret = 0;
61204 } else {
61205 /* Check for casting already in the list */
61206 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
61207 #ifdef SWIGRUNTIME_DEBUG
61208 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
61209 #endif
61210 if (!ocast) ret = 0;
61211 }
61212 }
61213
61214 if (!ret) {
61215 #ifdef SWIGRUNTIME_DEBUG
61216 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
61217 #endif
61218 if (type->cast) {
61219 type->cast->prev = cast;
61220 cast->next = type->cast;
61221 }
61222 type->cast = cast;
61223 }
61224 cast++;
61225 }
61226 /* Set entry in modules->types array equal to the type */
61227 swig_module.types[i] = type;
61228 }
61229 swig_module.types[i] = 0;
61230
61231 #ifdef SWIGRUNTIME_DEBUG
61232 printf("**** SWIG_InitializeModule: Cast List ******\n");
61233 for (i = 0; i < swig_module.size; ++i) {
61234 int j = 0;
61235 swig_cast_info *cast = swig_module.cast_initial[i];
61236 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
61237 while (cast->type) {
61238 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
61239 cast++;
61240 ++j;
61241 }
61242 printf("---- Total casts: %d\n",j);
61243 }
61244 printf("**** SWIG_InitializeModule: Cast List ******\n");
61245 #endif
61246 }
61247
61248 /* This function will propagate the clientdata field of type to
61249 * any new swig_type_info structures that have been added into the list
61250 * of equivalent types. It is like calling
61251 * SWIG_TypeClientData(type, clientdata) a second time.
61252 */
61253 SWIGRUNTIME void
61254 SWIG_PropagateClientData(void) {
61255 size_t i;
61256 swig_cast_info *equiv;
61257 static int init_run = 0;
61258
61259 if (init_run) return;
61260 init_run = 1;
61261
61262 for (i = 0; i < swig_module.size; i++) {
61263 if (swig_module.types[i]->clientdata) {
61264 equiv = swig_module.types[i]->cast;
61265 while (equiv) {
61266 if (!equiv->converter) {
61267 if (equiv->type && !equiv->type->clientdata)
61268 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
61269 }
61270 equiv = equiv->next;
61271 }
61272 }
61273 }
61274 }
61275
61276 #ifdef __cplusplus
61277 #if 0
61278 {
61279 /* c-mode */
61280 #endif
61281 }
61282 #endif
61283
61284
61285
61286 #ifdef __cplusplus
61287 extern "C" {
61288 #endif
61289
61290 /* Python-specific SWIG API */
61291 #define SWIG_newvarlink() SWIG_Python_newvarlink()
61292 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
61293 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
61294
61295 /* -----------------------------------------------------------------------------
61296 * global variable support code.
61297 * ----------------------------------------------------------------------------- */
61298
61299 typedef struct swig_globalvar {
61300 char *name; /* Name of global variable */
61301 PyObject *(*get_attr)(void); /* Return the current value */
61302 int (*set_attr)(PyObject *); /* Set the value */
61303 struct swig_globalvar *next;
61304 } swig_globalvar;
61305
61306 typedef struct swig_varlinkobject {
61307 PyObject_HEAD
61308 swig_globalvar *vars;
61309 } swig_varlinkobject;
61310
61311 SWIGINTERN PyObject *
61312 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
61313 return PyString_FromString("<Swig global variables>");
61314 }
61315
61316 SWIGINTERN PyObject *
61317 swig_varlink_str(swig_varlinkobject *v) {
61318 PyObject *str = PyString_FromString("(");
61319 swig_globalvar *var;
61320 for (var = v->vars; var; var=var->next) {
61321 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
61322 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
61323 }
61324 PyString_ConcatAndDel(&str,PyString_FromString(")"));
61325 return str;
61326 }
61327
61328 SWIGINTERN int
61329 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
61330 PyObject *str = swig_varlink_str(v);
61331 fprintf(fp,"Swig global variables ");
61332 fprintf(fp,"%s\n", PyString_AsString(str));
61333 Py_DECREF(str);
61334 return 0;
61335 }
61336
61337 SWIGINTERN void
61338 swig_varlink_dealloc(swig_varlinkobject *v) {
61339 swig_globalvar *var = v->vars;
61340 while (var) {
61341 swig_globalvar *n = var->next;
61342 free(var->name);
61343 free(var);
61344 var = n;
61345 }
61346 }
61347
61348 SWIGINTERN PyObject *
61349 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
61350 PyObject *res = NULL;
61351 swig_globalvar *var = v->vars;
61352 while (var) {
61353 if (strcmp(var->name,n) == 0) {
61354 res = (*var->get_attr)();
61355 break;
61356 }
61357 var = var->next;
61358 }
61359 if (res == NULL && !PyErr_Occurred()) {
61360 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
61361 }
61362 return res;
61363 }
61364
61365 SWIGINTERN int
61366 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
61367 int res = 1;
61368 swig_globalvar *var = v->vars;
61369 while (var) {
61370 if (strcmp(var->name,n) == 0) {
61371 res = (*var->set_attr)(p);
61372 break;
61373 }
61374 var = var->next;
61375 }
61376 if (res == 1 && !PyErr_Occurred()) {
61377 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
61378 }
61379 return res;
61380 }
61381
61382 SWIGINTERN PyTypeObject*
61383 swig_varlink_type(void) {
61384 static char varlink__doc__[] = "Swig var link object";
61385 static PyTypeObject varlink_type;
61386 static int type_init = 0;
61387 if (!type_init) {
61388 const PyTypeObject tmp
61389 = {
61390 PyObject_HEAD_INIT(NULL)
61391 0, /* Number of items in variable part (ob_size) */
61392 (char *)"swigvarlink", /* Type name (tp_name) */
61393 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
61394 0, /* Itemsize (tp_itemsize) */
61395 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
61396 (printfunc) swig_varlink_print, /* Print (tp_print) */
61397 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
61398 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
61399 0, /* tp_compare */
61400 (reprfunc) swig_varlink_repr, /* tp_repr */
61401 0, /* tp_as_number */
61402 0, /* tp_as_sequence */
61403 0, /* tp_as_mapping */
61404 0, /* tp_hash */
61405 0, /* tp_call */
61406 (reprfunc)swig_varlink_str, /* tp_str */
61407 0, /* tp_getattro */
61408 0, /* tp_setattro */
61409 0, /* tp_as_buffer */
61410 0, /* tp_flags */
61411 varlink__doc__, /* tp_doc */
61412 0, /* tp_traverse */
61413 0, /* tp_clear */
61414 0, /* tp_richcompare */
61415 0, /* tp_weaklistoffset */
61416 #if PY_VERSION_HEX >= 0x02020000
61417 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
61418 #endif
61419 #if PY_VERSION_HEX >= 0x02030000
61420 0, /* tp_del */
61421 #endif
61422 #ifdef COUNT_ALLOCS
61423 0,0,0,0 /* tp_alloc -> tp_next */
61424 #endif
61425 };
61426 varlink_type = tmp;
61427 varlink_type.ob_type = &PyType_Type;
61428 type_init = 1;
61429 }
61430 return &varlink_type;
61431 }
61432
61433 /* Create a variable linking object for use later */
61434 SWIGINTERN PyObject *
61435 SWIG_Python_newvarlink(void) {
61436 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
61437 if (result) {
61438 result->vars = 0;
61439 }
61440 return ((PyObject*) result);
61441 }
61442
61443 SWIGINTERN void
61444 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
61445 swig_varlinkobject *v = (swig_varlinkobject *) p;
61446 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
61447 if (gv) {
61448 size_t size = strlen(name)+1;
61449 gv->name = (char *)malloc(size);
61450 if (gv->name) {
61451 strncpy(gv->name,name,size);
61452 gv->get_attr = get_attr;
61453 gv->set_attr = set_attr;
61454 gv->next = v->vars;
61455 }
61456 }
61457 v->vars = gv;
61458 }
61459
61460 SWIGINTERN PyObject *
61461 SWIG_globals() {
61462 static PyObject *_SWIG_globals = 0;
61463 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
61464 return _SWIG_globals;
61465 }
61466
61467 /* -----------------------------------------------------------------------------
61468 * constants/methods manipulation
61469 * ----------------------------------------------------------------------------- */
61470
61471 /* Install Constants */
61472 SWIGINTERN void
61473 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
61474 PyObject *obj = 0;
61475 size_t i;
61476 for (i = 0; constants[i].type; ++i) {
61477 switch(constants[i].type) {
61478 case SWIG_PY_POINTER:
61479 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
61480 break;
61481 case SWIG_PY_BINARY:
61482 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
61483 break;
61484 default:
61485 obj = 0;
61486 break;
61487 }
61488 if (obj) {
61489 PyDict_SetItemString(d, constants[i].name, obj);
61490 Py_DECREF(obj);
61491 }
61492 }
61493 }
61494
61495 /* -----------------------------------------------------------------------------*/
61496 /* Fix SwigMethods to carry the callback ptrs when needed */
61497 /* -----------------------------------------------------------------------------*/
61498
61499 SWIGINTERN void
61500 SWIG_Python_FixMethods(PyMethodDef *methods,
61501 swig_const_info *const_table,
61502 swig_type_info **types,
61503 swig_type_info **types_initial) {
61504 size_t i;
61505 for (i = 0; methods[i].ml_name; ++i) {
61506 const char *c = methods[i].ml_doc;
61507 if (c && (c = strstr(c, "swig_ptr: "))) {
61508 int j;
61509 swig_const_info *ci = 0;
61510 const char *name = c + 10;
61511 for (j = 0; const_table[j].type; ++j) {
61512 if (strncmp(const_table[j].name, name,
61513 strlen(const_table[j].name)) == 0) {
61514 ci = &(const_table[j]);
61515 break;
61516 }
61517 }
61518 if (ci) {
61519 size_t shift = (ci->ptype) - types;
61520 swig_type_info *ty = types_initial[shift];
61521 size_t ldoc = (c - methods[i].ml_doc);
61522 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
61523 char *ndoc = (char*)malloc(ldoc + lptr + 10);
61524 if (ndoc) {
61525 char *buff = ndoc;
61526 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
61527 if (ptr) {
61528 strncpy(buff, methods[i].ml_doc, ldoc);
61529 buff += ldoc;
61530 strncpy(buff, "swig_ptr: ", 10);
61531 buff += 10;
61532 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
61533 methods[i].ml_doc = ndoc;
61534 }
61535 }
61536 }
61537 }
61538 }
61539 }
61540
61541 #ifdef __cplusplus
61542 }
61543 #endif
61544
61545 /* -----------------------------------------------------------------------------*
61546 * Partial Init method
61547 * -----------------------------------------------------------------------------*/
61548
61549 #ifdef __cplusplus
61550 extern "C"
61551 #endif
61552 SWIGEXPORT void SWIG_init(void) {
61553 PyObject *m, *d;
61554
61555 /* Fix SwigMethods to carry the callback ptrs when needed */
61556 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
61557
61558 m = Py_InitModule((char *) SWIG_name, SwigMethods);
61559 d = PyModule_GetDict(m);
61560
61561 SWIG_InitializeModule(0);
61562 SWIG_InstallConstants(d,swig_const_table);
61563
61564
61565
61566 #ifndef wxPyUSE_EXPORT
61567 // Make our API structure a CObject so other modules can import it
61568 // from this module.
61569 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
61570 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
61571 Py_XDECREF(cobj);
61572 #endif
61573
61574 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
61575 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
61576 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
61577 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
61578 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
61579 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
61580 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
61581 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
61582 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
61583 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
61584 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
61585 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
61586 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
61587 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
61588 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
61589 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
61590 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
61591 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
61592 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
61593 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
61594 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
61595 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
61596 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
61597 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
61598 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
61599 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
61600 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
61601 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
61602 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
61603 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
61604 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
61605 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
61606 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
61607 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
61608 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
61609 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
61610 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
61611 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
61612 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
61613 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
61614 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
61615 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
61616 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
61617 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
61618 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
61619 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
61620 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
61621 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
61622 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
61623 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
61624 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
61625 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
61626 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
61627 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
61628 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
61629 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
61630 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
61631 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
61632 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
61633 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
61634 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
61635 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
61636 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
61637 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
61638 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
61639 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
61640 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
61641 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
61642 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
61643 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
61644 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
61645 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
61646 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
61647 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
61648 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
61649 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
61650 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
61651 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
61652 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
61653 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
61654 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
61655 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
61656 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
61657 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
61658 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
61659 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
61660 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
61661 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
61662 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
61663 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
61664 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
61665 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
61666 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
61667 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
61668 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
61669 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
61670 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
61671 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
61672 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
61673 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
61674 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
61675 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
61676 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
61677 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
61678 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
61679 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
61680 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
61681 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
61682 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
61683 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
61684 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
61685 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
61686 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
61687 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
61688 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
61689 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
61690 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
61691 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
61692 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
61693 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
61694 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
61695 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
61696 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
61697 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
61698 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
61699 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
61700 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
61701 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
61702 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
61703 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
61704 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
61705 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
61706 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
61707 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
61708 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
61709 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
61710 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
61711 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
61712 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
61713 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
61714 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
61715 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
61716 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
61717 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
61718 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
61719 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
61720 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
61721 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
61722 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
61723 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
61724 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
61725 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
61726 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
61727 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
61728 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
61729 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
61730 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
61731 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
61732 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
61733 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
61734 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
61735 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
61736 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
61737 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
61738 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
61739 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
61740 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
61741 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
61742 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
61743 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
61744 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
61745 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
61746 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
61747 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
61748 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
61749 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
61750 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
61751 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
61752 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
61753 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
61754 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
61755 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
61756 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
61757 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
61758 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
61759 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
61760 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
61761 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
61762 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
61763 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
61764 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
61765 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
61766 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
61767 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
61768 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
61769 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
61770 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
61771 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
61772 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
61773 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
61774 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
61775 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
61776 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
61777 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
61778 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
61779 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
61780 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
61781 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
61782 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
61783 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
61784 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
61785 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
61786 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
61787 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
61788 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
61789 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
61790 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
61791 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
61792 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
61793 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
61794 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
61795 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
61796 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
61797 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
61798 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
61799 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
61800 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
61801 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
61802 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
61803 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
61804 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
61805 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
61806 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
61807 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
61808 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
61809 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
61810 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
61811 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
61812 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
61813 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
61814 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
61815 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
61816 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
61817 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
61818 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
61819 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
61820 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
61821 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
61822 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
61823 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
61824 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
61825 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
61826 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
61827 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
61828 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
61829 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
61830 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
61831 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
61832 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
61833 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
61834 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
61835 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
61836 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
61837 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
61838 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
61839 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
61840 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
61841 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
61842 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
61843 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
61844 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
61845 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
61846 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
61847 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
61848 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
61849 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
61850 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
61851 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
61852 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
61853 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
61854 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
61855 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
61856 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
61857 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
61858 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
61859 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
61860 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
61861 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
61862 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
61863 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
61864 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
61865 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
61866 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
61867 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
61868 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
61869 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
61870 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
61871 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
61872 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
61873 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
61874 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
61875 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
61876 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
61877 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
61878 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
61879 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
61880 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
61881 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
61882 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
61883 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
61884 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
61885 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
61886 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
61887 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
61888 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
61889 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
61890 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
61891 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
61892 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
61893 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
61894 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
61895 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
61896 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
61897 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
61898 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
61899 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
61900 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
61901 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
61902 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
61903 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
61904 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
61905 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
61906 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
61907 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
61908 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
61909 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
61910 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
61911 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
61912 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
61913 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
61914 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
61915 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
61916 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
61917 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
61918 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
61919 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
61920 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
61921 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
61922 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
61923 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
61924 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
61925 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
61926 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
61927 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
61928 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
61929 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
61930 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
61931 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
61932 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
61933 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
61934 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
61935 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
61936 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
61937 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
61938 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
61939 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
61940 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
61941 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
61942 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
61943 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
61944 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
61945 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
61946 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
61947 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
61948 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
61949 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
61950 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
61951 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
61952 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
61953 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
61954 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
61955 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
61956 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
61957 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
61958 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
61959 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
61960 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
61961 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
61962 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
61963 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
61964 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
61965 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
61966 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
61967 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
61968 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
61969 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
61970 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
61971 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
61972 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
61973 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
61974 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
61975 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
61976 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
61977 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
61978 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
61979 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
61980 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
61981 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
61982 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
61983 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
61984 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
61985 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
61986 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
61987 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
61988 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
61989 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
61990 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
61991 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
61992 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
61993 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
61994 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
61995 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
61996 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
61997 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
61998 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
61999 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
62000 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
62001 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
62002 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
62003 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
62004 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
62005 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
62006 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
62007 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
62008 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
62009 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
62010 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
62011 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
62012 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
62013 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
62014 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
62015 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
62016 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
62017 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
62018 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
62019 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
62020 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
62021 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
62022 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
62023 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
62024 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
62025 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
62026 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
62027 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
62028 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
62029 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
62030 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
62031 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
62032 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
62033 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
62034 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
62035 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
62036 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
62037 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
62038 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
62039 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
62040 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
62041 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
62042 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
62043 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
62044 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
62045 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
62046 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
62047 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
62048 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
62049 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
62050 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
62051 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
62052 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
62053 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
62054 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
62055 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
62056 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
62057 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
62058 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
62059 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
62060 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
62061 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
62062 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
62063 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
62064 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
62065 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
62066 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
62067 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
62068 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
62069 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
62070 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
62071 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
62072 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
62073 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
62074 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
62075 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
62076 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
62077 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
62078 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
62079 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
62080 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
62081 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
62082 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
62083 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
62084 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
62085 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
62086 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
62087 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
62088 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
62089 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
62090 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
62091 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
62092 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
62093 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
62094 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
62095 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
62096 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
62097 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
62098 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
62099 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
62100 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
62101 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
62102 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
62103 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
62104 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
62105 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
62106 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
62107 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
62108 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
62109 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
62110 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
62111 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
62112 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
62113 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
62114 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
62115 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
62116 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
62117 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
62118 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
62119 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
62120 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
62121 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
62122 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
62123 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
62124 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
62125 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
62126 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
62127 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
62128 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
62129 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
62130 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
62131 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
62132 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
62133 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
62134 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
62135 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
62136 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
62137 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
62138 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
62139 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
62140 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
62141 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
62142 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
62143 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
62144 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
62145 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
62146 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
62147 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
62148 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
62149 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
62150 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
62151 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
62152 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
62153 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
62154 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
62155 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
62156 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
62157 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
62158 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
62159 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
62160 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
62161 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
62162 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
62163 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
62164 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
62165 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
62166 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
62167 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
62168 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
62169 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
62170 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
62171 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
62172 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
62173 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
62174 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
62175 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
62176 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
62177 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
62178 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
62179 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
62180 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
62181 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
62182 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
62183 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
62184 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
62185 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TGA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TGA)));
62186 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
62187 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
62188 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
62189 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
62190 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
62191 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
62192 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
62193 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
62194 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
62195 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
62196 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
62197 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
62198 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
62199 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
62200 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
62201 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
62202 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
62203 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
62204 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
62205 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
62206 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
62207 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
62208 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
62209 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
62210 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
62211 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
62212 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
62213 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
62214 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
62215 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
62216 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
62217 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
62218 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
62219 SWIG_Python_SetConstant(d, "Inside",SWIG_From_int(static_cast< int >(wxInside)));
62220 SWIG_Python_SetConstant(d, "OutLeft",SWIG_From_int(static_cast< int >(wxOutLeft)));
62221 SWIG_Python_SetConstant(d, "OutRight",SWIG_From_int(static_cast< int >(wxOutRight)));
62222 SWIG_Python_SetConstant(d, "OutTop",SWIG_From_int(static_cast< int >(wxOutTop)));
62223 SWIG_Python_SetConstant(d, "OutBottom",SWIG_From_int(static_cast< int >(wxOutBottom)));
62224 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
62225 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
62226 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
62227 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
62228 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
62229
62230 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
62231
62232
62233 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
62234
62235 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
62236 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
62237 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
62238 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
62239 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
62240 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
62241 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
62242 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
62243 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
62244 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
62245 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
62246 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
62247 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
62248 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
62249 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
62250 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
62251 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
62252 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
62253 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
62254 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
62255 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
62256 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
62257 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
62258 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
62259 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
62260 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
62261 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
62262 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
62263 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
62264 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
62265 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
62266 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
62267 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
62268 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
62269 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
62270 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
62271 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
62272 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
62273 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
62274 PyDict_SetItemString(d, "wxEVT_ANY", PyInt_FromLong(wxEVT_ANY));
62275 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
62276 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
62277 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
62278 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
62279 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
62280 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
62281 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
62282 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
62283 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
62284 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
62285 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
62286 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
62287 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
62288 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
62289 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
62290 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
62291 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
62292 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
62293 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
62294 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
62295 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
62296 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
62297 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
62298 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
62299 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
62300 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
62301 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
62302 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
62303 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
62304 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
62305 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
62306 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
62307 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
62308 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
62309 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
62310 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
62311 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
62312 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
62313 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
62314 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
62315 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
62316 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
62317 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
62318 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
62319 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
62320 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
62321 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
62322 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
62323 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
62324 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
62325 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
62326 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
62327 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
62328 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
62329 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
62330 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
62331 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
62332 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
62333 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
62334 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
62335 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
62336 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
62337 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
62338 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
62339 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
62340 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
62341 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
62342 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
62343 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
62344 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
62345 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
62346 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
62347 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
62348 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
62349 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
62350 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
62351 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
62352 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
62353 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
62354 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
62355 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
62356 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
62357 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
62358 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
62359 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
62360 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
62361 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
62362 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
62363 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
62364 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
62365 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
62366 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
62367 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
62368 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
62369 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
62370 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
62371 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
62372 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
62373 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
62374 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
62375 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
62376 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
62377 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
62378 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
62379 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
62380 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
62381 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
62382 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
62383 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
62384 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
62385 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
62386 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
62387 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
62388 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
62389 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
62390 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
62391 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
62392 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
62393 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
62394 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
62395 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
62396 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
62397 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
62398 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
62399 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
62400 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
62401 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
62402 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
62403 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
62404 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
62405 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
62406 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
62407 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
62408 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
62409 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
62410 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
62411 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
62412 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
62413 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
62414 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
62415 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
62416 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
62417 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
62418 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
62419 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
62420 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
62421 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
62422 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
62423 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
62424 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
62425 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
62426 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
62427 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
62428 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
62429 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
62430 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
62431 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
62432 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
62433 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
62434 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
62435 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
62436 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
62437 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
62438 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
62439 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
62440 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
62441 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
62442 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
62443 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
62444 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
62445 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
62446 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
62447 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
62448 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
62449 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
62450
62451 // Initialize threading, some globals and such
62452 __wxPyPreStart(d);
62453
62454
62455 // Although these are defined in __version__ they need to be here too so
62456 // that an assert can be done to ensure that the wxPython and the wxWindows
62457 // versions match.
62458 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
62459 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
62460 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
62461
62462 }
62463
wxWidgets (Impactor)