]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
reSWIGged
[wxWidgets.git] / wxPython / src / msw / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2479 #define SWIGTYPE_p_wxArrayString swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2483 #define SWIGTYPE_p_wxButton swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2488 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2489 #define SWIGTYPE_p_wxColour swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDateTime swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_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_wxPropagateOnce swig_types[96]
2563 #define SWIGTYPE_p_wxPropagationDisabler swig_types[97]
2564 #define SWIGTYPE_p_wxPyApp swig_types[98]
2565 #define SWIGTYPE_p_wxPyCommandEvent swig_types[99]
2566 #define SWIGTYPE_p_wxPyDropTarget swig_types[100]
2567 #define SWIGTYPE_p_wxPyEvent swig_types[101]
2568 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[102]
2569 #define SWIGTYPE_p_wxPyImageHandler swig_types[103]
2570 #define SWIGTYPE_p_wxPyInputStream swig_types[104]
2571 #define SWIGTYPE_p_wxPySizer swig_types[105]
2572 #define SWIGTYPE_p_wxPyValidator swig_types[106]
2573 #define SWIGTYPE_p_wxQuantize swig_types[107]
2574 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[108]
2575 #define SWIGTYPE_p_wxRealPoint swig_types[109]
2576 #define SWIGTYPE_p_wxRect swig_types[110]
2577 #define SWIGTYPE_p_wxRect2D swig_types[111]
2578 #define SWIGTYPE_p_wxRegion swig_types[112]
2579 #define SWIGTYPE_p_wxScrollEvent swig_types[113]
2580 #define SWIGTYPE_p_wxScrollWinEvent swig_types[114]
2581 #define SWIGTYPE_p_wxSetCursorEvent swig_types[115]
2582 #define SWIGTYPE_p_wxShowEvent swig_types[116]
2583 #define SWIGTYPE_p_wxSize swig_types[117]
2584 #define SWIGTYPE_p_wxSizeEvent swig_types[118]
2585 #define SWIGTYPE_p_wxSizer swig_types[119]
2586 #define SWIGTYPE_p_wxSizerFlags swig_types[120]
2587 #define SWIGTYPE_p_wxSizerItem swig_types[121]
2588 #define SWIGTYPE_p_wxStaticBox swig_types[122]
2589 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[123]
2590 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[124]
2591 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[125]
2592 #define SWIGTYPE_p_wxTGAHandler swig_types[126]
2593 #define SWIGTYPE_p_wxTIFFHandler swig_types[127]
2594 #define SWIGTYPE_p_wxToolTip swig_types[128]
2595 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[129]
2596 #define SWIGTYPE_p_wxValidator swig_types[130]
2597 #define SWIGTYPE_p_wxVisualAttributes swig_types[131]
2598 #define SWIGTYPE_p_wxWindow swig_types[132]
2599 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[133]
2600 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[134]
2601 #define SWIGTYPE_p_wxXPMHandler swig_types[135]
2602 #define SWIGTYPE_p_wxZipFSHandler swig_types[136]
2603 static swig_type_info *swig_types[138];
2604 static swig_module_info swig_module = {swig_types, 137, 0, 0, 0, 0};
2605 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2606 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2607
2608 /* -------- TYPES TABLE (END) -------- */
2609
2610 #if (PY_VERSION_HEX <= 0x02000000)
2611 # if !defined(SWIG_PYTHON_CLASSIC)
2612 # error "This python version requires to use swig with the '-classic' option"
2613 # endif
2614 #endif
2615 #if (PY_VERSION_HEX <= 0x02020000)
2616 # error "This python version requires to use swig with the '-nomodern' option"
2617 #endif
2618 #if (PY_VERSION_HEX <= 0x02020000)
2619 # error "This python version requires to use swig with the '-nomodernargs' option"
2620 #endif
2621 #ifndef METH_O
2622 # error "This python version requires to use swig with the '-nofastunpack' option"
2623 #endif
2624
2625 /*-----------------------------------------------
2626 @(target):= _core_.so
2627 ------------------------------------------------*/
2628 #define SWIG_init init_core_
2629
2630 #define SWIG_name "_core_"
2631
2632 #define SWIGVERSION 0x010329
2633
2634
2635 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2636 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2637
2638
2639 #include <stdexcept>
2640
2641
2642 namespace swig {
2643 class PyObject_ptr {
2644 protected:
2645 PyObject *_obj;
2646
2647 public:
2648 PyObject_ptr() :_obj(0)
2649 {
2650 }
2651
2652 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2653 {
2654 Py_XINCREF(_obj);
2655 }
2656
2657 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2658 {
2659 if (initial_ref) Py_XINCREF(_obj);
2660 }
2661
2662 PyObject_ptr & operator=(const PyObject_ptr& item)
2663 {
2664 Py_XINCREF(item._obj);
2665 Py_XDECREF(_obj);
2666 _obj = item._obj;
2667 return *this;
2668 }
2669
2670 ~PyObject_ptr()
2671 {
2672 Py_XDECREF(_obj);
2673 }
2674
2675 operator PyObject *() const
2676 {
2677 return _obj;
2678 }
2679
2680 PyObject *operator->() const
2681 {
2682 return _obj;
2683 }
2684 };
2685 }
2686
2687
2688 namespace swig {
2689 struct PyObject_var : PyObject_ptr {
2690 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2691
2692 PyObject_var & operator = (PyObject* obj)
2693 {
2694 Py_XDECREF(_obj);
2695 _obj = obj;
2696 return *this;
2697 }
2698 };
2699 }
2700
2701
2702 #include "wx/wxPython/wxPython_int.h"
2703 #include "wx/wxPython/pyclasses.h"
2704 #include "wx/wxPython/twoitem.h"
2705
2706
2707 #ifndef wxPyUSE_EXPORT
2708 // Helper functions for dealing with SWIG objects and such. These are
2709 // located here so they know about the SWIG types and functions declared
2710 // in the wrapper code.
2711
2712 #include <wx/hashmap.h>
2713 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2714
2715
2716 // Maintains a hashmap of className to swig_type_info pointers. Given the
2717 // name of a class either looks up the type info in the cache, or scans the
2718 // SWIG tables for it.
2719 extern PyObject* wxPyPtrTypeMap;
2720 static
2721 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2722
2723 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2724
2725 if (typeInfoCache == NULL)
2726 typeInfoCache = new wxPyTypeInfoHashMap;
2727
2728 wxString name(className);
2729 swig_type_info* swigType = (*typeInfoCache)[name];
2730
2731 if (! swigType) {
2732 // it wasn't in the cache, so look it up from SWIG
2733 name.Append(wxT(" *"));
2734 swigType = SWIG_TypeQuery(name.mb_str());
2735
2736 // if it still wasn't found, try looking for a mapped name
2737 if (!swigType) {
2738 PyObject* item;
2739 name = className;
2740
2741 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2742 (char*)(const char*)name.mbc_str())) != NULL) {
2743 name = wxString(PyString_AsString(item), *wxConvCurrent);
2744 name.Append(wxT(" *"));
2745 swigType = SWIG_TypeQuery(name.mb_str());
2746 }
2747 }
2748 if (swigType) {
2749 // and add it to the map if found
2750 (*typeInfoCache)[className] = swigType;
2751 }
2752 }
2753 return swigType;
2754 }
2755
2756
2757 // Check if a class name is a type known to SWIG
2758 bool wxPyCheckSwigType(const wxChar* className) {
2759
2760 swig_type_info* swigType = wxPyFindSwigType(className);
2761 return swigType != NULL;
2762 }
2763
2764
2765 // Given a pointer to a C++ object and a class name, construct a Python proxy
2766 // object for it.
2767 PyObject* wxPyConstructObject(void* ptr,
2768 const wxChar* className,
2769 int setThisOwn) {
2770
2771 swig_type_info* swigType = wxPyFindSwigType(className);
2772 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2773
2774 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2775 }
2776
2777
2778 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2779 // Ensures that the proxy object is of the specified (or derived) type. If
2780 // not able to perform the conversion then a Python exception is set and the
2781 // error should be handled properly in the caller. Returns True on success.
2782 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2783 const wxChar* className) {
2784
2785 swig_type_info* swigType = wxPyFindSwigType(className);
2786 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2787
2788 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2789 }
2790
2791
2792
2793 // Make a SWIGified pointer object suitable for a .this attribute
2794 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2795
2796 PyObject* robj = NULL;
2797
2798 swig_type_info* swigType = wxPyFindSwigType(className);
2799 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2800
2801 robj = PySwigObject_New(ptr, swigType, 0);
2802 return robj;
2803 }
2804
2805
2806 // Python's PyInstance_Check does not return True for instances of new-style
2807 // classes. This should get close enough for both new and old classes but I
2808 // should re-evaluate the need for doing instance checks...
2809 bool wxPyInstance_Check(PyObject* obj) {
2810 return PyObject_HasAttrString(obj, "__class__") != 0;
2811 }
2812
2813
2814 // This one checks if the object is an instance of a SWIG proxy class (it has
2815 // a .this attribute, and the .this attribute is a PySwigObject.)
2816 bool wxPySwigInstance_Check(PyObject* obj) {
2817 static PyObject* this_str = NULL;
2818 if (this_str == NULL)
2819 this_str = PyString_FromString("this");
2820
2821 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2822 if (this_attr) {
2823 bool retval = (PySwigObject_Check(this_attr) != 0);
2824 Py_DECREF(this_attr);
2825 return retval;
2826 }
2827
2828 PyErr_Clear();
2829 return false;
2830 }
2831
2832
2833 // Export a C API in a struct. Other modules will be able to load this from
2834 // the wx._core_ module and will then have safe access to these functions,
2835 // even if they are located in another shared library.
2836 static wxPyCoreAPI API = {
2837
2838 wxPyCheckSwigType,
2839 wxPyConstructObject,
2840 wxPyConvertSwigPtr,
2841 wxPyMakeSwigPtr,
2842
2843 wxPyBeginAllowThreads,
2844 wxPyEndAllowThreads,
2845 wxPyBeginBlockThreads,
2846 wxPyEndBlockThreads,
2847
2848 wxPy_ConvertList,
2849
2850 wxString_in_helper,
2851 Py2wxString,
2852 wx2PyString,
2853
2854 byte_LIST_helper,
2855 int_LIST_helper,
2856 long_LIST_helper,
2857 string_LIST_helper,
2858 wxPoint_LIST_helper,
2859 wxBitmap_LIST_helper,
2860 wxString_LIST_helper,
2861 wxAcceleratorEntry_LIST_helper,
2862
2863 wxSize_helper,
2864 wxPoint_helper,
2865 wxRealPoint_helper,
2866 wxRect_helper,
2867 wxColour_helper,
2868 wxPoint2D_helper,
2869
2870 wxPySimple_typecheck,
2871 wxColour_typecheck,
2872
2873 wxPyCBH_setCallbackInfo,
2874 wxPyCBH_findCallback,
2875 wxPyCBH_callCallback,
2876 wxPyCBH_callCallbackObj,
2877 wxPyCBH_delete,
2878
2879 wxPyMake_wxObject,
2880 wxPyMake_wxSizer,
2881 wxPyPtrTypeMap_Add,
2882 wxPy2int_seq_helper,
2883 wxPy4int_seq_helper,
2884 wxArrayString2PyList_helper,
2885 wxArrayInt2PyList_helper,
2886
2887 wxPyClientData_dtor,
2888 wxPyUserData_dtor,
2889 wxPyOORClientData_dtor,
2890
2891 wxPyCBInputStream_create,
2892 wxPyCBInputStream_copy,
2893
2894 wxPyInstance_Check,
2895 wxPySwigInstance_Check,
2896
2897 wxPyCheckForApp,
2898
2899 wxArrayDouble2PyList_helper,
2900 wxPoint2D_LIST_helper,
2901 wxRect2D_helper,
2902
2903 };
2904
2905 #endif
2906
2907
2908 #if !WXWIN_COMPATIBILITY_2_4
2909 #define wxHIDE_READONLY 0
2910 #endif
2911
2912
2913 #define SWIG_From_long PyInt_FromLong
2914
2915
2916 SWIGINTERNINLINE PyObject *
2917 SWIG_From_int (int value)
2918 {
2919 return SWIG_From_long (value);
2920 }
2921
2922 static const wxString wxPyEmptyString(wxEmptyString);
2923 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2924 return self->GetClassInfo()->GetClassName();
2925 }
2926 SWIGINTERN void wxObject_Destroy(wxObject *self){
2927 delete self;
2928 }
2929
2930 #ifndef __WXMAC__
2931 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2932 #endif
2933
2934
2935 #include <limits.h>
2936 #ifndef LLONG_MIN
2937 # define LLONG_MIN LONG_LONG_MIN
2938 #endif
2939 #ifndef LLONG_MAX
2940 # define LLONG_MAX LONG_LONG_MAX
2941 #endif
2942 #ifndef ULLONG_MAX
2943 # define ULLONG_MAX ULONG_LONG_MAX
2944 #endif
2945
2946
2947 SWIGINTERN int
2948 SWIG_AsVal_long (PyObject* obj, long* val)
2949 {
2950 if (PyNumber_Check(obj)) {
2951 if (val) *val = PyInt_AsLong(obj);
2952 return SWIG_OK;
2953 }
2954 return SWIG_TypeError;
2955 }
2956
2957
2958 SWIGINTERN int
2959 SWIG_AsVal_int (PyObject * obj, int *val)
2960 {
2961 long v;
2962 int res = SWIG_AsVal_long (obj, &v);
2963 if (SWIG_IsOK(res)) {
2964 if ((v < INT_MIN || v > INT_MAX)) {
2965 return SWIG_OverflowError;
2966 } else {
2967 if (val) *val = static_cast< int >(v);
2968 }
2969 }
2970 return res;
2971 }
2972
2973 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2974 wxSize temp, *obj = &temp;
2975 if ( other == Py_None ) return false;
2976 if ( ! wxSize_helper(other, &obj) ) {
2977 PyErr_Clear();
2978 return false;
2979 }
2980 return self->operator==(*obj);
2981 }
2982 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2983 wxSize temp, *obj = &temp;
2984 if ( other == Py_None ) return true;
2985 if ( ! wxSize_helper(other, &obj)) {
2986 PyErr_Clear();
2987 return true;
2988 }
2989 return self->operator!=(*obj);
2990 }
2991
2992 #include <float.h>
2993
2994
2995 SWIGINTERN int
2996 SWIG_AsVal_double (PyObject *obj, double* val)
2997 {
2998 if (PyNumber_Check(obj)) {
2999 if (val) *val = PyFloat_AsDouble(obj);
3000 return SWIG_OK;
3001 }
3002 return SWIG_TypeError;
3003 }
3004
3005
3006 SWIGINTERN int
3007 SWIG_AsVal_float (PyObject * obj, float *val)
3008 {
3009 double v;
3010 int res = SWIG_AsVal_double (obj, &v);
3011 if (SWIG_IsOK(res)) {
3012 if ((v < -FLT_MAX || v > FLT_MAX)) {
3013 return SWIG_OverflowError;
3014 } else {
3015 if (val) *val = static_cast< float >(v);
3016 }
3017 }
3018 return res;
3019 }
3020
3021 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3022 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3023 PyObject* tup = PyTuple_New(2);
3024 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3025 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3026 //wxPyEndBlockThreads(blocked);
3027 return tup;
3028 }
3029
3030 #define SWIG_From_double PyFloat_FromDouble
3031
3032 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3033 wxRealPoint temp, *obj = &temp;
3034 if ( other == Py_None ) return false;
3035 if ( ! wxRealPoint_helper(other, &obj) ) {
3036 PyErr_Clear();
3037 return false;
3038 }
3039 return self->operator==(*obj);
3040 }
3041 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3042 wxRealPoint temp, *obj = &temp;
3043 if ( other == Py_None ) return true;
3044 if ( ! wxRealPoint_helper(other, &obj)) {
3045 PyErr_Clear();
3046 return true;
3047 }
3048 return self->operator!=(*obj);
3049 }
3050 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3051 self->x = x;
3052 self->y = y;
3053 }
3054 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3055 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3056 PyObject* tup = PyTuple_New(2);
3057 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3058 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3059 //PyEndBlockThreads(blocked);
3060 return tup;
3061 }
3062 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3063 wxPoint temp, *obj = &temp;
3064 if ( other == Py_None ) return false;
3065 if ( ! wxPoint_helper(other, &obj) ) {
3066 PyErr_Clear();
3067 return false;
3068 }
3069 return self->operator==(*obj);
3070 }
3071 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3072 wxPoint temp, *obj = &temp;
3073 if ( other == Py_None ) return true;
3074 if ( ! wxPoint_helper(other, &obj)) {
3075 PyErr_Clear();
3076 return true;
3077 }
3078 return self->operator!=(*obj);
3079 }
3080 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3081 self->x = x;
3082 self->y = y;
3083 }
3084 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3085 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3086 PyObject* tup = PyTuple_New(2);
3087 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3088 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3089 //wxPyEndBlockThreads(blocked);
3090 return tup;
3091 }
3092 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3093 wxRect temp, *obj = &temp;
3094 if ( other == Py_None ) return false;
3095 if ( ! wxRect_helper(other, &obj) ) {
3096 PyErr_Clear();
3097 return false;
3098 }
3099 return self->operator==(*obj);
3100 }
3101 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3102 wxRect temp, *obj = &temp;
3103 if ( other == Py_None ) return true;
3104 if ( ! wxRect_helper(other, &obj)) {
3105 PyErr_Clear();
3106 return true;
3107 }
3108 return self->operator!=(*obj);
3109 }
3110 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3111 self->x = x;
3112 self->y = y;
3113 self->width = width;
3114 self->height = height;
3115 }
3116 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3117 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3118 PyObject* tup = PyTuple_New(4);
3119 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3120 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3121 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3122 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3123 //wxPyEndBlockThreads(blocked);
3124 return tup;
3125 }
3126
3127 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3128 wxRegion reg1(*r1);
3129 wxRegion reg2(*r2);
3130 wxRect dest(0,0,0,0);
3131 PyObject* obj;
3132
3133 reg1.Intersect(reg2);
3134 dest = reg1.GetBox();
3135
3136 if (dest != wxRect(0,0,0,0)) {
3137 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3138 wxRect* newRect = new wxRect(dest);
3139 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3140 //wxPyEndBlockThreads(blocked);
3141 return obj;
3142 }
3143 Py_INCREF(Py_None);
3144 return Py_None;
3145 }
3146
3147 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3148 wxPoint2D temp, *obj = &temp;
3149 if ( other == Py_None ) return false;
3150 if ( ! wxPoint2D_helper(other, &obj) ) {
3151 PyErr_Clear();
3152 return false;
3153 }
3154 return self->operator==(*obj);
3155 }
3156 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3157 wxPoint2D temp, *obj = &temp;
3158 if ( other == Py_None ) return true;
3159 if ( ! wxPoint2D_helper(other, &obj)) {
3160 PyErr_Clear();
3161 return true;
3162 }
3163 return self->operator!=(*obj);
3164 }
3165 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3166 self->m_x = x;
3167 self->m_y = y;
3168 }
3169 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3170 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3171 PyObject* tup = PyTuple_New(2);
3172 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3173 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3174 //wxPyEndBlockThreads(blocked);
3175 return tup;
3176 }
3177 SWIGINTERN bool wxRect2D___eq__(wxRect2D *self,PyObject *other){
3178 wxRect2D temp, *obj = &temp;
3179 if ( other == Py_None ) return false;
3180 if ( ! wxRect2D_helper(other, &obj) ) {
3181 PyErr_Clear();
3182 return false;
3183 }
3184 return self->operator==(*obj);
3185 }
3186 SWIGINTERN bool wxRect2D___ne__(wxRect2D *self,PyObject *other){
3187 wxRect2D temp, *obj = &temp;
3188 if ( other == Py_None ) return true;
3189 if ( ! wxRect2D_helper(other, &obj)) {
3190 PyErr_Clear();
3191 return true;
3192 }
3193 return self->operator!=(*obj);
3194 }
3195 SWIGINTERN void wxRect2D_Set(wxRect2D *self,wxDouble x=0,wxDouble y=0,wxDouble width=0,wxDouble height=0){
3196 self->m_x = x;
3197 self->m_y = y;
3198 self->m_width = width;
3199 self->m_height = height;
3200 }
3201 SWIGINTERN PyObject *wxRect2D_Get(wxRect2D *self){
3202 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3203 PyObject* tup = PyTuple_New(4);
3204 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3205 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3206 PyTuple_SET_ITEM(tup, 2, PyFloat_FromDouble(self->m_width));
3207 PyTuple_SET_ITEM(tup, 3, PyFloat_FromDouble(self->m_height));
3208 //wxPyEndBlockThreads(blocked);
3209 return tup;
3210 }
3211
3212 #include "wx/wxPython/pyistream.h"
3213
3214 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3215 wxInputStream* wxis = wxPyCBInputStream::create(p);
3216 if (wxis)
3217 return new wxPyInputStream(wxis);
3218 else
3219 return NULL;
3220 }
3221
3222 SWIGINTERN swig_type_info*
3223 SWIG_pchar_descriptor()
3224 {
3225 static int init = 0;
3226 static swig_type_info* info = 0;
3227 if (!init) {
3228 info = SWIG_TypeQuery("_p_char");
3229 init = 1;
3230 }
3231 return info;
3232 }
3233
3234
3235 SWIGINTERNINLINE PyObject *
3236 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3237 {
3238 if (carray) {
3239 if (size > INT_MAX) {
3240 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3241 return pchar_descriptor ?
3242 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3243 } else {
3244 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3245 }
3246 } else {
3247 return SWIG_Py_Void();
3248 }
3249 }
3250
3251
3252 SWIGINTERNINLINE PyObject *
3253 SWIG_From_char (char c)
3254 {
3255 return SWIG_FromCharPtrAndSize(&c,1);
3256 }
3257
3258
3259 SWIGINTERNINLINE PyObject*
3260 SWIG_From_unsigned_SS_long (unsigned long value)
3261 {
3262 return (value > LONG_MAX) ?
3263 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3264 }
3265
3266
3267 SWIGINTERNINLINE PyObject *
3268 SWIG_From_size_t (size_t value)
3269 {
3270 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3271 }
3272
3273
3274 SWIGINTERN int
3275 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3276 {
3277 if (PyString_Check(obj)) {
3278 char *cstr; Py_ssize_t len;
3279 PyString_AsStringAndSize(obj, &cstr, &len);
3280 if (cptr) {
3281 if (alloc) {
3282 /*
3283 In python the user should not be able to modify the inner
3284 string representation. To warranty that, if you define
3285 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3286 buffer is always returned.
3287
3288 The default behavior is just to return the pointer value,
3289 so, be careful.
3290 */
3291 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3292 if (*alloc != SWIG_OLDOBJ)
3293 #else
3294 if (*alloc == SWIG_NEWOBJ)
3295 #endif
3296 {
3297 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3298 *alloc = SWIG_NEWOBJ;
3299 }
3300 else {
3301 *cptr = cstr;
3302 *alloc = SWIG_OLDOBJ;
3303 }
3304 } else {
3305 *cptr = PyString_AsString(obj);
3306 }
3307 }
3308 if (psize) *psize = len + 1;
3309 return SWIG_OK;
3310 } else {
3311 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3312 if (pchar_descriptor) {
3313 void* vptr = 0;
3314 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3315 if (cptr) *cptr = (char *) vptr;
3316 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3317 if (alloc) *alloc = SWIG_OLDOBJ;
3318 return SWIG_OK;
3319 }
3320 }
3321 }
3322 return SWIG_TypeError;
3323 }
3324
3325
3326 SWIGINTERN int
3327 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3328 {
3329 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3330 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3331 if (SWIG_IsOK(res)) {
3332 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3333 if (csize <= size) {
3334 if (val) {
3335 if (csize) memcpy(val, cptr, csize*sizeof(char));
3336 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3337 }
3338 if (alloc == SWIG_NEWOBJ) {
3339 delete[] cptr;
3340 res = SWIG_DelNewMask(res);
3341 }
3342 return res;
3343 }
3344 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3345 }
3346 return SWIG_TypeError;
3347 }
3348
3349
3350 SWIGINTERN int
3351 SWIG_AsVal_char (PyObject * obj, char *val)
3352 {
3353 int res = SWIG_AsCharArray(obj, val, 1);
3354 if (!SWIG_IsOK(res)) {
3355 long v;
3356 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3357 if (SWIG_IsOK(res)) {
3358 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3359 if (val) *val = static_cast< char >(v);
3360 } else {
3361 res = SWIG_OverflowError;
3362 }
3363 }
3364 }
3365 return res;
3366 }
3367
3368 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3369 // We use only strings for the streams, not unicode
3370 PyObject* str = PyObject_Str(obj);
3371 if (! str) {
3372 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3373 return;
3374 }
3375 self->Write(PyString_AS_STRING(str),
3376 PyString_GET_SIZE(str));
3377 Py_DECREF(str);
3378 }
3379
3380 #include "wx/wxPython/pyistream.h"
3381
3382
3383 class wxPyFileSystemHandler : public wxFileSystemHandler
3384 {
3385 public:
3386 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3387
3388 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3389 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3390 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3391 DEC_PYCALLBACK_STRING__pure(FindNext);
3392
3393 wxString GetProtocol(const wxString& location) {
3394 return wxFileSystemHandler::GetProtocol(location);
3395 }
3396
3397 wxString GetLeftLocation(const wxString& location) {
3398 return wxFileSystemHandler::GetLeftLocation(location);
3399 }
3400
3401 wxString GetAnchor(const wxString& location) {
3402 return wxFileSystemHandler::GetAnchor(location);
3403 }
3404
3405 wxString GetRightLocation(const wxString& location) {
3406 return wxFileSystemHandler::GetRightLocation(location);
3407 }
3408
3409 wxString GetMimeTypeFromExt(const wxString& location) {
3410 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3411 }
3412
3413 PYPRIVATE;
3414 };
3415
3416
3417 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3418 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3419 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3420 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3421
3422
3423 SWIGINTERN int
3424 SWIG_AsVal_bool (PyObject *obj, bool *val)
3425 {
3426 if (obj == Py_True) {
3427 if (val) *val = true;
3428 return SWIG_OK;
3429 } else if (obj == Py_False) {
3430 if (val) *val = false;
3431 return SWIG_OK;
3432 } else {
3433 long v = 0;
3434 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3435 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3436 return res;
3437 }
3438 }
3439
3440 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3441 wxFileName fname = wxFileSystem::URLToFileName(url);
3442 return fname.GetFullPath();
3443 }
3444
3445 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3446 wxImage& image,
3447 long type) {
3448 wxMemoryFSHandler::AddFile(filename, image, type);
3449 }
3450
3451 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3452 const wxBitmap& bitmap,
3453 long type) {
3454 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3455 }
3456
3457 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3458 PyObject* data) {
3459 if (! PyString_Check(data)) {
3460 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3461 "Expected string object"));
3462 return;
3463 }
3464
3465 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3466 void* ptr = (void*)PyString_AsString(data);
3467 size_t size = PyString_Size(data);
3468 wxPyEndBlockThreads(blocked);
3469
3470 wxMemoryFSHandler::AddFile(filename, ptr, size);
3471 }
3472
3473
3474 #include "wx/wxPython/pyistream.h"
3475
3476
3477 SWIGINTERN int
3478 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3479 {
3480 long v = 0;
3481 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3482 return SWIG_TypeError;
3483 }
3484 else if (val)
3485 *val = (unsigned long)v;
3486 return SWIG_OK;
3487 }
3488
3489
3490 SWIGINTERN int
3491 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3492 {
3493 unsigned long v;
3494 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3495 if (SWIG_IsOK(res)) {
3496 if ((v > UCHAR_MAX)) {
3497 return SWIG_OverflowError;
3498 } else {
3499 if (val) *val = static_cast< unsigned char >(v);
3500 }
3501 }
3502 return res;
3503 }
3504
3505
3506 SWIGINTERNINLINE PyObject *
3507 SWIG_From_unsigned_SS_char (unsigned char value)
3508 {
3509 return SWIG_From_unsigned_SS_long (value);
3510 }
3511
3512 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3513 wxImageHistogramEntry e = (*self)[key];
3514 return e.value;
3515 }
3516 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3517 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3518 wxImageHistogramEntry e = (*self)[key];
3519 return e.value;
3520 }
3521 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3522 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3523 colour.Green(),
3524 colour.Blue());
3525 wxImageHistogramEntry e = (*self)[key];
3526 return e.value;
3527 }
3528
3529 // Pull the nested class out to the top level for SWIG's sake
3530 #define wxImage_RGBValue wxImage::RGBValue
3531 #define wxImage_HSVValue wxImage::HSVValue
3532
3533 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3534 if (width > 0 && height > 0)
3535 return new wxImage(width, height, clear);
3536 else
3537 return new wxImage;
3538 }
3539 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3540 return new wxImage(bitmap.ConvertToImage());
3541 }
3542 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3543 if (DATASIZE != width*height*3) {
3544 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3545 return NULL;
3546 }
3547
3548 // Copy the source data so the wxImage can clean it up later
3549 buffer copy = (buffer)malloc(DATASIZE);
3550 if (copy == NULL) {
3551 wxPyBLOCK_THREADS(PyErr_NoMemory());
3552 return NULL;
3553 }
3554 memcpy(copy, data, DATASIZE);
3555 return new wxImage(width, height, copy, false);
3556 }
3557 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3558 if (DATASIZE != width*height*3) {
3559 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3560 return NULL;
3561 }
3562 if (ALPHASIZE != width*height) {
3563 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3564 return NULL;
3565 }
3566
3567 // Copy the source data so the wxImage can clean it up later
3568 buffer dcopy = (buffer)malloc(DATASIZE);
3569 if (dcopy == NULL) {
3570 wxPyBLOCK_THREADS(PyErr_NoMemory());
3571 return NULL;
3572 }
3573 memcpy(dcopy, data, DATASIZE);
3574
3575 buffer acopy = (buffer)malloc(ALPHASIZE);
3576 if (acopy == NULL) {
3577 wxPyBLOCK_THREADS(PyErr_NoMemory());
3578 return NULL;
3579 }
3580 memcpy(acopy, alpha, ALPHASIZE);
3581
3582 return new wxImage(width, height, dcopy, acopy, false);
3583 }
3584 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3585 wxSize size(self->GetWidth(), self->GetHeight());
3586 return size;
3587 }
3588 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3589 buffer data = self->GetData();
3590 int len = self->GetWidth() * self->GetHeight() * 3;
3591 PyObject* rv;
3592 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3593 return rv;
3594 }
3595 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3596 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3597 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3598 return;
3599 }
3600 buffer copy = (buffer)malloc(DATASIZE);
3601 if (copy == NULL) {
3602 wxPyBLOCK_THREADS(PyErr_NoMemory());
3603 return;
3604 }
3605 memcpy(copy, data, DATASIZE);
3606 self->SetData(copy, false);
3607 // wxImage takes ownership of copy...
3608 }
3609 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3610 buffer data = self->GetData();
3611 int len = self->GetWidth() * self->GetHeight() * 3;
3612 PyObject* rv;
3613 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3614 return rv;
3615 }
3616 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3617 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3618 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3619 return;
3620 }
3621 self->SetData(data, true);
3622 }
3623 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3624 buffer data = self->GetAlpha();
3625 if (! data) {
3626 RETURN_NONE();
3627 } else {
3628 int len = self->GetWidth() * self->GetHeight();
3629 PyObject* rv;
3630 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3631 return rv;
3632 }
3633 }
3634 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3635 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3636 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3637 return;
3638 }
3639 buffer acopy = (buffer)malloc(ALPHASIZE);
3640 if (acopy == NULL) {
3641 wxPyBLOCK_THREADS(PyErr_NoMemory());
3642 return;
3643 }
3644 memcpy(acopy, alpha, ALPHASIZE);
3645 self->SetAlpha(acopy, false);
3646 // wxImage takes ownership of acopy...
3647 }
3648 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3649 buffer data = self->GetAlpha();
3650 int len = self->GetWidth() * self->GetHeight();
3651 PyObject* rv;
3652 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3653 return rv;
3654 }
3655 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3656 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3657 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3658 return;
3659 }
3660 self->SetAlpha(alpha, true);
3661 }
3662 SWIGINTERN PyObject *wxImage_GetHandlers(){
3663 wxList& list = wxImage::GetHandlers();
3664 return wxPy_ConvertList(&list);
3665 }
3666 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3667 wxBitmap bitmap(*self, depth);
3668 return bitmap;
3669 }
3670 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3671 wxImage mono = self->ConvertToMono( red, green, blue );
3672 wxBitmap bitmap( mono, 1 );
3673 return bitmap;
3674 }
3675
3676 wxImage* _ImageFromBuffer(int width, int height,
3677 buffer data, int DATASIZE,
3678 buffer alpha=NULL, int ALPHASIZE=0)
3679 {
3680 if (DATASIZE != width*height*3) {
3681 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3682 return NULL;
3683 }
3684 if (alpha != NULL) {
3685 if (ALPHASIZE != width*height) {
3686 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3687 return NULL;
3688 }
3689 return new wxImage(width, height, data, alpha, true);
3690 }
3691 return new wxImage(width, height, data, true);
3692 }
3693
3694 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3695 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3696 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3697 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3698 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3699 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3700 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3701 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3702 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3703 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3704 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3705 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3706 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3707 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3708 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3709
3710 #include <wx/imagtga.h>
3711
3712
3713 #include <wx/quantize.h>
3714
3715 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3716 return wxQuantize::Quantize(src, dest,
3717 //NULL, // palette
3718 desiredNoColours,
3719 NULL, // eightBitData
3720 flags);
3721 }
3722 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3723 if (PyCallable_Check(func)) {
3724 self->Connect(id, lastId, eventType,
3725 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3726 new wxPyCallback(func));
3727 }
3728 else if (func == Py_None) {
3729 self->Disconnect(id, lastId, eventType,
3730 (wxObjectEventFunction)
3731 &wxPyCallback::EventThunker);
3732 }
3733 else {
3734 wxPyBLOCK_THREADS(
3735 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3736 }
3737 }
3738 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3739 return self->Disconnect(id, lastId, eventType,
3740 (wxObjectEventFunction)
3741 &wxPyCallback::EventThunker);
3742 }
3743 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3744 if (_self && _self != Py_None) {
3745 self->SetClientObject(new wxPyOORClientData(_self, incref));
3746 }
3747 else {
3748 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3749 if (data) {
3750 self->SetClientObject(NULL); // This will delete it too
3751 }
3752 }
3753 }
3754
3755 #if ! wxUSE_HOTKEY
3756 #define wxEVT_HOTKEY -9999
3757 #endif
3758
3759 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3760 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3761 if (data) {
3762 Py_INCREF(data->m_obj);
3763 return data->m_obj;
3764 } else {
3765 Py_INCREF(Py_None);
3766 return Py_None;
3767 }
3768 }
3769 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3770 wxPyClientData* data = new wxPyClientData(clientData);
3771 self->SetClientObject(data);
3772 }
3773 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3774 #if wxUSE_UNICODE
3775 return self->GetUnicodeKey();
3776 #else
3777 return 0;
3778 #endif
3779 }
3780 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3781 #if wxUSE_UNICODE
3782 self->m_uniChar = uniChar;
3783 #endif
3784 }
3785
3786 SWIGINTERNINLINE PyObject *
3787 SWIG_From_unsigned_SS_int (unsigned int value)
3788 {
3789 return SWIG_From_unsigned_SS_long (value);
3790 }
3791
3792
3793 SWIGINTERN int
3794 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3795 {
3796 unsigned long v;
3797 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3798 if (SWIG_IsOK(res)) {
3799 if ((v > UINT_MAX)) {
3800 return SWIG_OverflowError;
3801 } else {
3802 if (val) *val = static_cast< unsigned int >(v);
3803 }
3804 }
3805 return res;
3806 }
3807
3808 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3809 self->m_size = size;
3810 }
3811 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3812 int count = self->GetNumberOfFiles();
3813 wxString* files = self->GetFiles();
3814 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3815 PyObject* list = PyList_New(count);
3816
3817 if (!list) {
3818 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3819 wxPyEndBlockThreads(blocked);
3820 return NULL;
3821 }
3822
3823 for (int i=0; i<count; i++) {
3824 PyList_SetItem(list, i, wx2PyString(files[i]));
3825 }
3826 wxPyEndBlockThreads(blocked);
3827 return list;
3828 }
3829
3830
3831 SWIGINTERN wxPyApp *new_wxPyApp(){
3832 wxPythonApp = new wxPyApp();
3833 return wxPythonApp;
3834 }
3835 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3836 return wxPyTestDisplayAvailable();
3837 }
3838
3839 void wxApp_CleanUp() {
3840 __wxPyCleanup();
3841 }
3842
3843
3844 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3845
3846
3847
3848
3849
3850 SWIGINTERNINLINE PyObject *
3851 SWIG_FromCharPtr(const char *cptr)
3852 {
3853 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3854 }
3855
3856
3857 #if 0 // #ifdef __WXMAC__
3858
3859 // A dummy class that raises an exception if used...
3860 class wxEventLoop
3861 {
3862 public:
3863 wxEventLoop() { wxPyRaiseNotImplemented(); }
3864 int Run() { return 0; }
3865 void Exit(int rc = 0) {}
3866 bool Pending() const { return false; }
3867 bool Dispatch() { return false; }
3868 bool IsRunning() const { return false; }
3869 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3870 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3871 };
3872
3873 #else
3874
3875 #include <wx/evtloop.h>
3876
3877 #endif
3878
3879
3880
3881 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3882 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3883 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3884 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3885 wxWindowList& list = self->GetChildren();
3886 return wxPy_ConvertList(&list);
3887 }
3888 SWIGINTERN wxWindow *wxWindow_GetTopLevelParent(wxWindow *self){
3889 return wxGetTopLevelParent(self);
3890 }
3891 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3892 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3893 #if wxUSE_HOTKEY
3894 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3895 #else
3896 return false;
3897 #endif
3898 }
3899 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3900
3901
3902
3903 return false;
3904
3905 }
3906 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3907 return wxPyGetWinHandle(self);
3908 }
3909 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3910 self->AssociateHandle((WXWidget)handle);
3911 }
3912
3913 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3914 return wxWindow::FindWindowById(id, parent);
3915 }
3916
3917 wxWindow* wxFindWindowByName( const wxString& name,
3918 const wxWindow *parent = NULL ) {
3919 return wxWindow::FindWindowByName(name, parent);
3920 }
3921
3922 wxWindow* wxFindWindowByLabel( const wxString& label,
3923 const wxWindow *parent = NULL ) {
3924 return wxWindow::FindWindowByLabel(label, parent);
3925 }
3926
3927
3928 #ifdef __WXMSW__
3929 #include <wx/msw/private.h> // to get wxGetWindowId
3930 #endif
3931
3932
3933 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3934 #ifdef __WXMSW__
3935 WXHWND hWnd = (WXHWND)_hWnd;
3936 long id = wxGetWindowId(hWnd);
3937 wxWindow* win = new wxWindow;
3938 if (parent)
3939 parent->AddChild(win);
3940 win->SetEventHandler(win);
3941 win->SetHWND(hWnd);
3942 win->SetId(id);
3943 win->SubclassWin(hWnd);
3944 win->AdoptAttributesFromHWND();
3945 win->SetupColours();
3946 return win;
3947 #else
3948 wxPyRaiseNotImplemented();
3949 return NULL;
3950 #endif
3951 }
3952
3953
3954 PyObject* GetTopLevelWindows() {
3955 return wxPy_ConvertList(&wxTopLevelWindows);
3956 }
3957
3958
3959 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3960 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3961 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3962
3963 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3964
3965
3966 SWIGINTERNINLINE int
3967 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3968 {
3969 unsigned long v;
3970 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3971 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3972 return res;
3973 }
3974
3975 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3976 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3977 wxMenuItemList& list = self->GetMenuItems();
3978 return wxPy_ConvertList(&list);
3979 }
3980 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3981 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3982 static const wxString wxPyControlNameStr(wxControlNameStr);
3983 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3984 if (clientData) {
3985 wxPyClientData* data = new wxPyClientData(clientData);
3986 return self->Append(item, data);
3987 } else
3988 return self->Append(item);
3989 }
3990 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
3991 if (clientData) {
3992 wxPyClientData* data = new wxPyClientData(clientData);
3993 return self->Insert(item, pos, data);
3994 } else
3995 return self->Insert(item, pos);
3996 }
3997 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
3998 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3999 if (data) {
4000 Py_INCREF(data->m_obj);
4001 return data->m_obj;
4002 } else {
4003 Py_INCREF(Py_None);
4004 return Py_None;
4005 }
4006 }
4007 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
4008 wxPyClientData* data = new wxPyClientData(clientData);
4009 self->SetClientObject(n, data);
4010 }
4011
4012
4013 SWIGINTERN wxSizerFlags &wxSizerFlags_Border(wxSizerFlags *self,int direction=wxALL,int borderInPixels=-1){
4014 if (borderInPixels == -1)
4015 return self->Border(direction);
4016 else
4017 return self->Border(direction, borderInPixels);
4018 }
4019 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
4020 wxPyUserData* data = NULL;
4021 if ( userData ) {
4022 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4023 data = new wxPyUserData(userData);
4024 wxPyEndBlockThreads(blocked);
4025 }
4026 return new wxSizerItem(window, proportion, flag, border, data);
4027 }
4028 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
4029 wxPyUserData* data = NULL;
4030 if ( userData ) {
4031 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4032 data = new wxPyUserData(userData);
4033 wxPyEndBlockThreads(blocked);
4034 }
4035 return new wxSizerItem(width, height, proportion, flag, border, data);
4036 }
4037 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
4038 wxPyUserData* data = NULL;
4039 if ( userData ) {
4040 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4041 data = new wxPyUserData(userData);
4042 wxPyEndBlockThreads(blocked);
4043 }
4044 return new wxSizerItem(sizer, proportion, flag, border, data);
4045 }
4046
4047 SWIGINTERNINLINE PyObject *
4048 SWIG_From_float (float value)
4049 {
4050 return SWIG_From_double (value);
4051 }
4052
4053 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4054 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4055 if (data) {
4056 Py_INCREF(data->m_obj);
4057 return data->m_obj;
4058 } else {
4059 Py_INCREF(Py_None);
4060 return Py_None;
4061 }
4062 }
4063 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4064 wxPyUserData* data = NULL;
4065 if ( userData ) {
4066 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4067 data = new wxPyUserData(userData);
4068 wxPyEndBlockThreads(blocked);
4069 }
4070 self->SetUserData(data);
4071 }
4072
4073 // Figure out the type of the sizer item
4074
4075 struct wxPySizerItemInfo {
4076 wxPySizerItemInfo()
4077 : window(NULL), sizer(NULL), gotSize(false),
4078 size(wxDefaultSize), gotPos(false), pos(-1)
4079 {}
4080
4081 wxWindow* window;
4082 wxSizer* sizer;
4083 bool gotSize;
4084 wxSize size;
4085 bool gotPos;
4086 int pos;
4087 };
4088
4089 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4090
4091 wxPySizerItemInfo info;
4092 wxSize size;
4093 wxSize* sizePtr = &size;
4094
4095 // Find out what the type of the item is
4096 // try wxWindow
4097 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4098 PyErr_Clear();
4099 info.window = NULL;
4100
4101 // try wxSizer
4102 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4103 PyErr_Clear();
4104 info.sizer = NULL;
4105
4106 // try wxSize or (w,h)
4107 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4108 info.size = *sizePtr;
4109 info.gotSize = true;
4110 }
4111
4112 // or a single int
4113 if (checkIdx && PyInt_Check(item)) {
4114 info.pos = PyInt_AsLong(item);
4115 info.gotPos = true;
4116 }
4117 }
4118 }
4119
4120 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4121 // no expected type, figure out what kind of error message to generate
4122 if ( !checkSize && !checkIdx )
4123 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4124 else if ( checkSize && !checkIdx )
4125 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4126 else if ( !checkSize && checkIdx)
4127 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4128 else
4129 // can this one happen?
4130 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4131 }
4132
4133 return info;
4134 }
4135
4136 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4137 if (!self->GetClientObject())
4138 self->SetClientObject(new wxPyOORClientData(_self));
4139 }
4140 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4141
4142 wxPyUserData* data = NULL;
4143 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4144 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4145 if ( userData && (info.window || info.sizer || info.gotSize) )
4146 data = new wxPyUserData(userData);
4147 if ( info.sizer )
4148 PyObject_SetAttrString(item,"thisown",Py_False);
4149 wxPyEndBlockThreads(blocked);
4150
4151 // Now call the real Add method if a valid item type was found
4152 if ( info.window )
4153 return self->Add(info.window, proportion, flag, border, data);
4154 else if ( info.sizer )
4155 return self->Add(info.sizer, proportion, flag, border, data);
4156 else if (info.gotSize)
4157 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4158 proportion, flag, border, data);
4159 else
4160 return NULL;
4161 }
4162 SWIGINTERN wxSizerItem *wxSizer_AddF(wxSizer *self,PyObject *item,wxSizerFlags &flags){
4163
4164 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4165 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4166 if ( info.sizer )
4167 PyObject_SetAttrString(item,"thisown",Py_False);
4168 wxPyEndBlockThreads(blocked);
4169
4170 // Now call the real Add method if a valid item type was found
4171 if ( info.window )
4172 return self->Add(info.window, flags);
4173 else if ( info.sizer )
4174 return self->Add(info.sizer, flags);
4175 else if (info.gotSize)
4176 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4177 flags.GetProportion(),
4178 flags.GetFlags(),
4179 flags.GetBorderInPixels());
4180 else
4181 return NULL;
4182 }
4183 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4184
4185 wxPyUserData* data = NULL;
4186 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4187 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4188 if ( userData && (info.window || info.sizer || info.gotSize) )
4189 data = new wxPyUserData(userData);
4190 if ( info.sizer )
4191 PyObject_SetAttrString(item,"thisown",Py_False);
4192 wxPyEndBlockThreads(blocked);
4193
4194 // Now call the real Insert method if a valid item type was found
4195 if ( info.window )
4196 return self->Insert(before, info.window, proportion, flag, border, data);
4197 else if ( info.sizer )
4198 return self->Insert(before, info.sizer, proportion, flag, border, data);
4199 else if (info.gotSize)
4200 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4201 proportion, flag, border, data);
4202 else
4203 return NULL;
4204 }
4205 SWIGINTERN wxSizerItem *wxSizer_InsertF(wxSizer *self,int before,PyObject *item,wxSizerFlags &flags){
4206
4207 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4208 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4209 if ( info.sizer )
4210 PyObject_SetAttrString(item,"thisown",Py_False);
4211 wxPyEndBlockThreads(blocked);
4212
4213 // Now call the real Insert method if a valid item type was found
4214 if ( info.window )
4215 return self->Insert(before, info.window, flags);
4216 else if ( info.sizer )
4217 return self->Insert(before, info.sizer, flags);
4218 else if (info.gotSize)
4219 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4220 flags.GetProportion(),
4221 flags.GetFlags(),
4222 flags.GetBorderInPixels());
4223 else
4224 return NULL;
4225 }
4226 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4227
4228 wxPyUserData* data = NULL;
4229 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4230 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4231 if ( userData && (info.window || info.sizer || info.gotSize) )
4232 data = new wxPyUserData(userData);
4233 if ( info.sizer )
4234 PyObject_SetAttrString(item,"thisown",Py_False);
4235 wxPyEndBlockThreads(blocked);
4236
4237 // Now call the real Prepend method if a valid item type was found
4238 if ( info.window )
4239 return self->Prepend(info.window, proportion, flag, border, data);
4240 else if ( info.sizer )
4241 return self->Prepend(info.sizer, proportion, flag, border, data);
4242 else if (info.gotSize)
4243 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4244 proportion, flag, border, data);
4245 else
4246 return NULL;
4247 }
4248 SWIGINTERN wxSizerItem *wxSizer_PrependF(wxSizer *self,PyObject *item,wxSizerFlags &flags){
4249
4250 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4251 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4252 if ( info.sizer )
4253 PyObject_SetAttrString(item,"thisown",Py_False);
4254 wxPyEndBlockThreads(blocked);
4255
4256 // Now call the real Add method if a valid item type was found
4257 if ( info.window )
4258 return self->Prepend(info.window, flags);
4259 else if ( info.sizer )
4260 return self->Prepend(info.sizer, flags);
4261 else if (info.gotSize)
4262 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4263 flags.GetProportion(),
4264 flags.GetFlags(),
4265 flags.GetBorderInPixels());
4266 else
4267 return NULL;
4268 }
4269 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4270 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4271 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4272 wxPyEndBlockThreads(blocked);
4273 if ( info.window )
4274 return false; //self->Remove(info.window);
4275 else if ( info.sizer )
4276 return self->Remove(info.sizer);
4277 else if ( info.gotPos )
4278 return self->Remove(info.pos);
4279 else
4280 return false;
4281 }
4282 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4283 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4284 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4285 wxPyEndBlockThreads(blocked);
4286 if ( info.window )
4287 return self->Detach(info.window);
4288 else if ( info.sizer )
4289 return self->Detach(info.sizer);
4290 else if ( info.gotPos )
4291 return self->Detach(info.pos);
4292 else
4293 return false;
4294 }
4295 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item,bool recursive=false){
4296 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4297 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4298 wxPyEndBlockThreads(blocked);
4299 if ( info.window )
4300 return self->GetItem(info.window, recursive);
4301 else if ( info.sizer )
4302 return self->GetItem(info.sizer, recursive);
4303 else if ( info.gotPos )
4304 return self->GetItem(info.pos);
4305 else
4306 return NULL;
4307 }
4308 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4309 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4310 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4311 wxPyEndBlockThreads(blocked);
4312 if ( info.window )
4313 self->SetItemMinSize(info.window, size);
4314 else if ( info.sizer )
4315 self->SetItemMinSize(info.sizer, size);
4316 else if ( info.gotPos )
4317 self->SetItemMinSize(info.pos, size);
4318 }
4319 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4320 wxSizerItemList& list = self->GetChildren();
4321 return wxPy_ConvertList(&list);
4322 }
4323 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4324 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4325 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4326 wxPyEndBlockThreads(blocked);
4327 if ( info.window )
4328 return self->Show(info.window, show, recursive);
4329 else if ( info.sizer )
4330 return self->Show(info.sizer, show, recursive);
4331 else if ( info.gotPos )
4332 return self->Show(info.pos, show);
4333 else
4334 return false;
4335 }
4336 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4337 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4338 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4339 wxPyEndBlockThreads(blocked);
4340 if ( info.window )
4341 return self->IsShown(info.window);
4342 else if ( info.sizer )
4343 return self->IsShown(info.sizer);
4344 else if ( info.gotPos )
4345 return self->IsShown(info.pos);
4346 else
4347 return false;
4348 }
4349
4350 // See pyclasses.h
4351 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4352 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4353 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4354
4355
4356
4357
4358 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4359 {
4360 if (source == Py_None) {
4361 **obj = wxGBPosition(-1,-1);
4362 return true;
4363 }
4364 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4365 }
4366
4367 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4368 {
4369 if (source == Py_None) {
4370 **obj = wxGBSpan(-1,-1);
4371 return true;
4372 }
4373 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4374 }
4375
4376
4377 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4378 wxGBPosition temp, *obj = &temp;
4379 if ( other == Py_None ) return false;
4380 if ( ! wxGBPosition_helper(other, &obj) ) {
4381 PyErr_Clear();
4382 return false;
4383 }
4384 return self->operator==(*obj);
4385 }
4386 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4387 wxGBPosition temp, *obj = &temp;
4388 if ( other == Py_None ) return true;
4389 if ( ! wxGBPosition_helper(other, &obj)) {
4390 PyErr_Clear();
4391 return true;
4392 }
4393 return self->operator!=(*obj);
4394 }
4395 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4396 self->SetRow(row);
4397 self->SetCol(col);
4398 }
4399 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4400 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4401 PyObject* tup = PyTuple_New(2);
4402 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4403 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4404 wxPyEndBlockThreads(blocked);
4405 return tup;
4406 }
4407 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4408 wxGBSpan temp, *obj = &temp;
4409 if ( other == Py_None ) return false;
4410 if ( ! wxGBSpan_helper(other, &obj) ) {
4411 PyErr_Clear();
4412 return false;
4413 }
4414 return self->operator==(*obj);
4415 }
4416 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4417 wxGBSpan temp, *obj = &temp;
4418 if ( other == Py_None ) return true;
4419 if ( ! wxGBSpan_helper(other, &obj)) {
4420 PyErr_Clear();
4421 return true;
4422 }
4423 return self->operator!=(*obj);
4424 }
4425 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4426 self->SetRowspan(rowspan);
4427 self->SetColspan(colspan);
4428 }
4429 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4430 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4431 PyObject* tup = PyTuple_New(2);
4432 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4433 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4434 wxPyEndBlockThreads(blocked);
4435 return tup;
4436 }
4437 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4438 wxPyUserData* data = NULL;
4439 if ( userData ) {
4440 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4441 data = new wxPyUserData(userData);
4442 wxPyEndBlockThreads(blocked);
4443 }
4444 return new wxGBSizerItem(window, pos, span, flag, border, data);
4445 }
4446 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4447 wxPyUserData* data = NULL;
4448 if ( userData ) {
4449 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4450 data = new wxPyUserData(userData);
4451 wxPyEndBlockThreads(blocked);
4452 }
4453 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4454 }
4455 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4456 wxPyUserData* data = NULL;
4457 if ( userData ) {
4458 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4459 data = new wxPyUserData(userData);
4460 wxPyEndBlockThreads(blocked);
4461 }
4462 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4463 }
4464 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4465 int row, col;
4466 self->GetEndPos(row, col);
4467 return wxGBPosition(row, col);
4468 }
4469 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4470
4471 wxPyUserData* data = NULL;
4472 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4473 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4474 if ( userData && (info.window || info.sizer || info.gotSize) )
4475 data = new wxPyUserData(userData);
4476 if ( info.sizer )
4477 PyObject_SetAttrString(item,"thisown",Py_False);
4478 wxPyEndBlockThreads(blocked);
4479
4480 // Now call the real Add method if a valid item type was found
4481 if ( info.window )
4482 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4483 else if ( info.sizer )
4484 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4485 else if (info.gotSize)
4486 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4487 pos, span, flag, border, data);
4488 return NULL;
4489 }
4490
4491
4492 #ifdef __cplusplus
4493 extern "C" {
4494 #endif
4495 SWIGINTERN int EmptyString_set(PyObject *) {
4496 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4497 return 1;
4498 }
4499
4500
4501 SWIGINTERN PyObject *EmptyString_get(void) {
4502 PyObject *pyobj = 0;
4503
4504 {
4505 #if wxUSE_UNICODE
4506 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4507 #else
4508 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4509 #endif
4510 }
4511 return pyobj;
4512 }
4513
4514
4515 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4516 PyObject *resultobj = 0;
4517 wxObject *arg1 = (wxObject *) 0 ;
4518 wxString result;
4519 void *argp1 = 0 ;
4520 int res1 = 0 ;
4521 PyObject *swig_obj[1] ;
4522
4523 if (!args) SWIG_fail;
4524 swig_obj[0] = args;
4525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4526 if (!SWIG_IsOK(res1)) {
4527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4528 }
4529 arg1 = reinterpret_cast< wxObject * >(argp1);
4530 {
4531 PyThreadState* __tstate = wxPyBeginAllowThreads();
4532 result = wxObject_GetClassName(arg1);
4533 wxPyEndAllowThreads(__tstate);
4534 if (PyErr_Occurred()) SWIG_fail;
4535 }
4536 {
4537 #if wxUSE_UNICODE
4538 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4539 #else
4540 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4541 #endif
4542 }
4543 return resultobj;
4544 fail:
4545 return NULL;
4546 }
4547
4548
4549 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4550 PyObject *resultobj = 0;
4551 wxObject *arg1 = (wxObject *) 0 ;
4552 void *argp1 = 0 ;
4553 int res1 = 0 ;
4554 PyObject *swig_obj[1] ;
4555
4556 if (!args) SWIG_fail;
4557 swig_obj[0] = args;
4558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4559 if (!SWIG_IsOK(res1)) {
4560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4561 }
4562 arg1 = reinterpret_cast< wxObject * >(argp1);
4563 {
4564 PyThreadState* __tstate = wxPyBeginAllowThreads();
4565 wxObject_Destroy(arg1);
4566 wxPyEndAllowThreads(__tstate);
4567 if (PyErr_Occurred()) SWIG_fail;
4568 }
4569 resultobj = SWIG_Py_Void();
4570 return resultobj;
4571 fail:
4572 return NULL;
4573 }
4574
4575
4576 SWIGINTERN PyObject *_wrap_Object_IsSameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4577 PyObject *resultobj = 0;
4578 wxObject *arg1 = (wxObject *) 0 ;
4579 wxObject *arg2 = 0 ;
4580 bool result;
4581 void *argp1 = 0 ;
4582 int res1 = 0 ;
4583 void *argp2 = 0 ;
4584 int res2 = 0 ;
4585 PyObject * obj0 = 0 ;
4586 PyObject * obj1 = 0 ;
4587 char * kwnames[] = {
4588 (char *) "self",(char *) "p", NULL
4589 };
4590
4591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Object_IsSameAs",kwnames,&obj0,&obj1)) SWIG_fail;
4592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4593 if (!SWIG_IsOK(res1)) {
4594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_IsSameAs" "', expected argument " "1"" of type '" "wxObject const *""'");
4595 }
4596 arg1 = reinterpret_cast< wxObject * >(argp1);
4597 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxObject, 0 | 0);
4598 if (!SWIG_IsOK(res2)) {
4599 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4600 }
4601 if (!argp2) {
4602 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4603 }
4604 arg2 = reinterpret_cast< wxObject * >(argp2);
4605 {
4606 PyThreadState* __tstate = wxPyBeginAllowThreads();
4607 result = (bool)((wxObject const *)arg1)->IsSameAs((wxObject const &)*arg2);
4608 wxPyEndAllowThreads(__tstate);
4609 if (PyErr_Occurred()) SWIG_fail;
4610 }
4611 {
4612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4613 }
4614 return resultobj;
4615 fail:
4616 return NULL;
4617 }
4618
4619
4620 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4621 PyObject *obj;
4622 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4623 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4624 return SWIG_Py_Void();
4625 }
4626
4627 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4628 PyObject *resultobj = 0;
4629 wxSize *arg1 = (wxSize *) 0 ;
4630 int arg2 ;
4631 void *argp1 = 0 ;
4632 int res1 = 0 ;
4633 int val2 ;
4634 int ecode2 = 0 ;
4635 PyObject *swig_obj[2] ;
4636
4637 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4639 if (!SWIG_IsOK(res1)) {
4640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4641 }
4642 arg1 = reinterpret_cast< wxSize * >(argp1);
4643 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4644 if (!SWIG_IsOK(ecode2)) {
4645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4646 }
4647 arg2 = static_cast< int >(val2);
4648 if (arg1) (arg1)->x = arg2;
4649
4650 resultobj = SWIG_Py_Void();
4651 return resultobj;
4652 fail:
4653 return NULL;
4654 }
4655
4656
4657 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4658 PyObject *resultobj = 0;
4659 wxSize *arg1 = (wxSize *) 0 ;
4660 int result;
4661 void *argp1 = 0 ;
4662 int res1 = 0 ;
4663 PyObject *swig_obj[1] ;
4664
4665 if (!args) SWIG_fail;
4666 swig_obj[0] = args;
4667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4668 if (!SWIG_IsOK(res1)) {
4669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4670 }
4671 arg1 = reinterpret_cast< wxSize * >(argp1);
4672 result = (int) ((arg1)->x);
4673 resultobj = SWIG_From_int(static_cast< int >(result));
4674 return resultobj;
4675 fail:
4676 return NULL;
4677 }
4678
4679
4680 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4681 PyObject *resultobj = 0;
4682 wxSize *arg1 = (wxSize *) 0 ;
4683 int arg2 ;
4684 void *argp1 = 0 ;
4685 int res1 = 0 ;
4686 int val2 ;
4687 int ecode2 = 0 ;
4688 PyObject *swig_obj[2] ;
4689
4690 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4692 if (!SWIG_IsOK(res1)) {
4693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4694 }
4695 arg1 = reinterpret_cast< wxSize * >(argp1);
4696 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4697 if (!SWIG_IsOK(ecode2)) {
4698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4699 }
4700 arg2 = static_cast< int >(val2);
4701 if (arg1) (arg1)->y = arg2;
4702
4703 resultobj = SWIG_Py_Void();
4704 return resultobj;
4705 fail:
4706 return NULL;
4707 }
4708
4709
4710 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4711 PyObject *resultobj = 0;
4712 wxSize *arg1 = (wxSize *) 0 ;
4713 int result;
4714 void *argp1 = 0 ;
4715 int res1 = 0 ;
4716 PyObject *swig_obj[1] ;
4717
4718 if (!args) SWIG_fail;
4719 swig_obj[0] = args;
4720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4721 if (!SWIG_IsOK(res1)) {
4722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4723 }
4724 arg1 = reinterpret_cast< wxSize * >(argp1);
4725 result = (int) ((arg1)->y);
4726 resultobj = SWIG_From_int(static_cast< int >(result));
4727 return resultobj;
4728 fail:
4729 return NULL;
4730 }
4731
4732
4733 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4734 PyObject *resultobj = 0;
4735 int arg1 = (int) 0 ;
4736 int arg2 = (int) 0 ;
4737 wxSize *result = 0 ;
4738 int val1 ;
4739 int ecode1 = 0 ;
4740 int val2 ;
4741 int ecode2 = 0 ;
4742 PyObject * obj0 = 0 ;
4743 PyObject * obj1 = 0 ;
4744 char * kwnames[] = {
4745 (char *) "w",(char *) "h", NULL
4746 };
4747
4748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4749 if (obj0) {
4750 ecode1 = SWIG_AsVal_int(obj0, &val1);
4751 if (!SWIG_IsOK(ecode1)) {
4752 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4753 }
4754 arg1 = static_cast< int >(val1);
4755 }
4756 if (obj1) {
4757 ecode2 = SWIG_AsVal_int(obj1, &val2);
4758 if (!SWIG_IsOK(ecode2)) {
4759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4760 }
4761 arg2 = static_cast< int >(val2);
4762 }
4763 {
4764 result = (wxSize *)new wxSize(arg1,arg2);
4765 if (PyErr_Occurred()) SWIG_fail;
4766 }
4767 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4768 return resultobj;
4769 fail:
4770 return NULL;
4771 }
4772
4773
4774 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4775 PyObject *resultobj = 0;
4776 wxSize *arg1 = (wxSize *) 0 ;
4777 void *argp1 = 0 ;
4778 int res1 = 0 ;
4779 PyObject *swig_obj[1] ;
4780
4781 if (!args) SWIG_fail;
4782 swig_obj[0] = args;
4783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4784 if (!SWIG_IsOK(res1)) {
4785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4786 }
4787 arg1 = reinterpret_cast< wxSize * >(argp1);
4788 {
4789 delete arg1;
4790
4791 if (PyErr_Occurred()) SWIG_fail;
4792 }
4793 resultobj = SWIG_Py_Void();
4794 return resultobj;
4795 fail:
4796 return NULL;
4797 }
4798
4799
4800 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4801 PyObject *resultobj = 0;
4802 wxSize *arg1 = (wxSize *) 0 ;
4803 PyObject *arg2 = (PyObject *) 0 ;
4804 bool result;
4805 void *argp1 = 0 ;
4806 int res1 = 0 ;
4807 PyObject * obj0 = 0 ;
4808 PyObject * obj1 = 0 ;
4809 char * kwnames[] = {
4810 (char *) "self",(char *) "other", NULL
4811 };
4812
4813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4815 if (!SWIG_IsOK(res1)) {
4816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4817 }
4818 arg1 = reinterpret_cast< wxSize * >(argp1);
4819 arg2 = obj1;
4820 {
4821 result = (bool)wxSize___eq__(arg1,arg2);
4822 if (PyErr_Occurred()) SWIG_fail;
4823 }
4824 {
4825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4826 }
4827 return resultobj;
4828 fail:
4829 return NULL;
4830 }
4831
4832
4833 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4834 PyObject *resultobj = 0;
4835 wxSize *arg1 = (wxSize *) 0 ;
4836 PyObject *arg2 = (PyObject *) 0 ;
4837 bool result;
4838 void *argp1 = 0 ;
4839 int res1 = 0 ;
4840 PyObject * obj0 = 0 ;
4841 PyObject * obj1 = 0 ;
4842 char * kwnames[] = {
4843 (char *) "self",(char *) "other", NULL
4844 };
4845
4846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4848 if (!SWIG_IsOK(res1)) {
4849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4850 }
4851 arg1 = reinterpret_cast< wxSize * >(argp1);
4852 arg2 = obj1;
4853 {
4854 result = (bool)wxSize___ne__(arg1,arg2);
4855 if (PyErr_Occurred()) SWIG_fail;
4856 }
4857 {
4858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4859 }
4860 return resultobj;
4861 fail:
4862 return NULL;
4863 }
4864
4865
4866 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4867 PyObject *resultobj = 0;
4868 wxSize *arg1 = (wxSize *) 0 ;
4869 wxSize *arg2 = 0 ;
4870 wxSize result;
4871 void *argp1 = 0 ;
4872 int res1 = 0 ;
4873 wxSize temp2 ;
4874 PyObject * obj0 = 0 ;
4875 PyObject * obj1 = 0 ;
4876 char * kwnames[] = {
4877 (char *) "self",(char *) "sz", NULL
4878 };
4879
4880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4882 if (!SWIG_IsOK(res1)) {
4883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4884 }
4885 arg1 = reinterpret_cast< wxSize * >(argp1);
4886 {
4887 arg2 = &temp2;
4888 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4889 }
4890 {
4891 result = (arg1)->operator +((wxSize const &)*arg2);
4892 if (PyErr_Occurred()) SWIG_fail;
4893 }
4894 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4895 return resultobj;
4896 fail:
4897 return NULL;
4898 }
4899
4900
4901 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4902 PyObject *resultobj = 0;
4903 wxSize *arg1 = (wxSize *) 0 ;
4904 wxSize *arg2 = 0 ;
4905 wxSize result;
4906 void *argp1 = 0 ;
4907 int res1 = 0 ;
4908 wxSize temp2 ;
4909 PyObject * obj0 = 0 ;
4910 PyObject * obj1 = 0 ;
4911 char * kwnames[] = {
4912 (char *) "self",(char *) "sz", NULL
4913 };
4914
4915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4917 if (!SWIG_IsOK(res1)) {
4918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4919 }
4920 arg1 = reinterpret_cast< wxSize * >(argp1);
4921 {
4922 arg2 = &temp2;
4923 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4924 }
4925 {
4926 result = (arg1)->operator -((wxSize const &)*arg2);
4927 if (PyErr_Occurred()) SWIG_fail;
4928 }
4929 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4930 return resultobj;
4931 fail:
4932 return NULL;
4933 }
4934
4935
4936 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4937 PyObject *resultobj = 0;
4938 wxSize *arg1 = (wxSize *) 0 ;
4939 wxSize *arg2 = 0 ;
4940 void *argp1 = 0 ;
4941 int res1 = 0 ;
4942 wxSize temp2 ;
4943 PyObject * obj0 = 0 ;
4944 PyObject * obj1 = 0 ;
4945 char * kwnames[] = {
4946 (char *) "self",(char *) "sz", NULL
4947 };
4948
4949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4951 if (!SWIG_IsOK(res1)) {
4952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4953 }
4954 arg1 = reinterpret_cast< wxSize * >(argp1);
4955 {
4956 arg2 = &temp2;
4957 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4958 }
4959 {
4960 (arg1)->IncTo((wxSize const &)*arg2);
4961 if (PyErr_Occurred()) SWIG_fail;
4962 }
4963 resultobj = SWIG_Py_Void();
4964 return resultobj;
4965 fail:
4966 return NULL;
4967 }
4968
4969
4970 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4971 PyObject *resultobj = 0;
4972 wxSize *arg1 = (wxSize *) 0 ;
4973 wxSize *arg2 = 0 ;
4974 void *argp1 = 0 ;
4975 int res1 = 0 ;
4976 wxSize temp2 ;
4977 PyObject * obj0 = 0 ;
4978 PyObject * obj1 = 0 ;
4979 char * kwnames[] = {
4980 (char *) "self",(char *) "sz", NULL
4981 };
4982
4983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4985 if (!SWIG_IsOK(res1)) {
4986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4987 }
4988 arg1 = reinterpret_cast< wxSize * >(argp1);
4989 {
4990 arg2 = &temp2;
4991 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4992 }
4993 {
4994 (arg1)->DecTo((wxSize const &)*arg2);
4995 if (PyErr_Occurred()) SWIG_fail;
4996 }
4997 resultobj = SWIG_Py_Void();
4998 return resultobj;
4999 fail:
5000 return NULL;
5001 }
5002
5003
5004 SWIGINTERN PyObject *_wrap_Size_IncBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5005 PyObject *resultobj = 0;
5006 wxSize *arg1 = (wxSize *) 0 ;
5007 int arg2 ;
5008 int arg3 ;
5009 void *argp1 = 0 ;
5010 int res1 = 0 ;
5011 int val2 ;
5012 int ecode2 = 0 ;
5013 int val3 ;
5014 int ecode3 = 0 ;
5015 PyObject * obj0 = 0 ;
5016 PyObject * obj1 = 0 ;
5017 PyObject * obj2 = 0 ;
5018 char * kwnames[] = {
5019 (char *) "self",(char *) "dx",(char *) "dy", NULL
5020 };
5021
5022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_IncBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5024 if (!SWIG_IsOK(res1)) {
5025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncBy" "', expected argument " "1"" of type '" "wxSize *""'");
5026 }
5027 arg1 = reinterpret_cast< wxSize * >(argp1);
5028 ecode2 = SWIG_AsVal_int(obj1, &val2);
5029 if (!SWIG_IsOK(ecode2)) {
5030 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_IncBy" "', expected argument " "2"" of type '" "int""'");
5031 }
5032 arg2 = static_cast< int >(val2);
5033 ecode3 = SWIG_AsVal_int(obj2, &val3);
5034 if (!SWIG_IsOK(ecode3)) {
5035 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_IncBy" "', expected argument " "3"" of type '" "int""'");
5036 }
5037 arg3 = static_cast< int >(val3);
5038 {
5039 (arg1)->IncBy(arg2,arg3);
5040 if (PyErr_Occurred()) SWIG_fail;
5041 }
5042 resultobj = SWIG_Py_Void();
5043 return resultobj;
5044 fail:
5045 return NULL;
5046 }
5047
5048
5049 SWIGINTERN PyObject *_wrap_Size_DecBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5050 PyObject *resultobj = 0;
5051 wxSize *arg1 = (wxSize *) 0 ;
5052 int arg2 ;
5053 int arg3 ;
5054 void *argp1 = 0 ;
5055 int res1 = 0 ;
5056 int val2 ;
5057 int ecode2 = 0 ;
5058 int val3 ;
5059 int ecode3 = 0 ;
5060 PyObject * obj0 = 0 ;
5061 PyObject * obj1 = 0 ;
5062 PyObject * obj2 = 0 ;
5063 char * kwnames[] = {
5064 (char *) "self",(char *) "dx",(char *) "dy", NULL
5065 };
5066
5067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_DecBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5069 if (!SWIG_IsOK(res1)) {
5070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecBy" "', expected argument " "1"" of type '" "wxSize *""'");
5071 }
5072 arg1 = reinterpret_cast< wxSize * >(argp1);
5073 ecode2 = SWIG_AsVal_int(obj1, &val2);
5074 if (!SWIG_IsOK(ecode2)) {
5075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_DecBy" "', expected argument " "2"" of type '" "int""'");
5076 }
5077 arg2 = static_cast< int >(val2);
5078 ecode3 = SWIG_AsVal_int(obj2, &val3);
5079 if (!SWIG_IsOK(ecode3)) {
5080 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_DecBy" "', expected argument " "3"" of type '" "int""'");
5081 }
5082 arg3 = static_cast< int >(val3);
5083 {
5084 (arg1)->DecBy(arg2,arg3);
5085 if (PyErr_Occurred()) SWIG_fail;
5086 }
5087 resultobj = SWIG_Py_Void();
5088 return resultobj;
5089 fail:
5090 return NULL;
5091 }
5092
5093
5094 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5095 PyObject *resultobj = 0;
5096 wxSize *arg1 = (wxSize *) 0 ;
5097 float arg2 ;
5098 float arg3 ;
5099 void *argp1 = 0 ;
5100 int res1 = 0 ;
5101 float val2 ;
5102 int ecode2 = 0 ;
5103 float val3 ;
5104 int ecode3 = 0 ;
5105 PyObject * obj0 = 0 ;
5106 PyObject * obj1 = 0 ;
5107 PyObject * obj2 = 0 ;
5108 char * kwnames[] = {
5109 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
5110 };
5111
5112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5114 if (!SWIG_IsOK(res1)) {
5115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
5116 }
5117 arg1 = reinterpret_cast< wxSize * >(argp1);
5118 ecode2 = SWIG_AsVal_float(obj1, &val2);
5119 if (!SWIG_IsOK(ecode2)) {
5120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
5121 }
5122 arg2 = static_cast< float >(val2);
5123 ecode3 = SWIG_AsVal_float(obj2, &val3);
5124 if (!SWIG_IsOK(ecode3)) {
5125 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
5126 }
5127 arg3 = static_cast< float >(val3);
5128 {
5129 (arg1)->Scale(arg2,arg3);
5130 if (PyErr_Occurred()) SWIG_fail;
5131 }
5132 resultobj = SWIG_Py_Void();
5133 return resultobj;
5134 fail:
5135 return NULL;
5136 }
5137
5138
5139 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5140 PyObject *resultobj = 0;
5141 wxSize *arg1 = (wxSize *) 0 ;
5142 int arg2 ;
5143 int arg3 ;
5144 void *argp1 = 0 ;
5145 int res1 = 0 ;
5146 int val2 ;
5147 int ecode2 = 0 ;
5148 int val3 ;
5149 int ecode3 = 0 ;
5150 PyObject * obj0 = 0 ;
5151 PyObject * obj1 = 0 ;
5152 PyObject * obj2 = 0 ;
5153 char * kwnames[] = {
5154 (char *) "self",(char *) "w",(char *) "h", NULL
5155 };
5156
5157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5159 if (!SWIG_IsOK(res1)) {
5160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
5161 }
5162 arg1 = reinterpret_cast< wxSize * >(argp1);
5163 ecode2 = SWIG_AsVal_int(obj1, &val2);
5164 if (!SWIG_IsOK(ecode2)) {
5165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
5166 }
5167 arg2 = static_cast< int >(val2);
5168 ecode3 = SWIG_AsVal_int(obj2, &val3);
5169 if (!SWIG_IsOK(ecode3)) {
5170 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
5171 }
5172 arg3 = static_cast< int >(val3);
5173 {
5174 (arg1)->Set(arg2,arg3);
5175 if (PyErr_Occurred()) SWIG_fail;
5176 }
5177 resultobj = SWIG_Py_Void();
5178 return resultobj;
5179 fail:
5180 return NULL;
5181 }
5182
5183
5184 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5185 PyObject *resultobj = 0;
5186 wxSize *arg1 = (wxSize *) 0 ;
5187 int arg2 ;
5188 void *argp1 = 0 ;
5189 int res1 = 0 ;
5190 int val2 ;
5191 int ecode2 = 0 ;
5192 PyObject * obj0 = 0 ;
5193 PyObject * obj1 = 0 ;
5194 char * kwnames[] = {
5195 (char *) "self",(char *) "w", NULL
5196 };
5197
5198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
5199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5200 if (!SWIG_IsOK(res1)) {
5201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
5202 }
5203 arg1 = reinterpret_cast< wxSize * >(argp1);
5204 ecode2 = SWIG_AsVal_int(obj1, &val2);
5205 if (!SWIG_IsOK(ecode2)) {
5206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
5207 }
5208 arg2 = static_cast< int >(val2);
5209 {
5210 (arg1)->SetWidth(arg2);
5211 if (PyErr_Occurred()) SWIG_fail;
5212 }
5213 resultobj = SWIG_Py_Void();
5214 return resultobj;
5215 fail:
5216 return NULL;
5217 }
5218
5219
5220 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5221 PyObject *resultobj = 0;
5222 wxSize *arg1 = (wxSize *) 0 ;
5223 int arg2 ;
5224 void *argp1 = 0 ;
5225 int res1 = 0 ;
5226 int val2 ;
5227 int ecode2 = 0 ;
5228 PyObject * obj0 = 0 ;
5229 PyObject * obj1 = 0 ;
5230 char * kwnames[] = {
5231 (char *) "self",(char *) "h", NULL
5232 };
5233
5234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5236 if (!SWIG_IsOK(res1)) {
5237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5238 }
5239 arg1 = reinterpret_cast< wxSize * >(argp1);
5240 ecode2 = SWIG_AsVal_int(obj1, &val2);
5241 if (!SWIG_IsOK(ecode2)) {
5242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5243 }
5244 arg2 = static_cast< int >(val2);
5245 {
5246 (arg1)->SetHeight(arg2);
5247 if (PyErr_Occurred()) SWIG_fail;
5248 }
5249 resultobj = SWIG_Py_Void();
5250 return resultobj;
5251 fail:
5252 return NULL;
5253 }
5254
5255
5256 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5257 PyObject *resultobj = 0;
5258 wxSize *arg1 = (wxSize *) 0 ;
5259 int result;
5260 void *argp1 = 0 ;
5261 int res1 = 0 ;
5262 PyObject *swig_obj[1] ;
5263
5264 if (!args) SWIG_fail;
5265 swig_obj[0] = args;
5266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5267 if (!SWIG_IsOK(res1)) {
5268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5269 }
5270 arg1 = reinterpret_cast< wxSize * >(argp1);
5271 {
5272 result = (int)((wxSize const *)arg1)->GetWidth();
5273 if (PyErr_Occurred()) SWIG_fail;
5274 }
5275 resultobj = SWIG_From_int(static_cast< int >(result));
5276 return resultobj;
5277 fail:
5278 return NULL;
5279 }
5280
5281
5282 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5283 PyObject *resultobj = 0;
5284 wxSize *arg1 = (wxSize *) 0 ;
5285 int result;
5286 void *argp1 = 0 ;
5287 int res1 = 0 ;
5288 PyObject *swig_obj[1] ;
5289
5290 if (!args) SWIG_fail;
5291 swig_obj[0] = args;
5292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5293 if (!SWIG_IsOK(res1)) {
5294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5295 }
5296 arg1 = reinterpret_cast< wxSize * >(argp1);
5297 {
5298 result = (int)((wxSize const *)arg1)->GetHeight();
5299 if (PyErr_Occurred()) SWIG_fail;
5300 }
5301 resultobj = SWIG_From_int(static_cast< int >(result));
5302 return resultobj;
5303 fail:
5304 return NULL;
5305 }
5306
5307
5308 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5309 PyObject *resultobj = 0;
5310 wxSize *arg1 = (wxSize *) 0 ;
5311 bool result;
5312 void *argp1 = 0 ;
5313 int res1 = 0 ;
5314 PyObject *swig_obj[1] ;
5315
5316 if (!args) SWIG_fail;
5317 swig_obj[0] = args;
5318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5319 if (!SWIG_IsOK(res1)) {
5320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5321 }
5322 arg1 = reinterpret_cast< wxSize * >(argp1);
5323 {
5324 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5325 if (PyErr_Occurred()) SWIG_fail;
5326 }
5327 {
5328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5329 }
5330 return resultobj;
5331 fail:
5332 return NULL;
5333 }
5334
5335
5336 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5337 PyObject *resultobj = 0;
5338 wxSize *arg1 = (wxSize *) 0 ;
5339 wxSize *arg2 = 0 ;
5340 void *argp1 = 0 ;
5341 int res1 = 0 ;
5342 wxSize temp2 ;
5343 PyObject * obj0 = 0 ;
5344 PyObject * obj1 = 0 ;
5345 char * kwnames[] = {
5346 (char *) "self",(char *) "size", NULL
5347 };
5348
5349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5351 if (!SWIG_IsOK(res1)) {
5352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5353 }
5354 arg1 = reinterpret_cast< wxSize * >(argp1);
5355 {
5356 arg2 = &temp2;
5357 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5358 }
5359 {
5360 (arg1)->SetDefaults((wxSize const &)*arg2);
5361 if (PyErr_Occurred()) SWIG_fail;
5362 }
5363 resultobj = SWIG_Py_Void();
5364 return resultobj;
5365 fail:
5366 return NULL;
5367 }
5368
5369
5370 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5371 PyObject *resultobj = 0;
5372 wxSize *arg1 = (wxSize *) 0 ;
5373 PyObject *result = 0 ;
5374 void *argp1 = 0 ;
5375 int res1 = 0 ;
5376 PyObject *swig_obj[1] ;
5377
5378 if (!args) SWIG_fail;
5379 swig_obj[0] = args;
5380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5381 if (!SWIG_IsOK(res1)) {
5382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5383 }
5384 arg1 = reinterpret_cast< wxSize * >(argp1);
5385 {
5386 result = (PyObject *)wxSize_Get(arg1);
5387 if (PyErr_Occurred()) SWIG_fail;
5388 }
5389 resultobj = result;
5390 return resultobj;
5391 fail:
5392 return NULL;
5393 }
5394
5395
5396 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5397 PyObject *obj;
5398 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5399 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5400 return SWIG_Py_Void();
5401 }
5402
5403 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5404 return SWIG_Python_InitShadowInstance(args);
5405 }
5406
5407 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5408 PyObject *resultobj = 0;
5409 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5410 double arg2 ;
5411 void *argp1 = 0 ;
5412 int res1 = 0 ;
5413 double val2 ;
5414 int ecode2 = 0 ;
5415 PyObject *swig_obj[2] ;
5416
5417 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5419 if (!SWIG_IsOK(res1)) {
5420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5421 }
5422 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5423 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5424 if (!SWIG_IsOK(ecode2)) {
5425 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5426 }
5427 arg2 = static_cast< double >(val2);
5428 if (arg1) (arg1)->x = arg2;
5429
5430 resultobj = SWIG_Py_Void();
5431 return resultobj;
5432 fail:
5433 return NULL;
5434 }
5435
5436
5437 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5438 PyObject *resultobj = 0;
5439 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5440 double result;
5441 void *argp1 = 0 ;
5442 int res1 = 0 ;
5443 PyObject *swig_obj[1] ;
5444
5445 if (!args) SWIG_fail;
5446 swig_obj[0] = args;
5447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5448 if (!SWIG_IsOK(res1)) {
5449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5450 }
5451 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5452 result = (double) ((arg1)->x);
5453 resultobj = SWIG_From_double(static_cast< double >(result));
5454 return resultobj;
5455 fail:
5456 return NULL;
5457 }
5458
5459
5460 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5461 PyObject *resultobj = 0;
5462 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5463 double arg2 ;
5464 void *argp1 = 0 ;
5465 int res1 = 0 ;
5466 double val2 ;
5467 int ecode2 = 0 ;
5468 PyObject *swig_obj[2] ;
5469
5470 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5472 if (!SWIG_IsOK(res1)) {
5473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5474 }
5475 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5476 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5477 if (!SWIG_IsOK(ecode2)) {
5478 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5479 }
5480 arg2 = static_cast< double >(val2);
5481 if (arg1) (arg1)->y = arg2;
5482
5483 resultobj = SWIG_Py_Void();
5484 return resultobj;
5485 fail:
5486 return NULL;
5487 }
5488
5489
5490 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5491 PyObject *resultobj = 0;
5492 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5493 double result;
5494 void *argp1 = 0 ;
5495 int res1 = 0 ;
5496 PyObject *swig_obj[1] ;
5497
5498 if (!args) SWIG_fail;
5499 swig_obj[0] = args;
5500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5501 if (!SWIG_IsOK(res1)) {
5502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5503 }
5504 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5505 result = (double) ((arg1)->y);
5506 resultobj = SWIG_From_double(static_cast< double >(result));
5507 return resultobj;
5508 fail:
5509 return NULL;
5510 }
5511
5512
5513 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5514 PyObject *resultobj = 0;
5515 double arg1 = (double) 0.0 ;
5516 double arg2 = (double) 0.0 ;
5517 wxRealPoint *result = 0 ;
5518 double val1 ;
5519 int ecode1 = 0 ;
5520 double val2 ;
5521 int ecode2 = 0 ;
5522 PyObject * obj0 = 0 ;
5523 PyObject * obj1 = 0 ;
5524 char * kwnames[] = {
5525 (char *) "x",(char *) "y", NULL
5526 };
5527
5528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5529 if (obj0) {
5530 ecode1 = SWIG_AsVal_double(obj0, &val1);
5531 if (!SWIG_IsOK(ecode1)) {
5532 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5533 }
5534 arg1 = static_cast< double >(val1);
5535 }
5536 if (obj1) {
5537 ecode2 = SWIG_AsVal_double(obj1, &val2);
5538 if (!SWIG_IsOK(ecode2)) {
5539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5540 }
5541 arg2 = static_cast< double >(val2);
5542 }
5543 {
5544 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5545 if (PyErr_Occurred()) SWIG_fail;
5546 }
5547 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5548 return resultobj;
5549 fail:
5550 return NULL;
5551 }
5552
5553
5554 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5555 PyObject *resultobj = 0;
5556 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5557 void *argp1 = 0 ;
5558 int res1 = 0 ;
5559 PyObject *swig_obj[1] ;
5560
5561 if (!args) SWIG_fail;
5562 swig_obj[0] = args;
5563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5564 if (!SWIG_IsOK(res1)) {
5565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5566 }
5567 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5568 {
5569 delete arg1;
5570
5571 if (PyErr_Occurred()) SWIG_fail;
5572 }
5573 resultobj = SWIG_Py_Void();
5574 return resultobj;
5575 fail:
5576 return NULL;
5577 }
5578
5579
5580 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5581 PyObject *resultobj = 0;
5582 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5583 PyObject *arg2 = (PyObject *) 0 ;
5584 bool result;
5585 void *argp1 = 0 ;
5586 int res1 = 0 ;
5587 PyObject * obj0 = 0 ;
5588 PyObject * obj1 = 0 ;
5589 char * kwnames[] = {
5590 (char *) "self",(char *) "other", NULL
5591 };
5592
5593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5595 if (!SWIG_IsOK(res1)) {
5596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5597 }
5598 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5599 arg2 = obj1;
5600 {
5601 result = (bool)wxRealPoint___eq__(arg1,arg2);
5602 if (PyErr_Occurred()) SWIG_fail;
5603 }
5604 {
5605 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5606 }
5607 return resultobj;
5608 fail:
5609 return NULL;
5610 }
5611
5612
5613 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5614 PyObject *resultobj = 0;
5615 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5616 PyObject *arg2 = (PyObject *) 0 ;
5617 bool result;
5618 void *argp1 = 0 ;
5619 int res1 = 0 ;
5620 PyObject * obj0 = 0 ;
5621 PyObject * obj1 = 0 ;
5622 char * kwnames[] = {
5623 (char *) "self",(char *) "other", NULL
5624 };
5625
5626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5628 if (!SWIG_IsOK(res1)) {
5629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5630 }
5631 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5632 arg2 = obj1;
5633 {
5634 result = (bool)wxRealPoint___ne__(arg1,arg2);
5635 if (PyErr_Occurred()) SWIG_fail;
5636 }
5637 {
5638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5639 }
5640 return resultobj;
5641 fail:
5642 return NULL;
5643 }
5644
5645
5646 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5647 PyObject *resultobj = 0;
5648 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5649 wxRealPoint *arg2 = 0 ;
5650 wxRealPoint result;
5651 void *argp1 = 0 ;
5652 int res1 = 0 ;
5653 wxRealPoint temp2 ;
5654 PyObject * obj0 = 0 ;
5655 PyObject * obj1 = 0 ;
5656 char * kwnames[] = {
5657 (char *) "self",(char *) "pt", NULL
5658 };
5659
5660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5662 if (!SWIG_IsOK(res1)) {
5663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5664 }
5665 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5666 {
5667 arg2 = &temp2;
5668 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5669 }
5670 {
5671 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5672 if (PyErr_Occurred()) SWIG_fail;
5673 }
5674 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5675 return resultobj;
5676 fail:
5677 return NULL;
5678 }
5679
5680
5681 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5682 PyObject *resultobj = 0;
5683 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5684 wxRealPoint *arg2 = 0 ;
5685 wxRealPoint result;
5686 void *argp1 = 0 ;
5687 int res1 = 0 ;
5688 wxRealPoint temp2 ;
5689 PyObject * obj0 = 0 ;
5690 PyObject * obj1 = 0 ;
5691 char * kwnames[] = {
5692 (char *) "self",(char *) "pt", NULL
5693 };
5694
5695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5697 if (!SWIG_IsOK(res1)) {
5698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5699 }
5700 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5701 {
5702 arg2 = &temp2;
5703 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5704 }
5705 {
5706 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5707 if (PyErr_Occurred()) SWIG_fail;
5708 }
5709 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5710 return resultobj;
5711 fail:
5712 return NULL;
5713 }
5714
5715
5716 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5717 PyObject *resultobj = 0;
5718 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5719 double arg2 ;
5720 double arg3 ;
5721 void *argp1 = 0 ;
5722 int res1 = 0 ;
5723 double val2 ;
5724 int ecode2 = 0 ;
5725 double val3 ;
5726 int ecode3 = 0 ;
5727 PyObject * obj0 = 0 ;
5728 PyObject * obj1 = 0 ;
5729 PyObject * obj2 = 0 ;
5730 char * kwnames[] = {
5731 (char *) "self",(char *) "x",(char *) "y", NULL
5732 };
5733
5734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5736 if (!SWIG_IsOK(res1)) {
5737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5738 }
5739 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5740 ecode2 = SWIG_AsVal_double(obj1, &val2);
5741 if (!SWIG_IsOK(ecode2)) {
5742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5743 }
5744 arg2 = static_cast< double >(val2);
5745 ecode3 = SWIG_AsVal_double(obj2, &val3);
5746 if (!SWIG_IsOK(ecode3)) {
5747 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5748 }
5749 arg3 = static_cast< double >(val3);
5750 {
5751 wxRealPoint_Set(arg1,arg2,arg3);
5752 if (PyErr_Occurred()) SWIG_fail;
5753 }
5754 resultobj = SWIG_Py_Void();
5755 return resultobj;
5756 fail:
5757 return NULL;
5758 }
5759
5760
5761 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5762 PyObject *resultobj = 0;
5763 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5764 PyObject *result = 0 ;
5765 void *argp1 = 0 ;
5766 int res1 = 0 ;
5767 PyObject *swig_obj[1] ;
5768
5769 if (!args) SWIG_fail;
5770 swig_obj[0] = args;
5771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5772 if (!SWIG_IsOK(res1)) {
5773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5774 }
5775 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5776 {
5777 result = (PyObject *)wxRealPoint_Get(arg1);
5778 if (PyErr_Occurred()) SWIG_fail;
5779 }
5780 resultobj = result;
5781 return resultobj;
5782 fail:
5783 return NULL;
5784 }
5785
5786
5787 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5788 PyObject *obj;
5789 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5790 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5791 return SWIG_Py_Void();
5792 }
5793
5794 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5795 return SWIG_Python_InitShadowInstance(args);
5796 }
5797
5798 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5799 PyObject *resultobj = 0;
5800 wxPoint *arg1 = (wxPoint *) 0 ;
5801 int arg2 ;
5802 void *argp1 = 0 ;
5803 int res1 = 0 ;
5804 int val2 ;
5805 int ecode2 = 0 ;
5806 PyObject *swig_obj[2] ;
5807
5808 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5810 if (!SWIG_IsOK(res1)) {
5811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5812 }
5813 arg1 = reinterpret_cast< wxPoint * >(argp1);
5814 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5815 if (!SWIG_IsOK(ecode2)) {
5816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5817 }
5818 arg2 = static_cast< int >(val2);
5819 if (arg1) (arg1)->x = arg2;
5820
5821 resultobj = SWIG_Py_Void();
5822 return resultobj;
5823 fail:
5824 return NULL;
5825 }
5826
5827
5828 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5829 PyObject *resultobj = 0;
5830 wxPoint *arg1 = (wxPoint *) 0 ;
5831 int result;
5832 void *argp1 = 0 ;
5833 int res1 = 0 ;
5834 PyObject *swig_obj[1] ;
5835
5836 if (!args) SWIG_fail;
5837 swig_obj[0] = args;
5838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5839 if (!SWIG_IsOK(res1)) {
5840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5841 }
5842 arg1 = reinterpret_cast< wxPoint * >(argp1);
5843 result = (int) ((arg1)->x);
5844 resultobj = SWIG_From_int(static_cast< int >(result));
5845 return resultobj;
5846 fail:
5847 return NULL;
5848 }
5849
5850
5851 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5852 PyObject *resultobj = 0;
5853 wxPoint *arg1 = (wxPoint *) 0 ;
5854 int arg2 ;
5855 void *argp1 = 0 ;
5856 int res1 = 0 ;
5857 int val2 ;
5858 int ecode2 = 0 ;
5859 PyObject *swig_obj[2] ;
5860
5861 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5863 if (!SWIG_IsOK(res1)) {
5864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5865 }
5866 arg1 = reinterpret_cast< wxPoint * >(argp1);
5867 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5868 if (!SWIG_IsOK(ecode2)) {
5869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5870 }
5871 arg2 = static_cast< int >(val2);
5872 if (arg1) (arg1)->y = arg2;
5873
5874 resultobj = SWIG_Py_Void();
5875 return resultobj;
5876 fail:
5877 return NULL;
5878 }
5879
5880
5881 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5882 PyObject *resultobj = 0;
5883 wxPoint *arg1 = (wxPoint *) 0 ;
5884 int result;
5885 void *argp1 = 0 ;
5886 int res1 = 0 ;
5887 PyObject *swig_obj[1] ;
5888
5889 if (!args) SWIG_fail;
5890 swig_obj[0] = args;
5891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5892 if (!SWIG_IsOK(res1)) {
5893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5894 }
5895 arg1 = reinterpret_cast< wxPoint * >(argp1);
5896 result = (int) ((arg1)->y);
5897 resultobj = SWIG_From_int(static_cast< int >(result));
5898 return resultobj;
5899 fail:
5900 return NULL;
5901 }
5902
5903
5904 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5905 PyObject *resultobj = 0;
5906 int arg1 = (int) 0 ;
5907 int arg2 = (int) 0 ;
5908 wxPoint *result = 0 ;
5909 int val1 ;
5910 int ecode1 = 0 ;
5911 int val2 ;
5912 int ecode2 = 0 ;
5913 PyObject * obj0 = 0 ;
5914 PyObject * obj1 = 0 ;
5915 char * kwnames[] = {
5916 (char *) "x",(char *) "y", NULL
5917 };
5918
5919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5920 if (obj0) {
5921 ecode1 = SWIG_AsVal_int(obj0, &val1);
5922 if (!SWIG_IsOK(ecode1)) {
5923 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5924 }
5925 arg1 = static_cast< int >(val1);
5926 }
5927 if (obj1) {
5928 ecode2 = SWIG_AsVal_int(obj1, &val2);
5929 if (!SWIG_IsOK(ecode2)) {
5930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5931 }
5932 arg2 = static_cast< int >(val2);
5933 }
5934 {
5935 result = (wxPoint *)new wxPoint(arg1,arg2);
5936 if (PyErr_Occurred()) SWIG_fail;
5937 }
5938 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5939 return resultobj;
5940 fail:
5941 return NULL;
5942 }
5943
5944
5945 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5946 PyObject *resultobj = 0;
5947 wxPoint *arg1 = (wxPoint *) 0 ;
5948 void *argp1 = 0 ;
5949 int res1 = 0 ;
5950 PyObject *swig_obj[1] ;
5951
5952 if (!args) SWIG_fail;
5953 swig_obj[0] = args;
5954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5955 if (!SWIG_IsOK(res1)) {
5956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5957 }
5958 arg1 = reinterpret_cast< wxPoint * >(argp1);
5959 {
5960 delete arg1;
5961
5962 if (PyErr_Occurred()) SWIG_fail;
5963 }
5964 resultobj = SWIG_Py_Void();
5965 return resultobj;
5966 fail:
5967 return NULL;
5968 }
5969
5970
5971 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5972 PyObject *resultobj = 0;
5973 wxPoint *arg1 = (wxPoint *) 0 ;
5974 PyObject *arg2 = (PyObject *) 0 ;
5975 bool result;
5976 void *argp1 = 0 ;
5977 int res1 = 0 ;
5978 PyObject * obj0 = 0 ;
5979 PyObject * obj1 = 0 ;
5980 char * kwnames[] = {
5981 (char *) "self",(char *) "other", NULL
5982 };
5983
5984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5986 if (!SWIG_IsOK(res1)) {
5987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5988 }
5989 arg1 = reinterpret_cast< wxPoint * >(argp1);
5990 arg2 = obj1;
5991 {
5992 result = (bool)wxPoint___eq__(arg1,arg2);
5993 if (PyErr_Occurred()) SWIG_fail;
5994 }
5995 {
5996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5997 }
5998 return resultobj;
5999 fail:
6000 return NULL;
6001 }
6002
6003
6004 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6005 PyObject *resultobj = 0;
6006 wxPoint *arg1 = (wxPoint *) 0 ;
6007 PyObject *arg2 = (PyObject *) 0 ;
6008 bool result;
6009 void *argp1 = 0 ;
6010 int res1 = 0 ;
6011 PyObject * obj0 = 0 ;
6012 PyObject * obj1 = 0 ;
6013 char * kwnames[] = {
6014 (char *) "self",(char *) "other", NULL
6015 };
6016
6017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
6018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6019 if (!SWIG_IsOK(res1)) {
6020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
6021 }
6022 arg1 = reinterpret_cast< wxPoint * >(argp1);
6023 arg2 = obj1;
6024 {
6025 result = (bool)wxPoint___ne__(arg1,arg2);
6026 if (PyErr_Occurred()) SWIG_fail;
6027 }
6028 {
6029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6030 }
6031 return resultobj;
6032 fail:
6033 return NULL;
6034 }
6035
6036
6037 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6038 PyObject *resultobj = 0;
6039 wxPoint *arg1 = (wxPoint *) 0 ;
6040 wxPoint *arg2 = 0 ;
6041 wxPoint result;
6042 void *argp1 = 0 ;
6043 int res1 = 0 ;
6044 wxPoint temp2 ;
6045 PyObject * obj0 = 0 ;
6046 PyObject * obj1 = 0 ;
6047 char * kwnames[] = {
6048 (char *) "self",(char *) "pt", NULL
6049 };
6050
6051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
6052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6053 if (!SWIG_IsOK(res1)) {
6054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
6055 }
6056 arg1 = reinterpret_cast< wxPoint * >(argp1);
6057 {
6058 arg2 = &temp2;
6059 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6060 }
6061 {
6062 result = (arg1)->operator +((wxPoint const &)*arg2);
6063 if (PyErr_Occurred()) SWIG_fail;
6064 }
6065 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6066 return resultobj;
6067 fail:
6068 return NULL;
6069 }
6070
6071
6072 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6073 PyObject *resultobj = 0;
6074 wxPoint *arg1 = (wxPoint *) 0 ;
6075 wxPoint *arg2 = 0 ;
6076 wxPoint result;
6077 void *argp1 = 0 ;
6078 int res1 = 0 ;
6079 wxPoint temp2 ;
6080 PyObject * obj0 = 0 ;
6081 PyObject * obj1 = 0 ;
6082 char * kwnames[] = {
6083 (char *) "self",(char *) "pt", NULL
6084 };
6085
6086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
6087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6088 if (!SWIG_IsOK(res1)) {
6089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6090 }
6091 arg1 = reinterpret_cast< wxPoint * >(argp1);
6092 {
6093 arg2 = &temp2;
6094 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6095 }
6096 {
6097 result = (arg1)->operator -((wxPoint const &)*arg2);
6098 if (PyErr_Occurred()) SWIG_fail;
6099 }
6100 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6101 return resultobj;
6102 fail:
6103 return NULL;
6104 }
6105
6106
6107 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6108 PyObject *resultobj = 0;
6109 wxPoint *arg1 = (wxPoint *) 0 ;
6110 wxPoint *arg2 = 0 ;
6111 wxPoint *result = 0 ;
6112 void *argp1 = 0 ;
6113 int res1 = 0 ;
6114 wxPoint temp2 ;
6115 PyObject * obj0 = 0 ;
6116 PyObject * obj1 = 0 ;
6117 char * kwnames[] = {
6118 (char *) "self",(char *) "pt", NULL
6119 };
6120
6121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
6122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6123 if (!SWIG_IsOK(res1)) {
6124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
6125 }
6126 arg1 = reinterpret_cast< wxPoint * >(argp1);
6127 {
6128 arg2 = &temp2;
6129 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6130 }
6131 {
6132 {
6133 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
6134 result = (wxPoint *) &_result_ref;
6135 }
6136 if (PyErr_Occurred()) SWIG_fail;
6137 }
6138 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6139 return resultobj;
6140 fail:
6141 return NULL;
6142 }
6143
6144
6145 SWIGINTERN PyObject *_wrap_Point___isub__(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___isub__",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___isub__" "', 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_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6184 PyObject *resultobj = 0;
6185 wxPoint *arg1 = (wxPoint *) 0 ;
6186 long arg2 ;
6187 long arg3 ;
6188 void *argp1 = 0 ;
6189 int res1 = 0 ;
6190 long val2 ;
6191 int ecode2 = 0 ;
6192 long val3 ;
6193 int ecode3 = 0 ;
6194 PyObject * obj0 = 0 ;
6195 PyObject * obj1 = 0 ;
6196 PyObject * obj2 = 0 ;
6197 char * kwnames[] = {
6198 (char *) "self",(char *) "x",(char *) "y", NULL
6199 };
6200
6201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6203 if (!SWIG_IsOK(res1)) {
6204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6205 }
6206 arg1 = reinterpret_cast< wxPoint * >(argp1);
6207 ecode2 = SWIG_AsVal_long(obj1, &val2);
6208 if (!SWIG_IsOK(ecode2)) {
6209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6210 }
6211 arg2 = static_cast< long >(val2);
6212 ecode3 = SWIG_AsVal_long(obj2, &val3);
6213 if (!SWIG_IsOK(ecode3)) {
6214 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6215 }
6216 arg3 = static_cast< long >(val3);
6217 {
6218 wxPoint_Set(arg1,arg2,arg3);
6219 if (PyErr_Occurred()) SWIG_fail;
6220 }
6221 resultobj = SWIG_Py_Void();
6222 return resultobj;
6223 fail:
6224 return NULL;
6225 }
6226
6227
6228 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6229 PyObject *resultobj = 0;
6230 wxPoint *arg1 = (wxPoint *) 0 ;
6231 PyObject *result = 0 ;
6232 void *argp1 = 0 ;
6233 int res1 = 0 ;
6234 PyObject *swig_obj[1] ;
6235
6236 if (!args) SWIG_fail;
6237 swig_obj[0] = args;
6238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6239 if (!SWIG_IsOK(res1)) {
6240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6241 }
6242 arg1 = reinterpret_cast< wxPoint * >(argp1);
6243 {
6244 result = (PyObject *)wxPoint_Get(arg1);
6245 if (PyErr_Occurred()) SWIG_fail;
6246 }
6247 resultobj = result;
6248 return resultobj;
6249 fail:
6250 return NULL;
6251 }
6252
6253
6254 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6255 PyObject *obj;
6256 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6257 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6258 return SWIG_Py_Void();
6259 }
6260
6261 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6262 return SWIG_Python_InitShadowInstance(args);
6263 }
6264
6265 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6266 PyObject *resultobj = 0;
6267 int arg1 = (int) 0 ;
6268 int arg2 = (int) 0 ;
6269 int arg3 = (int) 0 ;
6270 int arg4 = (int) 0 ;
6271 wxRect *result = 0 ;
6272 int val1 ;
6273 int ecode1 = 0 ;
6274 int val2 ;
6275 int ecode2 = 0 ;
6276 int val3 ;
6277 int ecode3 = 0 ;
6278 int val4 ;
6279 int ecode4 = 0 ;
6280 PyObject * obj0 = 0 ;
6281 PyObject * obj1 = 0 ;
6282 PyObject * obj2 = 0 ;
6283 PyObject * obj3 = 0 ;
6284 char * kwnames[] = {
6285 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6286 };
6287
6288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6289 if (obj0) {
6290 ecode1 = SWIG_AsVal_int(obj0, &val1);
6291 if (!SWIG_IsOK(ecode1)) {
6292 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6293 }
6294 arg1 = static_cast< int >(val1);
6295 }
6296 if (obj1) {
6297 ecode2 = SWIG_AsVal_int(obj1, &val2);
6298 if (!SWIG_IsOK(ecode2)) {
6299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6300 }
6301 arg2 = static_cast< int >(val2);
6302 }
6303 if (obj2) {
6304 ecode3 = SWIG_AsVal_int(obj2, &val3);
6305 if (!SWIG_IsOK(ecode3)) {
6306 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6307 }
6308 arg3 = static_cast< int >(val3);
6309 }
6310 if (obj3) {
6311 ecode4 = SWIG_AsVal_int(obj3, &val4);
6312 if (!SWIG_IsOK(ecode4)) {
6313 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6314 }
6315 arg4 = static_cast< int >(val4);
6316 }
6317 {
6318 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6319 if (PyErr_Occurred()) SWIG_fail;
6320 }
6321 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6322 return resultobj;
6323 fail:
6324 return NULL;
6325 }
6326
6327
6328 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6329 PyObject *resultobj = 0;
6330 wxPoint *arg1 = 0 ;
6331 wxPoint *arg2 = 0 ;
6332 wxRect *result = 0 ;
6333 wxPoint temp1 ;
6334 wxPoint temp2 ;
6335 PyObject * obj0 = 0 ;
6336 PyObject * obj1 = 0 ;
6337 char * kwnames[] = {
6338 (char *) "topLeft",(char *) "bottomRight", NULL
6339 };
6340
6341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6342 {
6343 arg1 = &temp1;
6344 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6345 }
6346 {
6347 arg2 = &temp2;
6348 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6349 }
6350 {
6351 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6352 if (PyErr_Occurred()) SWIG_fail;
6353 }
6354 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6355 return resultobj;
6356 fail:
6357 return NULL;
6358 }
6359
6360
6361 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6362 PyObject *resultobj = 0;
6363 wxPoint *arg1 = 0 ;
6364 wxSize *arg2 = 0 ;
6365 wxRect *result = 0 ;
6366 wxPoint temp1 ;
6367 wxSize temp2 ;
6368 PyObject * obj0 = 0 ;
6369 PyObject * obj1 = 0 ;
6370 char * kwnames[] = {
6371 (char *) "pos",(char *) "size", NULL
6372 };
6373
6374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6375 {
6376 arg1 = &temp1;
6377 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6378 }
6379 {
6380 arg2 = &temp2;
6381 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6382 }
6383 {
6384 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6385 if (PyErr_Occurred()) SWIG_fail;
6386 }
6387 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6388 return resultobj;
6389 fail:
6390 return NULL;
6391 }
6392
6393
6394 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6395 PyObject *resultobj = 0;
6396 wxSize *arg1 = 0 ;
6397 wxRect *result = 0 ;
6398 wxSize temp1 ;
6399 PyObject * obj0 = 0 ;
6400 char * kwnames[] = {
6401 (char *) "size", NULL
6402 };
6403
6404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6405 {
6406 arg1 = &temp1;
6407 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6408 }
6409 {
6410 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6411 if (PyErr_Occurred()) SWIG_fail;
6412 }
6413 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6414 return resultobj;
6415 fail:
6416 return NULL;
6417 }
6418
6419
6420 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6421 PyObject *resultobj = 0;
6422 wxRect *arg1 = (wxRect *) 0 ;
6423 void *argp1 = 0 ;
6424 int res1 = 0 ;
6425 PyObject *swig_obj[1] ;
6426
6427 if (!args) SWIG_fail;
6428 swig_obj[0] = args;
6429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6430 if (!SWIG_IsOK(res1)) {
6431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6432 }
6433 arg1 = reinterpret_cast< wxRect * >(argp1);
6434 {
6435 delete arg1;
6436
6437 if (PyErr_Occurred()) SWIG_fail;
6438 }
6439 resultobj = SWIG_Py_Void();
6440 return resultobj;
6441 fail:
6442 return NULL;
6443 }
6444
6445
6446 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6447 PyObject *resultobj = 0;
6448 wxRect *arg1 = (wxRect *) 0 ;
6449 int result;
6450 void *argp1 = 0 ;
6451 int res1 = 0 ;
6452 PyObject *swig_obj[1] ;
6453
6454 if (!args) SWIG_fail;
6455 swig_obj[0] = args;
6456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6457 if (!SWIG_IsOK(res1)) {
6458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6459 }
6460 arg1 = reinterpret_cast< wxRect * >(argp1);
6461 {
6462 result = (int)((wxRect const *)arg1)->GetX();
6463 if (PyErr_Occurred()) SWIG_fail;
6464 }
6465 resultobj = SWIG_From_int(static_cast< int >(result));
6466 return resultobj;
6467 fail:
6468 return NULL;
6469 }
6470
6471
6472 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6473 PyObject *resultobj = 0;
6474 wxRect *arg1 = (wxRect *) 0 ;
6475 int arg2 ;
6476 void *argp1 = 0 ;
6477 int res1 = 0 ;
6478 int val2 ;
6479 int ecode2 = 0 ;
6480 PyObject * obj0 = 0 ;
6481 PyObject * obj1 = 0 ;
6482 char * kwnames[] = {
6483 (char *) "self",(char *) "x", NULL
6484 };
6485
6486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6488 if (!SWIG_IsOK(res1)) {
6489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6490 }
6491 arg1 = reinterpret_cast< wxRect * >(argp1);
6492 ecode2 = SWIG_AsVal_int(obj1, &val2);
6493 if (!SWIG_IsOK(ecode2)) {
6494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6495 }
6496 arg2 = static_cast< int >(val2);
6497 {
6498 (arg1)->SetX(arg2);
6499 if (PyErr_Occurred()) SWIG_fail;
6500 }
6501 resultobj = SWIG_Py_Void();
6502 return resultobj;
6503 fail:
6504 return NULL;
6505 }
6506
6507
6508 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6509 PyObject *resultobj = 0;
6510 wxRect *arg1 = (wxRect *) 0 ;
6511 int result;
6512 void *argp1 = 0 ;
6513 int res1 = 0 ;
6514 PyObject *swig_obj[1] ;
6515
6516 if (!args) SWIG_fail;
6517 swig_obj[0] = args;
6518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6519 if (!SWIG_IsOK(res1)) {
6520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6521 }
6522 arg1 = reinterpret_cast< wxRect * >(argp1);
6523 {
6524 result = (int)(arg1)->GetY();
6525 if (PyErr_Occurred()) SWIG_fail;
6526 }
6527 resultobj = SWIG_From_int(static_cast< int >(result));
6528 return resultobj;
6529 fail:
6530 return NULL;
6531 }
6532
6533
6534 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6535 PyObject *resultobj = 0;
6536 wxRect *arg1 = (wxRect *) 0 ;
6537 int arg2 ;
6538 void *argp1 = 0 ;
6539 int res1 = 0 ;
6540 int val2 ;
6541 int ecode2 = 0 ;
6542 PyObject * obj0 = 0 ;
6543 PyObject * obj1 = 0 ;
6544 char * kwnames[] = {
6545 (char *) "self",(char *) "y", NULL
6546 };
6547
6548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6550 if (!SWIG_IsOK(res1)) {
6551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6552 }
6553 arg1 = reinterpret_cast< wxRect * >(argp1);
6554 ecode2 = SWIG_AsVal_int(obj1, &val2);
6555 if (!SWIG_IsOK(ecode2)) {
6556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6557 }
6558 arg2 = static_cast< int >(val2);
6559 {
6560 (arg1)->SetY(arg2);
6561 if (PyErr_Occurred()) SWIG_fail;
6562 }
6563 resultobj = SWIG_Py_Void();
6564 return resultobj;
6565 fail:
6566 return NULL;
6567 }
6568
6569
6570 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6571 PyObject *resultobj = 0;
6572 wxRect *arg1 = (wxRect *) 0 ;
6573 int result;
6574 void *argp1 = 0 ;
6575 int res1 = 0 ;
6576 PyObject *swig_obj[1] ;
6577
6578 if (!args) SWIG_fail;
6579 swig_obj[0] = args;
6580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6581 if (!SWIG_IsOK(res1)) {
6582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6583 }
6584 arg1 = reinterpret_cast< wxRect * >(argp1);
6585 {
6586 result = (int)((wxRect const *)arg1)->GetWidth();
6587 if (PyErr_Occurred()) SWIG_fail;
6588 }
6589 resultobj = SWIG_From_int(static_cast< int >(result));
6590 return resultobj;
6591 fail:
6592 return NULL;
6593 }
6594
6595
6596 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6597 PyObject *resultobj = 0;
6598 wxRect *arg1 = (wxRect *) 0 ;
6599 int arg2 ;
6600 void *argp1 = 0 ;
6601 int res1 = 0 ;
6602 int val2 ;
6603 int ecode2 = 0 ;
6604 PyObject * obj0 = 0 ;
6605 PyObject * obj1 = 0 ;
6606 char * kwnames[] = {
6607 (char *) "self",(char *) "w", NULL
6608 };
6609
6610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6612 if (!SWIG_IsOK(res1)) {
6613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6614 }
6615 arg1 = reinterpret_cast< wxRect * >(argp1);
6616 ecode2 = SWIG_AsVal_int(obj1, &val2);
6617 if (!SWIG_IsOK(ecode2)) {
6618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6619 }
6620 arg2 = static_cast< int >(val2);
6621 {
6622 (arg1)->SetWidth(arg2);
6623 if (PyErr_Occurred()) SWIG_fail;
6624 }
6625 resultobj = SWIG_Py_Void();
6626 return resultobj;
6627 fail:
6628 return NULL;
6629 }
6630
6631
6632 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6633 PyObject *resultobj = 0;
6634 wxRect *arg1 = (wxRect *) 0 ;
6635 int result;
6636 void *argp1 = 0 ;
6637 int res1 = 0 ;
6638 PyObject *swig_obj[1] ;
6639
6640 if (!args) SWIG_fail;
6641 swig_obj[0] = args;
6642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6643 if (!SWIG_IsOK(res1)) {
6644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6645 }
6646 arg1 = reinterpret_cast< wxRect * >(argp1);
6647 {
6648 result = (int)((wxRect const *)arg1)->GetHeight();
6649 if (PyErr_Occurred()) SWIG_fail;
6650 }
6651 resultobj = SWIG_From_int(static_cast< int >(result));
6652 return resultobj;
6653 fail:
6654 return NULL;
6655 }
6656
6657
6658 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6659 PyObject *resultobj = 0;
6660 wxRect *arg1 = (wxRect *) 0 ;
6661 int arg2 ;
6662 void *argp1 = 0 ;
6663 int res1 = 0 ;
6664 int val2 ;
6665 int ecode2 = 0 ;
6666 PyObject * obj0 = 0 ;
6667 PyObject * obj1 = 0 ;
6668 char * kwnames[] = {
6669 (char *) "self",(char *) "h", NULL
6670 };
6671
6672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6674 if (!SWIG_IsOK(res1)) {
6675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6676 }
6677 arg1 = reinterpret_cast< wxRect * >(argp1);
6678 ecode2 = SWIG_AsVal_int(obj1, &val2);
6679 if (!SWIG_IsOK(ecode2)) {
6680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6681 }
6682 arg2 = static_cast< int >(val2);
6683 {
6684 (arg1)->SetHeight(arg2);
6685 if (PyErr_Occurred()) SWIG_fail;
6686 }
6687 resultobj = SWIG_Py_Void();
6688 return resultobj;
6689 fail:
6690 return NULL;
6691 }
6692
6693
6694 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6695 PyObject *resultobj = 0;
6696 wxRect *arg1 = (wxRect *) 0 ;
6697 wxPoint result;
6698 void *argp1 = 0 ;
6699 int res1 = 0 ;
6700 PyObject *swig_obj[1] ;
6701
6702 if (!args) SWIG_fail;
6703 swig_obj[0] = args;
6704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6705 if (!SWIG_IsOK(res1)) {
6706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6707 }
6708 arg1 = reinterpret_cast< wxRect * >(argp1);
6709 {
6710 result = ((wxRect const *)arg1)->GetPosition();
6711 if (PyErr_Occurred()) SWIG_fail;
6712 }
6713 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6714 return resultobj;
6715 fail:
6716 return NULL;
6717 }
6718
6719
6720 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6721 PyObject *resultobj = 0;
6722 wxRect *arg1 = (wxRect *) 0 ;
6723 wxPoint *arg2 = 0 ;
6724 void *argp1 = 0 ;
6725 int res1 = 0 ;
6726 wxPoint temp2 ;
6727 PyObject * obj0 = 0 ;
6728 PyObject * obj1 = 0 ;
6729 char * kwnames[] = {
6730 (char *) "self",(char *) "p", NULL
6731 };
6732
6733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6735 if (!SWIG_IsOK(res1)) {
6736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6737 }
6738 arg1 = reinterpret_cast< wxRect * >(argp1);
6739 {
6740 arg2 = &temp2;
6741 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6742 }
6743 {
6744 (arg1)->SetPosition((wxPoint const &)*arg2);
6745 if (PyErr_Occurred()) SWIG_fail;
6746 }
6747 resultobj = SWIG_Py_Void();
6748 return resultobj;
6749 fail:
6750 return NULL;
6751 }
6752
6753
6754 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6755 PyObject *resultobj = 0;
6756 wxRect *arg1 = (wxRect *) 0 ;
6757 wxSize result;
6758 void *argp1 = 0 ;
6759 int res1 = 0 ;
6760 PyObject *swig_obj[1] ;
6761
6762 if (!args) SWIG_fail;
6763 swig_obj[0] = args;
6764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6765 if (!SWIG_IsOK(res1)) {
6766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6767 }
6768 arg1 = reinterpret_cast< wxRect * >(argp1);
6769 {
6770 result = ((wxRect const *)arg1)->GetSize();
6771 if (PyErr_Occurred()) SWIG_fail;
6772 }
6773 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6774 return resultobj;
6775 fail:
6776 return NULL;
6777 }
6778
6779
6780 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6781 PyObject *resultobj = 0;
6782 wxRect *arg1 = (wxRect *) 0 ;
6783 wxSize *arg2 = 0 ;
6784 void *argp1 = 0 ;
6785 int res1 = 0 ;
6786 wxSize temp2 ;
6787 PyObject * obj0 = 0 ;
6788 PyObject * obj1 = 0 ;
6789 char * kwnames[] = {
6790 (char *) "self",(char *) "s", NULL
6791 };
6792
6793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6795 if (!SWIG_IsOK(res1)) {
6796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6797 }
6798 arg1 = reinterpret_cast< wxRect * >(argp1);
6799 {
6800 arg2 = &temp2;
6801 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6802 }
6803 {
6804 (arg1)->SetSize((wxSize const &)*arg2);
6805 if (PyErr_Occurred()) SWIG_fail;
6806 }
6807 resultobj = SWIG_Py_Void();
6808 return resultobj;
6809 fail:
6810 return NULL;
6811 }
6812
6813
6814 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6815 PyObject *resultobj = 0;
6816 wxRect *arg1 = (wxRect *) 0 ;
6817 bool result;
6818 void *argp1 = 0 ;
6819 int res1 = 0 ;
6820 PyObject *swig_obj[1] ;
6821
6822 if (!args) SWIG_fail;
6823 swig_obj[0] = args;
6824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6825 if (!SWIG_IsOK(res1)) {
6826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6827 }
6828 arg1 = reinterpret_cast< wxRect * >(argp1);
6829 {
6830 result = (bool)((wxRect const *)arg1)->IsEmpty();
6831 if (PyErr_Occurred()) SWIG_fail;
6832 }
6833 {
6834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6835 }
6836 return resultobj;
6837 fail:
6838 return NULL;
6839 }
6840
6841
6842 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6843 PyObject *resultobj = 0;
6844 wxRect *arg1 = (wxRect *) 0 ;
6845 wxPoint result;
6846 void *argp1 = 0 ;
6847 int res1 = 0 ;
6848 PyObject *swig_obj[1] ;
6849
6850 if (!args) SWIG_fail;
6851 swig_obj[0] = args;
6852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6853 if (!SWIG_IsOK(res1)) {
6854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6855 }
6856 arg1 = reinterpret_cast< wxRect * >(argp1);
6857 {
6858 result = ((wxRect const *)arg1)->GetTopLeft();
6859 if (PyErr_Occurred()) SWIG_fail;
6860 }
6861 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6862 return resultobj;
6863 fail:
6864 return NULL;
6865 }
6866
6867
6868 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6869 PyObject *resultobj = 0;
6870 wxRect *arg1 = (wxRect *) 0 ;
6871 wxPoint *arg2 = 0 ;
6872 void *argp1 = 0 ;
6873 int res1 = 0 ;
6874 wxPoint temp2 ;
6875 PyObject * obj0 = 0 ;
6876 PyObject * obj1 = 0 ;
6877 char * kwnames[] = {
6878 (char *) "self",(char *) "p", NULL
6879 };
6880
6881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6883 if (!SWIG_IsOK(res1)) {
6884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6885 }
6886 arg1 = reinterpret_cast< wxRect * >(argp1);
6887 {
6888 arg2 = &temp2;
6889 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6890 }
6891 {
6892 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6893 if (PyErr_Occurred()) SWIG_fail;
6894 }
6895 resultobj = SWIG_Py_Void();
6896 return resultobj;
6897 fail:
6898 return NULL;
6899 }
6900
6901
6902 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6903 PyObject *resultobj = 0;
6904 wxRect *arg1 = (wxRect *) 0 ;
6905 wxPoint result;
6906 void *argp1 = 0 ;
6907 int res1 = 0 ;
6908 PyObject *swig_obj[1] ;
6909
6910 if (!args) SWIG_fail;
6911 swig_obj[0] = args;
6912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6913 if (!SWIG_IsOK(res1)) {
6914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6915 }
6916 arg1 = reinterpret_cast< wxRect * >(argp1);
6917 {
6918 result = ((wxRect const *)arg1)->GetBottomRight();
6919 if (PyErr_Occurred()) SWIG_fail;
6920 }
6921 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6922 return resultobj;
6923 fail:
6924 return NULL;
6925 }
6926
6927
6928 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6929 PyObject *resultobj = 0;
6930 wxRect *arg1 = (wxRect *) 0 ;
6931 wxPoint *arg2 = 0 ;
6932 void *argp1 = 0 ;
6933 int res1 = 0 ;
6934 wxPoint temp2 ;
6935 PyObject * obj0 = 0 ;
6936 PyObject * obj1 = 0 ;
6937 char * kwnames[] = {
6938 (char *) "self",(char *) "p", NULL
6939 };
6940
6941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6943 if (!SWIG_IsOK(res1)) {
6944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6945 }
6946 arg1 = reinterpret_cast< wxRect * >(argp1);
6947 {
6948 arg2 = &temp2;
6949 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6950 }
6951 {
6952 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6953 if (PyErr_Occurred()) SWIG_fail;
6954 }
6955 resultobj = SWIG_Py_Void();
6956 return resultobj;
6957 fail:
6958 return NULL;
6959 }
6960
6961
6962 SWIGINTERN PyObject *_wrap_Rect_GetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6963 PyObject *resultobj = 0;
6964 wxRect *arg1 = (wxRect *) 0 ;
6965 wxPoint result;
6966 void *argp1 = 0 ;
6967 int res1 = 0 ;
6968 PyObject *swig_obj[1] ;
6969
6970 if (!args) SWIG_fail;
6971 swig_obj[0] = args;
6972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6973 if (!SWIG_IsOK(res1)) {
6974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6975 }
6976 arg1 = reinterpret_cast< wxRect * >(argp1);
6977 {
6978 result = ((wxRect const *)arg1)->GetTopRight();
6979 if (PyErr_Occurred()) SWIG_fail;
6980 }
6981 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6982 return resultobj;
6983 fail:
6984 return NULL;
6985 }
6986
6987
6988 SWIGINTERN PyObject *_wrap_Rect_SetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6989 PyObject *resultobj = 0;
6990 wxRect *arg1 = (wxRect *) 0 ;
6991 wxPoint *arg2 = 0 ;
6992 void *argp1 = 0 ;
6993 int res1 = 0 ;
6994 wxPoint temp2 ;
6995 PyObject * obj0 = 0 ;
6996 PyObject * obj1 = 0 ;
6997 char * kwnames[] = {
6998 (char *) "self",(char *) "p", NULL
6999 };
7000
7001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopRight",kwnames,&obj0,&obj1)) SWIG_fail;
7002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7003 if (!SWIG_IsOK(res1)) {
7004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopRight" "', expected argument " "1"" of type '" "wxRect *""'");
7005 }
7006 arg1 = reinterpret_cast< wxRect * >(argp1);
7007 {
7008 arg2 = &temp2;
7009 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7010 }
7011 {
7012 (arg1)->SetTopRight((wxPoint const &)*arg2);
7013 if (PyErr_Occurred()) SWIG_fail;
7014 }
7015 resultobj = SWIG_Py_Void();
7016 return resultobj;
7017 fail:
7018 return NULL;
7019 }
7020
7021
7022 SWIGINTERN PyObject *_wrap_Rect_GetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7023 PyObject *resultobj = 0;
7024 wxRect *arg1 = (wxRect *) 0 ;
7025 wxPoint result;
7026 void *argp1 = 0 ;
7027 int res1 = 0 ;
7028 PyObject *swig_obj[1] ;
7029
7030 if (!args) SWIG_fail;
7031 swig_obj[0] = args;
7032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7033 if (!SWIG_IsOK(res1)) {
7034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7035 }
7036 arg1 = reinterpret_cast< wxRect * >(argp1);
7037 {
7038 result = ((wxRect const *)arg1)->GetBottomLeft();
7039 if (PyErr_Occurred()) SWIG_fail;
7040 }
7041 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7042 return resultobj;
7043 fail:
7044 return NULL;
7045 }
7046
7047
7048 SWIGINTERN PyObject *_wrap_Rect_SetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7049 PyObject *resultobj = 0;
7050 wxRect *arg1 = (wxRect *) 0 ;
7051 wxPoint *arg2 = 0 ;
7052 void *argp1 = 0 ;
7053 int res1 = 0 ;
7054 wxPoint temp2 ;
7055 PyObject * obj0 = 0 ;
7056 PyObject * obj1 = 0 ;
7057 char * kwnames[] = {
7058 (char *) "self",(char *) "p", NULL
7059 };
7060
7061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7063 if (!SWIG_IsOK(res1)) {
7064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7065 }
7066 arg1 = reinterpret_cast< wxRect * >(argp1);
7067 {
7068 arg2 = &temp2;
7069 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7070 }
7071 {
7072 (arg1)->SetBottomLeft((wxPoint const &)*arg2);
7073 if (PyErr_Occurred()) SWIG_fail;
7074 }
7075 resultobj = SWIG_Py_Void();
7076 return resultobj;
7077 fail:
7078 return NULL;
7079 }
7080
7081
7082 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7083 PyObject *resultobj = 0;
7084 wxRect *arg1 = (wxRect *) 0 ;
7085 int result;
7086 void *argp1 = 0 ;
7087 int res1 = 0 ;
7088 PyObject *swig_obj[1] ;
7089
7090 if (!args) SWIG_fail;
7091 swig_obj[0] = args;
7092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7093 if (!SWIG_IsOK(res1)) {
7094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7095 }
7096 arg1 = reinterpret_cast< wxRect * >(argp1);
7097 {
7098 result = (int)((wxRect const *)arg1)->GetLeft();
7099 if (PyErr_Occurred()) SWIG_fail;
7100 }
7101 resultobj = SWIG_From_int(static_cast< int >(result));
7102 return resultobj;
7103 fail:
7104 return NULL;
7105 }
7106
7107
7108 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7109 PyObject *resultobj = 0;
7110 wxRect *arg1 = (wxRect *) 0 ;
7111 int result;
7112 void *argp1 = 0 ;
7113 int res1 = 0 ;
7114 PyObject *swig_obj[1] ;
7115
7116 if (!args) SWIG_fail;
7117 swig_obj[0] = args;
7118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7119 if (!SWIG_IsOK(res1)) {
7120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
7121 }
7122 arg1 = reinterpret_cast< wxRect * >(argp1);
7123 {
7124 result = (int)((wxRect const *)arg1)->GetTop();
7125 if (PyErr_Occurred()) SWIG_fail;
7126 }
7127 resultobj = SWIG_From_int(static_cast< int >(result));
7128 return resultobj;
7129 fail:
7130 return NULL;
7131 }
7132
7133
7134 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7135 PyObject *resultobj = 0;
7136 wxRect *arg1 = (wxRect *) 0 ;
7137 int result;
7138 void *argp1 = 0 ;
7139 int res1 = 0 ;
7140 PyObject *swig_obj[1] ;
7141
7142 if (!args) SWIG_fail;
7143 swig_obj[0] = args;
7144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7145 if (!SWIG_IsOK(res1)) {
7146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
7147 }
7148 arg1 = reinterpret_cast< wxRect * >(argp1);
7149 {
7150 result = (int)((wxRect const *)arg1)->GetBottom();
7151 if (PyErr_Occurred()) SWIG_fail;
7152 }
7153 resultobj = SWIG_From_int(static_cast< int >(result));
7154 return resultobj;
7155 fail:
7156 return NULL;
7157 }
7158
7159
7160 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7161 PyObject *resultobj = 0;
7162 wxRect *arg1 = (wxRect *) 0 ;
7163 int result;
7164 void *argp1 = 0 ;
7165 int res1 = 0 ;
7166 PyObject *swig_obj[1] ;
7167
7168 if (!args) SWIG_fail;
7169 swig_obj[0] = args;
7170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7171 if (!SWIG_IsOK(res1)) {
7172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7173 }
7174 arg1 = reinterpret_cast< wxRect * >(argp1);
7175 {
7176 result = (int)((wxRect const *)arg1)->GetRight();
7177 if (PyErr_Occurred()) SWIG_fail;
7178 }
7179 resultobj = SWIG_From_int(static_cast< int >(result));
7180 return resultobj;
7181 fail:
7182 return NULL;
7183 }
7184
7185
7186 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7187 PyObject *resultobj = 0;
7188 wxRect *arg1 = (wxRect *) 0 ;
7189 int arg2 ;
7190 void *argp1 = 0 ;
7191 int res1 = 0 ;
7192 int val2 ;
7193 int ecode2 = 0 ;
7194 PyObject * obj0 = 0 ;
7195 PyObject * obj1 = 0 ;
7196 char * kwnames[] = {
7197 (char *) "self",(char *) "left", NULL
7198 };
7199
7200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7202 if (!SWIG_IsOK(res1)) {
7203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7204 }
7205 arg1 = reinterpret_cast< wxRect * >(argp1);
7206 ecode2 = SWIG_AsVal_int(obj1, &val2);
7207 if (!SWIG_IsOK(ecode2)) {
7208 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
7209 }
7210 arg2 = static_cast< int >(val2);
7211 {
7212 (arg1)->SetLeft(arg2);
7213 if (PyErr_Occurred()) SWIG_fail;
7214 }
7215 resultobj = SWIG_Py_Void();
7216 return resultobj;
7217 fail:
7218 return NULL;
7219 }
7220
7221
7222 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7223 PyObject *resultobj = 0;
7224 wxRect *arg1 = (wxRect *) 0 ;
7225 int arg2 ;
7226 void *argp1 = 0 ;
7227 int res1 = 0 ;
7228 int val2 ;
7229 int ecode2 = 0 ;
7230 PyObject * obj0 = 0 ;
7231 PyObject * obj1 = 0 ;
7232 char * kwnames[] = {
7233 (char *) "self",(char *) "right", NULL
7234 };
7235
7236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
7237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7238 if (!SWIG_IsOK(res1)) {
7239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
7240 }
7241 arg1 = reinterpret_cast< wxRect * >(argp1);
7242 ecode2 = SWIG_AsVal_int(obj1, &val2);
7243 if (!SWIG_IsOK(ecode2)) {
7244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7245 }
7246 arg2 = static_cast< int >(val2);
7247 {
7248 (arg1)->SetRight(arg2);
7249 if (PyErr_Occurred()) SWIG_fail;
7250 }
7251 resultobj = SWIG_Py_Void();
7252 return resultobj;
7253 fail:
7254 return NULL;
7255 }
7256
7257
7258 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7259 PyObject *resultobj = 0;
7260 wxRect *arg1 = (wxRect *) 0 ;
7261 int arg2 ;
7262 void *argp1 = 0 ;
7263 int res1 = 0 ;
7264 int val2 ;
7265 int ecode2 = 0 ;
7266 PyObject * obj0 = 0 ;
7267 PyObject * obj1 = 0 ;
7268 char * kwnames[] = {
7269 (char *) "self",(char *) "top", NULL
7270 };
7271
7272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7274 if (!SWIG_IsOK(res1)) {
7275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7276 }
7277 arg1 = reinterpret_cast< wxRect * >(argp1);
7278 ecode2 = SWIG_AsVal_int(obj1, &val2);
7279 if (!SWIG_IsOK(ecode2)) {
7280 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7281 }
7282 arg2 = static_cast< int >(val2);
7283 {
7284 (arg1)->SetTop(arg2);
7285 if (PyErr_Occurred()) SWIG_fail;
7286 }
7287 resultobj = SWIG_Py_Void();
7288 return resultobj;
7289 fail:
7290 return NULL;
7291 }
7292
7293
7294 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7295 PyObject *resultobj = 0;
7296 wxRect *arg1 = (wxRect *) 0 ;
7297 int arg2 ;
7298 void *argp1 = 0 ;
7299 int res1 = 0 ;
7300 int val2 ;
7301 int ecode2 = 0 ;
7302 PyObject * obj0 = 0 ;
7303 PyObject * obj1 = 0 ;
7304 char * kwnames[] = {
7305 (char *) "self",(char *) "bottom", NULL
7306 };
7307
7308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7310 if (!SWIG_IsOK(res1)) {
7311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7312 }
7313 arg1 = reinterpret_cast< wxRect * >(argp1);
7314 ecode2 = SWIG_AsVal_int(obj1, &val2);
7315 if (!SWIG_IsOK(ecode2)) {
7316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7317 }
7318 arg2 = static_cast< int >(val2);
7319 {
7320 (arg1)->SetBottom(arg2);
7321 if (PyErr_Occurred()) SWIG_fail;
7322 }
7323 resultobj = SWIG_Py_Void();
7324 return resultobj;
7325 fail:
7326 return NULL;
7327 }
7328
7329
7330 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7331 PyObject *resultobj = 0;
7332 wxRect *arg1 = (wxRect *) 0 ;
7333 int arg2 ;
7334 int arg3 ;
7335 wxRect result;
7336 void *argp1 = 0 ;
7337 int res1 = 0 ;
7338 int val2 ;
7339 int ecode2 = 0 ;
7340 int val3 ;
7341 int ecode3 = 0 ;
7342 PyObject * obj0 = 0 ;
7343 PyObject * obj1 = 0 ;
7344 PyObject * obj2 = 0 ;
7345 char * kwnames[] = {
7346 (char *) "self",(char *) "dx",(char *) "dy", NULL
7347 };
7348
7349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7351 if (!SWIG_IsOK(res1)) {
7352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7353 }
7354 arg1 = reinterpret_cast< wxRect * >(argp1);
7355 ecode2 = SWIG_AsVal_int(obj1, &val2);
7356 if (!SWIG_IsOK(ecode2)) {
7357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7358 }
7359 arg2 = static_cast< int >(val2);
7360 ecode3 = SWIG_AsVal_int(obj2, &val3);
7361 if (!SWIG_IsOK(ecode3)) {
7362 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7363 }
7364 arg3 = static_cast< int >(val3);
7365 {
7366 result = (arg1)->Inflate(arg2,arg3);
7367 if (PyErr_Occurred()) SWIG_fail;
7368 }
7369 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7370 return resultobj;
7371 fail:
7372 return NULL;
7373 }
7374
7375
7376 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7377 PyObject *resultobj = 0;
7378 wxRect *arg1 = (wxRect *) 0 ;
7379 int arg2 ;
7380 int arg3 ;
7381 wxRect *result = 0 ;
7382 void *argp1 = 0 ;
7383 int res1 = 0 ;
7384 int val2 ;
7385 int ecode2 = 0 ;
7386 int val3 ;
7387 int ecode3 = 0 ;
7388 PyObject * obj0 = 0 ;
7389 PyObject * obj1 = 0 ;
7390 PyObject * obj2 = 0 ;
7391 char * kwnames[] = {
7392 (char *) "self",(char *) "dx",(char *) "dy", NULL
7393 };
7394
7395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7397 if (!SWIG_IsOK(res1)) {
7398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7399 }
7400 arg1 = reinterpret_cast< wxRect * >(argp1);
7401 ecode2 = SWIG_AsVal_int(obj1, &val2);
7402 if (!SWIG_IsOK(ecode2)) {
7403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7404 }
7405 arg2 = static_cast< int >(val2);
7406 ecode3 = SWIG_AsVal_int(obj2, &val3);
7407 if (!SWIG_IsOK(ecode3)) {
7408 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7409 }
7410 arg3 = static_cast< int >(val3);
7411 {
7412 {
7413 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7414 result = (wxRect *) &_result_ref;
7415 }
7416 if (PyErr_Occurred()) SWIG_fail;
7417 }
7418 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7419 return resultobj;
7420 fail:
7421 return NULL;
7422 }
7423
7424
7425 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7426 PyObject *resultobj = 0;
7427 wxRect *arg1 = (wxRect *) 0 ;
7428 int arg2 ;
7429 int arg3 ;
7430 void *argp1 = 0 ;
7431 int res1 = 0 ;
7432 int val2 ;
7433 int ecode2 = 0 ;
7434 int val3 ;
7435 int ecode3 = 0 ;
7436 PyObject * obj0 = 0 ;
7437 PyObject * obj1 = 0 ;
7438 PyObject * obj2 = 0 ;
7439 char * kwnames[] = {
7440 (char *) "self",(char *) "dx",(char *) "dy", NULL
7441 };
7442
7443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7445 if (!SWIG_IsOK(res1)) {
7446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7447 }
7448 arg1 = reinterpret_cast< wxRect * >(argp1);
7449 ecode2 = SWIG_AsVal_int(obj1, &val2);
7450 if (!SWIG_IsOK(ecode2)) {
7451 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7452 }
7453 arg2 = static_cast< int >(val2);
7454 ecode3 = SWIG_AsVal_int(obj2, &val3);
7455 if (!SWIG_IsOK(ecode3)) {
7456 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7457 }
7458 arg3 = static_cast< int >(val3);
7459 {
7460 (arg1)->Offset(arg2,arg3);
7461 if (PyErr_Occurred()) SWIG_fail;
7462 }
7463 resultobj = SWIG_Py_Void();
7464 return resultobj;
7465 fail:
7466 return NULL;
7467 }
7468
7469
7470 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7471 PyObject *resultobj = 0;
7472 wxRect *arg1 = (wxRect *) 0 ;
7473 wxPoint *arg2 = 0 ;
7474 void *argp1 = 0 ;
7475 int res1 = 0 ;
7476 wxPoint temp2 ;
7477 PyObject * obj0 = 0 ;
7478 PyObject * obj1 = 0 ;
7479 char * kwnames[] = {
7480 (char *) "self",(char *) "pt", NULL
7481 };
7482
7483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7485 if (!SWIG_IsOK(res1)) {
7486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7487 }
7488 arg1 = reinterpret_cast< wxRect * >(argp1);
7489 {
7490 arg2 = &temp2;
7491 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7492 }
7493 {
7494 (arg1)->Offset((wxPoint const &)*arg2);
7495 if (PyErr_Occurred()) SWIG_fail;
7496 }
7497 resultobj = SWIG_Py_Void();
7498 return resultobj;
7499 fail:
7500 return NULL;
7501 }
7502
7503
7504 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7505 PyObject *resultobj = 0;
7506 wxRect *arg1 = (wxRect *) 0 ;
7507 wxRect *arg2 = 0 ;
7508 wxRect result;
7509 void *argp1 = 0 ;
7510 int res1 = 0 ;
7511 wxRect temp2 ;
7512 PyObject * obj0 = 0 ;
7513 PyObject * obj1 = 0 ;
7514 char * kwnames[] = {
7515 (char *) "self",(char *) "rect", NULL
7516 };
7517
7518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7520 if (!SWIG_IsOK(res1)) {
7521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7522 }
7523 arg1 = reinterpret_cast< wxRect * >(argp1);
7524 {
7525 arg2 = &temp2;
7526 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7527 }
7528 {
7529 result = (arg1)->Intersect((wxRect const &)*arg2);
7530 if (PyErr_Occurred()) SWIG_fail;
7531 }
7532 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7533 return resultobj;
7534 fail:
7535 return NULL;
7536 }
7537
7538
7539 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7540 PyObject *resultobj = 0;
7541 wxRect *arg1 = (wxRect *) 0 ;
7542 wxRect *arg2 = 0 ;
7543 wxRect result;
7544 void *argp1 = 0 ;
7545 int res1 = 0 ;
7546 wxRect temp2 ;
7547 PyObject * obj0 = 0 ;
7548 PyObject * obj1 = 0 ;
7549 char * kwnames[] = {
7550 (char *) "self",(char *) "rect", NULL
7551 };
7552
7553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7555 if (!SWIG_IsOK(res1)) {
7556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7557 }
7558 arg1 = reinterpret_cast< wxRect * >(argp1);
7559 {
7560 arg2 = &temp2;
7561 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7562 }
7563 {
7564 result = (arg1)->Union((wxRect const &)*arg2);
7565 if (PyErr_Occurred()) SWIG_fail;
7566 }
7567 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7568 return resultobj;
7569 fail:
7570 return NULL;
7571 }
7572
7573
7574 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7575 PyObject *resultobj = 0;
7576 wxRect *arg1 = (wxRect *) 0 ;
7577 wxRect *arg2 = 0 ;
7578 wxRect result;
7579 void *argp1 = 0 ;
7580 int res1 = 0 ;
7581 wxRect temp2 ;
7582 PyObject * obj0 = 0 ;
7583 PyObject * obj1 = 0 ;
7584 char * kwnames[] = {
7585 (char *) "self",(char *) "rect", NULL
7586 };
7587
7588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7590 if (!SWIG_IsOK(res1)) {
7591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7592 }
7593 arg1 = reinterpret_cast< wxRect * >(argp1);
7594 {
7595 arg2 = &temp2;
7596 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7597 }
7598 {
7599 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7600 if (PyErr_Occurred()) SWIG_fail;
7601 }
7602 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7603 return resultobj;
7604 fail:
7605 return NULL;
7606 }
7607
7608
7609 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7610 PyObject *resultobj = 0;
7611 wxRect *arg1 = (wxRect *) 0 ;
7612 wxRect *arg2 = 0 ;
7613 wxRect *result = 0 ;
7614 void *argp1 = 0 ;
7615 int res1 = 0 ;
7616 wxRect temp2 ;
7617 PyObject * obj0 = 0 ;
7618 PyObject * obj1 = 0 ;
7619 char * kwnames[] = {
7620 (char *) "self",(char *) "rect", NULL
7621 };
7622
7623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7625 if (!SWIG_IsOK(res1)) {
7626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7627 }
7628 arg1 = reinterpret_cast< wxRect * >(argp1);
7629 {
7630 arg2 = &temp2;
7631 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7632 }
7633 {
7634 {
7635 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7636 result = (wxRect *) &_result_ref;
7637 }
7638 if (PyErr_Occurred()) SWIG_fail;
7639 }
7640 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7641 return resultobj;
7642 fail:
7643 return NULL;
7644 }
7645
7646
7647 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7648 PyObject *resultobj = 0;
7649 wxRect *arg1 = (wxRect *) 0 ;
7650 PyObject *arg2 = (PyObject *) 0 ;
7651 bool result;
7652 void *argp1 = 0 ;
7653 int res1 = 0 ;
7654 PyObject * obj0 = 0 ;
7655 PyObject * obj1 = 0 ;
7656 char * kwnames[] = {
7657 (char *) "self",(char *) "other", NULL
7658 };
7659
7660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7662 if (!SWIG_IsOK(res1)) {
7663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7664 }
7665 arg1 = reinterpret_cast< wxRect * >(argp1);
7666 arg2 = obj1;
7667 {
7668 result = (bool)wxRect___eq__(arg1,arg2);
7669 if (PyErr_Occurred()) SWIG_fail;
7670 }
7671 {
7672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7673 }
7674 return resultobj;
7675 fail:
7676 return NULL;
7677 }
7678
7679
7680 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7681 PyObject *resultobj = 0;
7682 wxRect *arg1 = (wxRect *) 0 ;
7683 PyObject *arg2 = (PyObject *) 0 ;
7684 bool result;
7685 void *argp1 = 0 ;
7686 int res1 = 0 ;
7687 PyObject * obj0 = 0 ;
7688 PyObject * obj1 = 0 ;
7689 char * kwnames[] = {
7690 (char *) "self",(char *) "other", NULL
7691 };
7692
7693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7695 if (!SWIG_IsOK(res1)) {
7696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7697 }
7698 arg1 = reinterpret_cast< wxRect * >(argp1);
7699 arg2 = obj1;
7700 {
7701 result = (bool)wxRect___ne__(arg1,arg2);
7702 if (PyErr_Occurred()) SWIG_fail;
7703 }
7704 {
7705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7706 }
7707 return resultobj;
7708 fail:
7709 return NULL;
7710 }
7711
7712
7713 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7714 PyObject *resultobj = 0;
7715 wxRect *arg1 = (wxRect *) 0 ;
7716 int arg2 ;
7717 int arg3 ;
7718 bool result;
7719 void *argp1 = 0 ;
7720 int res1 = 0 ;
7721 int val2 ;
7722 int ecode2 = 0 ;
7723 int val3 ;
7724 int ecode3 = 0 ;
7725 PyObject * obj0 = 0 ;
7726 PyObject * obj1 = 0 ;
7727 PyObject * obj2 = 0 ;
7728 char * kwnames[] = {
7729 (char *) "self",(char *) "x",(char *) "y", NULL
7730 };
7731
7732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7734 if (!SWIG_IsOK(res1)) {
7735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7736 }
7737 arg1 = reinterpret_cast< wxRect * >(argp1);
7738 ecode2 = SWIG_AsVal_int(obj1, &val2);
7739 if (!SWIG_IsOK(ecode2)) {
7740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7741 }
7742 arg2 = static_cast< int >(val2);
7743 ecode3 = SWIG_AsVal_int(obj2, &val3);
7744 if (!SWIG_IsOK(ecode3)) {
7745 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7746 }
7747 arg3 = static_cast< int >(val3);
7748 {
7749 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7750 if (PyErr_Occurred()) SWIG_fail;
7751 }
7752 {
7753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7754 }
7755 return resultobj;
7756 fail:
7757 return NULL;
7758 }
7759
7760
7761 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7762 PyObject *resultobj = 0;
7763 wxRect *arg1 = (wxRect *) 0 ;
7764 wxPoint *arg2 = 0 ;
7765 bool result;
7766 void *argp1 = 0 ;
7767 int res1 = 0 ;
7768 wxPoint temp2 ;
7769 PyObject * obj0 = 0 ;
7770 PyObject * obj1 = 0 ;
7771 char * kwnames[] = {
7772 (char *) "self",(char *) "pt", NULL
7773 };
7774
7775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7777 if (!SWIG_IsOK(res1)) {
7778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7779 }
7780 arg1 = reinterpret_cast< wxRect * >(argp1);
7781 {
7782 arg2 = &temp2;
7783 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7784 }
7785 {
7786 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7787 if (PyErr_Occurred()) SWIG_fail;
7788 }
7789 {
7790 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7791 }
7792 return resultobj;
7793 fail:
7794 return NULL;
7795 }
7796
7797
7798 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7799 PyObject *resultobj = 0;
7800 wxRect *arg1 = (wxRect *) 0 ;
7801 wxRect *arg2 = 0 ;
7802 bool result;
7803 void *argp1 = 0 ;
7804 int res1 = 0 ;
7805 wxRect temp2 ;
7806 PyObject * obj0 = 0 ;
7807 PyObject * obj1 = 0 ;
7808 char * kwnames[] = {
7809 (char *) "self",(char *) "rect", NULL
7810 };
7811
7812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7814 if (!SWIG_IsOK(res1)) {
7815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7816 }
7817 arg1 = reinterpret_cast< wxRect * >(argp1);
7818 {
7819 arg2 = &temp2;
7820 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7821 }
7822 {
7823 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7824 if (PyErr_Occurred()) SWIG_fail;
7825 }
7826 {
7827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7828 }
7829 return resultobj;
7830 fail:
7831 return NULL;
7832 }
7833
7834
7835 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7836 PyObject *resultobj = 0;
7837 wxRect *arg1 = (wxRect *) 0 ;
7838 wxRect *arg2 = 0 ;
7839 bool result;
7840 void *argp1 = 0 ;
7841 int res1 = 0 ;
7842 wxRect temp2 ;
7843 PyObject * obj0 = 0 ;
7844 PyObject * obj1 = 0 ;
7845 char * kwnames[] = {
7846 (char *) "self",(char *) "rect", NULL
7847 };
7848
7849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7851 if (!SWIG_IsOK(res1)) {
7852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7853 }
7854 arg1 = reinterpret_cast< wxRect * >(argp1);
7855 {
7856 arg2 = &temp2;
7857 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7858 }
7859 {
7860 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7861 if (PyErr_Occurred()) SWIG_fail;
7862 }
7863 {
7864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7865 }
7866 return resultobj;
7867 fail:
7868 return NULL;
7869 }
7870
7871
7872 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7873 PyObject *resultobj = 0;
7874 wxRect *arg1 = (wxRect *) 0 ;
7875 wxRect *arg2 = 0 ;
7876 int arg3 = (int) wxBOTH ;
7877 wxRect result;
7878 void *argp1 = 0 ;
7879 int res1 = 0 ;
7880 wxRect temp2 ;
7881 int val3 ;
7882 int ecode3 = 0 ;
7883 PyObject * obj0 = 0 ;
7884 PyObject * obj1 = 0 ;
7885 PyObject * obj2 = 0 ;
7886 char * kwnames[] = {
7887 (char *) "self",(char *) "r",(char *) "dir", NULL
7888 };
7889
7890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7892 if (!SWIG_IsOK(res1)) {
7893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7894 }
7895 arg1 = reinterpret_cast< wxRect * >(argp1);
7896 {
7897 arg2 = &temp2;
7898 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7899 }
7900 if (obj2) {
7901 ecode3 = SWIG_AsVal_int(obj2, &val3);
7902 if (!SWIG_IsOK(ecode3)) {
7903 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7904 }
7905 arg3 = static_cast< int >(val3);
7906 }
7907 {
7908 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7909 if (PyErr_Occurred()) SWIG_fail;
7910 }
7911 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7912 return resultobj;
7913 fail:
7914 return NULL;
7915 }
7916
7917
7918 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7919 PyObject *resultobj = 0;
7920 wxRect *arg1 = (wxRect *) 0 ;
7921 int arg2 ;
7922 void *argp1 = 0 ;
7923 int res1 = 0 ;
7924 int val2 ;
7925 int ecode2 = 0 ;
7926 PyObject *swig_obj[2] ;
7927
7928 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7930 if (!SWIG_IsOK(res1)) {
7931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7932 }
7933 arg1 = reinterpret_cast< wxRect * >(argp1);
7934 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7935 if (!SWIG_IsOK(ecode2)) {
7936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7937 }
7938 arg2 = static_cast< int >(val2);
7939 if (arg1) (arg1)->x = arg2;
7940
7941 resultobj = SWIG_Py_Void();
7942 return resultobj;
7943 fail:
7944 return NULL;
7945 }
7946
7947
7948 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7949 PyObject *resultobj = 0;
7950 wxRect *arg1 = (wxRect *) 0 ;
7951 int result;
7952 void *argp1 = 0 ;
7953 int res1 = 0 ;
7954 PyObject *swig_obj[1] ;
7955
7956 if (!args) SWIG_fail;
7957 swig_obj[0] = args;
7958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7959 if (!SWIG_IsOK(res1)) {
7960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7961 }
7962 arg1 = reinterpret_cast< wxRect * >(argp1);
7963 result = (int) ((arg1)->x);
7964 resultobj = SWIG_From_int(static_cast< int >(result));
7965 return resultobj;
7966 fail:
7967 return NULL;
7968 }
7969
7970
7971 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7972 PyObject *resultobj = 0;
7973 wxRect *arg1 = (wxRect *) 0 ;
7974 int arg2 ;
7975 void *argp1 = 0 ;
7976 int res1 = 0 ;
7977 int val2 ;
7978 int ecode2 = 0 ;
7979 PyObject *swig_obj[2] ;
7980
7981 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7983 if (!SWIG_IsOK(res1)) {
7984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7985 }
7986 arg1 = reinterpret_cast< wxRect * >(argp1);
7987 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7988 if (!SWIG_IsOK(ecode2)) {
7989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7990 }
7991 arg2 = static_cast< int >(val2);
7992 if (arg1) (arg1)->y = arg2;
7993
7994 resultobj = SWIG_Py_Void();
7995 return resultobj;
7996 fail:
7997 return NULL;
7998 }
7999
8000
8001 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8002 PyObject *resultobj = 0;
8003 wxRect *arg1 = (wxRect *) 0 ;
8004 int result;
8005 void *argp1 = 0 ;
8006 int res1 = 0 ;
8007 PyObject *swig_obj[1] ;
8008
8009 if (!args) SWIG_fail;
8010 swig_obj[0] = args;
8011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8012 if (!SWIG_IsOK(res1)) {
8013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
8014 }
8015 arg1 = reinterpret_cast< wxRect * >(argp1);
8016 result = (int) ((arg1)->y);
8017 resultobj = SWIG_From_int(static_cast< int >(result));
8018 return resultobj;
8019 fail:
8020 return NULL;
8021 }
8022
8023
8024 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8025 PyObject *resultobj = 0;
8026 wxRect *arg1 = (wxRect *) 0 ;
8027 int arg2 ;
8028 void *argp1 = 0 ;
8029 int res1 = 0 ;
8030 int val2 ;
8031 int ecode2 = 0 ;
8032 PyObject *swig_obj[2] ;
8033
8034 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
8035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8036 if (!SWIG_IsOK(res1)) {
8037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
8038 }
8039 arg1 = reinterpret_cast< wxRect * >(argp1);
8040 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8041 if (!SWIG_IsOK(ecode2)) {
8042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
8043 }
8044 arg2 = static_cast< int >(val2);
8045 if (arg1) (arg1)->width = arg2;
8046
8047 resultobj = SWIG_Py_Void();
8048 return resultobj;
8049 fail:
8050 return NULL;
8051 }
8052
8053
8054 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8055 PyObject *resultobj = 0;
8056 wxRect *arg1 = (wxRect *) 0 ;
8057 int result;
8058 void *argp1 = 0 ;
8059 int res1 = 0 ;
8060 PyObject *swig_obj[1] ;
8061
8062 if (!args) SWIG_fail;
8063 swig_obj[0] = args;
8064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8065 if (!SWIG_IsOK(res1)) {
8066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
8067 }
8068 arg1 = reinterpret_cast< wxRect * >(argp1);
8069 result = (int) ((arg1)->width);
8070 resultobj = SWIG_From_int(static_cast< int >(result));
8071 return resultobj;
8072 fail:
8073 return NULL;
8074 }
8075
8076
8077 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8078 PyObject *resultobj = 0;
8079 wxRect *arg1 = (wxRect *) 0 ;
8080 int arg2 ;
8081 void *argp1 = 0 ;
8082 int res1 = 0 ;
8083 int val2 ;
8084 int ecode2 = 0 ;
8085 PyObject *swig_obj[2] ;
8086
8087 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
8088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8089 if (!SWIG_IsOK(res1)) {
8090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
8091 }
8092 arg1 = reinterpret_cast< wxRect * >(argp1);
8093 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8094 if (!SWIG_IsOK(ecode2)) {
8095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
8096 }
8097 arg2 = static_cast< int >(val2);
8098 if (arg1) (arg1)->height = arg2;
8099
8100 resultobj = SWIG_Py_Void();
8101 return resultobj;
8102 fail:
8103 return NULL;
8104 }
8105
8106
8107 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8108 PyObject *resultobj = 0;
8109 wxRect *arg1 = (wxRect *) 0 ;
8110 int result;
8111 void *argp1 = 0 ;
8112 int res1 = 0 ;
8113 PyObject *swig_obj[1] ;
8114
8115 if (!args) SWIG_fail;
8116 swig_obj[0] = args;
8117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8118 if (!SWIG_IsOK(res1)) {
8119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
8120 }
8121 arg1 = reinterpret_cast< wxRect * >(argp1);
8122 result = (int) ((arg1)->height);
8123 resultobj = SWIG_From_int(static_cast< int >(result));
8124 return resultobj;
8125 fail:
8126 return NULL;
8127 }
8128
8129
8130 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8131 PyObject *resultobj = 0;
8132 wxRect *arg1 = (wxRect *) 0 ;
8133 int arg2 = (int) 0 ;
8134 int arg3 = (int) 0 ;
8135 int arg4 = (int) 0 ;
8136 int arg5 = (int) 0 ;
8137 void *argp1 = 0 ;
8138 int res1 = 0 ;
8139 int val2 ;
8140 int ecode2 = 0 ;
8141 int val3 ;
8142 int ecode3 = 0 ;
8143 int val4 ;
8144 int ecode4 = 0 ;
8145 int val5 ;
8146 int ecode5 = 0 ;
8147 PyObject * obj0 = 0 ;
8148 PyObject * obj1 = 0 ;
8149 PyObject * obj2 = 0 ;
8150 PyObject * obj3 = 0 ;
8151 PyObject * obj4 = 0 ;
8152 char * kwnames[] = {
8153 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8154 };
8155
8156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8158 if (!SWIG_IsOK(res1)) {
8159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
8160 }
8161 arg1 = reinterpret_cast< wxRect * >(argp1);
8162 if (obj1) {
8163 ecode2 = SWIG_AsVal_int(obj1, &val2);
8164 if (!SWIG_IsOK(ecode2)) {
8165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
8166 }
8167 arg2 = static_cast< int >(val2);
8168 }
8169 if (obj2) {
8170 ecode3 = SWIG_AsVal_int(obj2, &val3);
8171 if (!SWIG_IsOK(ecode3)) {
8172 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
8173 }
8174 arg3 = static_cast< int >(val3);
8175 }
8176 if (obj3) {
8177 ecode4 = SWIG_AsVal_int(obj3, &val4);
8178 if (!SWIG_IsOK(ecode4)) {
8179 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
8180 }
8181 arg4 = static_cast< int >(val4);
8182 }
8183 if (obj4) {
8184 ecode5 = SWIG_AsVal_int(obj4, &val5);
8185 if (!SWIG_IsOK(ecode5)) {
8186 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
8187 }
8188 arg5 = static_cast< int >(val5);
8189 }
8190 {
8191 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
8192 if (PyErr_Occurred()) SWIG_fail;
8193 }
8194 resultobj = SWIG_Py_Void();
8195 return resultobj;
8196 fail:
8197 return NULL;
8198 }
8199
8200
8201 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8202 PyObject *resultobj = 0;
8203 wxRect *arg1 = (wxRect *) 0 ;
8204 PyObject *result = 0 ;
8205 void *argp1 = 0 ;
8206 int res1 = 0 ;
8207 PyObject *swig_obj[1] ;
8208
8209 if (!args) SWIG_fail;
8210 swig_obj[0] = args;
8211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8212 if (!SWIG_IsOK(res1)) {
8213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8214 }
8215 arg1 = reinterpret_cast< wxRect * >(argp1);
8216 {
8217 result = (PyObject *)wxRect_Get(arg1);
8218 if (PyErr_Occurred()) SWIG_fail;
8219 }
8220 resultobj = result;
8221 return resultobj;
8222 fail:
8223 return NULL;
8224 }
8225
8226
8227 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8228 PyObject *obj;
8229 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8230 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8231 return SWIG_Py_Void();
8232 }
8233
8234 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8235 return SWIG_Python_InitShadowInstance(args);
8236 }
8237
8238 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8239 PyObject *resultobj = 0;
8240 wxRect *arg1 = (wxRect *) 0 ;
8241 wxRect *arg2 = (wxRect *) 0 ;
8242 PyObject *result = 0 ;
8243 void *argp1 = 0 ;
8244 int res1 = 0 ;
8245 void *argp2 = 0 ;
8246 int res2 = 0 ;
8247 PyObject * obj0 = 0 ;
8248 PyObject * obj1 = 0 ;
8249 char * kwnames[] = {
8250 (char *) "r1",(char *) "r2", NULL
8251 };
8252
8253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8255 if (!SWIG_IsOK(res1)) {
8256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8257 }
8258 arg1 = reinterpret_cast< wxRect * >(argp1);
8259 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8260 if (!SWIG_IsOK(res2)) {
8261 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8262 }
8263 arg2 = reinterpret_cast< wxRect * >(argp2);
8264 {
8265 if (!wxPyCheckForApp()) SWIG_fail;
8266 PyThreadState* __tstate = wxPyBeginAllowThreads();
8267 result = (PyObject *)wxIntersectRect(arg1,arg2);
8268 wxPyEndAllowThreads(__tstate);
8269 if (PyErr_Occurred()) SWIG_fail;
8270 }
8271 resultobj = result;
8272 return resultobj;
8273 fail:
8274 return NULL;
8275 }
8276
8277
8278 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8279 PyObject *resultobj = 0;
8280 double arg1 = (double) 0.0 ;
8281 double arg2 = (double) 0.0 ;
8282 wxPoint2D *result = 0 ;
8283 double val1 ;
8284 int ecode1 = 0 ;
8285 double val2 ;
8286 int ecode2 = 0 ;
8287 PyObject * obj0 = 0 ;
8288 PyObject * obj1 = 0 ;
8289 char * kwnames[] = {
8290 (char *) "x",(char *) "y", NULL
8291 };
8292
8293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8294 if (obj0) {
8295 ecode1 = SWIG_AsVal_double(obj0, &val1);
8296 if (!SWIG_IsOK(ecode1)) {
8297 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8298 }
8299 arg1 = static_cast< double >(val1);
8300 }
8301 if (obj1) {
8302 ecode2 = SWIG_AsVal_double(obj1, &val2);
8303 if (!SWIG_IsOK(ecode2)) {
8304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8305 }
8306 arg2 = static_cast< double >(val2);
8307 }
8308 {
8309 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8310 if (PyErr_Occurred()) SWIG_fail;
8311 }
8312 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8313 return resultobj;
8314 fail:
8315 return NULL;
8316 }
8317
8318
8319 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8320 PyObject *resultobj = 0;
8321 wxPoint2D *arg1 = 0 ;
8322 wxPoint2D *result = 0 ;
8323 wxPoint2D temp1 ;
8324 PyObject * obj0 = 0 ;
8325 char * kwnames[] = {
8326 (char *) "pt", NULL
8327 };
8328
8329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8330 {
8331 arg1 = &temp1;
8332 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8333 }
8334 {
8335 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8336 if (PyErr_Occurred()) SWIG_fail;
8337 }
8338 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8339 return resultobj;
8340 fail:
8341 return NULL;
8342 }
8343
8344
8345 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8346 PyObject *resultobj = 0;
8347 wxPoint *arg1 = 0 ;
8348 wxPoint2D *result = 0 ;
8349 wxPoint temp1 ;
8350 PyObject * obj0 = 0 ;
8351 char * kwnames[] = {
8352 (char *) "pt", NULL
8353 };
8354
8355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8356 {
8357 arg1 = &temp1;
8358 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8359 }
8360 {
8361 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8362 if (PyErr_Occurred()) SWIG_fail;
8363 }
8364 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8365 return resultobj;
8366 fail:
8367 return NULL;
8368 }
8369
8370
8371 SWIGINTERN PyObject *_wrap_delete_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8372 PyObject *resultobj = 0;
8373 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8374 void *argp1 = 0 ;
8375 int res1 = 0 ;
8376 PyObject *swig_obj[1] ;
8377
8378 if (!args) SWIG_fail;
8379 swig_obj[0] = args;
8380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8381 if (!SWIG_IsOK(res1)) {
8382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point2D" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8383 }
8384 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8385 {
8386 delete arg1;
8387
8388 if (PyErr_Occurred()) SWIG_fail;
8389 }
8390 resultobj = SWIG_Py_Void();
8391 return resultobj;
8392 fail:
8393 return NULL;
8394 }
8395
8396
8397 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8398 PyObject *resultobj = 0;
8399 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8400 int *arg2 = (int *) 0 ;
8401 int *arg3 = (int *) 0 ;
8402 void *argp1 = 0 ;
8403 int res1 = 0 ;
8404 int temp2 ;
8405 int res2 = SWIG_TMPOBJ ;
8406 int temp3 ;
8407 int res3 = SWIG_TMPOBJ ;
8408 PyObject *swig_obj[1] ;
8409
8410 arg2 = &temp2;
8411 arg3 = &temp3;
8412 if (!args) SWIG_fail;
8413 swig_obj[0] = args;
8414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8415 if (!SWIG_IsOK(res1)) {
8416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8417 }
8418 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8419 {
8420 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8421 if (PyErr_Occurred()) SWIG_fail;
8422 }
8423 resultobj = SWIG_Py_Void();
8424 if (SWIG_IsTmpObj(res2)) {
8425 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8426 } else {
8427 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8428 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8429 }
8430 if (SWIG_IsTmpObj(res3)) {
8431 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8432 } else {
8433 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8434 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8435 }
8436 return resultobj;
8437 fail:
8438 return NULL;
8439 }
8440
8441
8442 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8443 PyObject *resultobj = 0;
8444 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8445 int *arg2 = (int *) 0 ;
8446 int *arg3 = (int *) 0 ;
8447 void *argp1 = 0 ;
8448 int res1 = 0 ;
8449 int temp2 ;
8450 int res2 = SWIG_TMPOBJ ;
8451 int temp3 ;
8452 int res3 = SWIG_TMPOBJ ;
8453 PyObject *swig_obj[1] ;
8454
8455 arg2 = &temp2;
8456 arg3 = &temp3;
8457 if (!args) SWIG_fail;
8458 swig_obj[0] = args;
8459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8460 if (!SWIG_IsOK(res1)) {
8461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8462 }
8463 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8464 {
8465 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8466 if (PyErr_Occurred()) SWIG_fail;
8467 }
8468 resultobj = SWIG_Py_Void();
8469 if (SWIG_IsTmpObj(res2)) {
8470 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8471 } else {
8472 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8473 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8474 }
8475 if (SWIG_IsTmpObj(res3)) {
8476 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8477 } else {
8478 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8479 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8480 }
8481 return resultobj;
8482 fail:
8483 return NULL;
8484 }
8485
8486
8487 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8488 PyObject *resultobj = 0;
8489 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8490 double result;
8491 void *argp1 = 0 ;
8492 int res1 = 0 ;
8493 PyObject *swig_obj[1] ;
8494
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_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8500 }
8501 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8502 {
8503 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8504 if (PyErr_Occurred()) SWIG_fail;
8505 }
8506 resultobj = SWIG_From_double(static_cast< double >(result));
8507 return resultobj;
8508 fail:
8509 return NULL;
8510 }
8511
8512
8513 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8514 PyObject *resultobj = 0;
8515 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8516 double result;
8517 void *argp1 = 0 ;
8518 int res1 = 0 ;
8519 PyObject *swig_obj[1] ;
8520
8521 if (!args) SWIG_fail;
8522 swig_obj[0] = args;
8523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8524 if (!SWIG_IsOK(res1)) {
8525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8526 }
8527 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8528 {
8529 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8530 if (PyErr_Occurred()) SWIG_fail;
8531 }
8532 resultobj = SWIG_From_double(static_cast< double >(result));
8533 return resultobj;
8534 fail:
8535 return NULL;
8536 }
8537
8538
8539 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8540 PyObject *resultobj = 0;
8541 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8542 double arg2 ;
8543 void *argp1 = 0 ;
8544 int res1 = 0 ;
8545 double val2 ;
8546 int ecode2 = 0 ;
8547 PyObject * obj0 = 0 ;
8548 PyObject * obj1 = 0 ;
8549 char * kwnames[] = {
8550 (char *) "self",(char *) "length", NULL
8551 };
8552
8553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8555 if (!SWIG_IsOK(res1)) {
8556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8557 }
8558 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8559 ecode2 = SWIG_AsVal_double(obj1, &val2);
8560 if (!SWIG_IsOK(ecode2)) {
8561 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8562 }
8563 arg2 = static_cast< double >(val2);
8564 {
8565 (arg1)->SetVectorLength(arg2);
8566 if (PyErr_Occurred()) SWIG_fail;
8567 }
8568 resultobj = SWIG_Py_Void();
8569 return resultobj;
8570 fail:
8571 return NULL;
8572 }
8573
8574
8575 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8576 PyObject *resultobj = 0;
8577 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8578 double arg2 ;
8579 void *argp1 = 0 ;
8580 int res1 = 0 ;
8581 double val2 ;
8582 int ecode2 = 0 ;
8583 PyObject * obj0 = 0 ;
8584 PyObject * obj1 = 0 ;
8585 char * kwnames[] = {
8586 (char *) "self",(char *) "degrees", NULL
8587 };
8588
8589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8591 if (!SWIG_IsOK(res1)) {
8592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8593 }
8594 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8595 ecode2 = SWIG_AsVal_double(obj1, &val2);
8596 if (!SWIG_IsOK(ecode2)) {
8597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8598 }
8599 arg2 = static_cast< double >(val2);
8600 {
8601 (arg1)->SetVectorAngle(arg2);
8602 if (PyErr_Occurred()) SWIG_fail;
8603 }
8604 resultobj = SWIG_Py_Void();
8605 return resultobj;
8606 fail:
8607 return NULL;
8608 }
8609
8610
8611 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8612 PyObject *resultobj = 0;
8613 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8614 wxPoint2D *arg2 = 0 ;
8615 double result;
8616 void *argp1 = 0 ;
8617 int res1 = 0 ;
8618 wxPoint2D temp2 ;
8619 PyObject * obj0 = 0 ;
8620 PyObject * obj1 = 0 ;
8621 char * kwnames[] = {
8622 (char *) "self",(char *) "pt", NULL
8623 };
8624
8625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8627 if (!SWIG_IsOK(res1)) {
8628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8629 }
8630 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8631 {
8632 arg2 = &temp2;
8633 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8634 }
8635 {
8636 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8637 if (PyErr_Occurred()) SWIG_fail;
8638 }
8639 resultobj = SWIG_From_double(static_cast< double >(result));
8640 return resultobj;
8641 fail:
8642 return NULL;
8643 }
8644
8645
8646 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8647 PyObject *resultobj = 0;
8648 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8649 wxPoint2D *arg2 = 0 ;
8650 double result;
8651 void *argp1 = 0 ;
8652 int res1 = 0 ;
8653 wxPoint2D temp2 ;
8654 PyObject * obj0 = 0 ;
8655 PyObject * obj1 = 0 ;
8656 char * kwnames[] = {
8657 (char *) "self",(char *) "pt", NULL
8658 };
8659
8660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8662 if (!SWIG_IsOK(res1)) {
8663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8664 }
8665 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8666 {
8667 arg2 = &temp2;
8668 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8669 }
8670 {
8671 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8672 if (PyErr_Occurred()) SWIG_fail;
8673 }
8674 resultobj = SWIG_From_double(static_cast< double >(result));
8675 return resultobj;
8676 fail:
8677 return NULL;
8678 }
8679
8680
8681 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8682 PyObject *resultobj = 0;
8683 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8684 wxPoint2D *arg2 = 0 ;
8685 double result;
8686 void *argp1 = 0 ;
8687 int res1 = 0 ;
8688 wxPoint2D temp2 ;
8689 PyObject * obj0 = 0 ;
8690 PyObject * obj1 = 0 ;
8691 char * kwnames[] = {
8692 (char *) "self",(char *) "vec", NULL
8693 };
8694
8695 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8696 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8697 if (!SWIG_IsOK(res1)) {
8698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8699 }
8700 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8701 {
8702 arg2 = &temp2;
8703 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8704 }
8705 {
8706 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8707 if (PyErr_Occurred()) SWIG_fail;
8708 }
8709 resultobj = SWIG_From_double(static_cast< double >(result));
8710 return resultobj;
8711 fail:
8712 return NULL;
8713 }
8714
8715
8716 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8717 PyObject *resultobj = 0;
8718 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8719 wxPoint2D *arg2 = 0 ;
8720 double result;
8721 void *argp1 = 0 ;
8722 int res1 = 0 ;
8723 wxPoint2D temp2 ;
8724 PyObject * obj0 = 0 ;
8725 PyObject * obj1 = 0 ;
8726 char * kwnames[] = {
8727 (char *) "self",(char *) "vec", NULL
8728 };
8729
8730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8732 if (!SWIG_IsOK(res1)) {
8733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8734 }
8735 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8736 {
8737 arg2 = &temp2;
8738 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8739 }
8740 {
8741 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8742 if (PyErr_Occurred()) SWIG_fail;
8743 }
8744 resultobj = SWIG_From_double(static_cast< double >(result));
8745 return resultobj;
8746 fail:
8747 return NULL;
8748 }
8749
8750
8751 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8752 PyObject *resultobj = 0;
8753 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8754 wxPoint2D result;
8755 void *argp1 = 0 ;
8756 int res1 = 0 ;
8757 PyObject *swig_obj[1] ;
8758
8759 if (!args) SWIG_fail;
8760 swig_obj[0] = args;
8761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8762 if (!SWIG_IsOK(res1)) {
8763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8764 }
8765 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8766 {
8767 result = (arg1)->operator -();
8768 if (PyErr_Occurred()) SWIG_fail;
8769 }
8770 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8771 return resultobj;
8772 fail:
8773 return NULL;
8774 }
8775
8776
8777 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8778 PyObject *resultobj = 0;
8779 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8780 wxPoint2D *arg2 = 0 ;
8781 wxPoint2D *result = 0 ;
8782 void *argp1 = 0 ;
8783 int res1 = 0 ;
8784 wxPoint2D temp2 ;
8785 PyObject * obj0 = 0 ;
8786 PyObject * obj1 = 0 ;
8787 char * kwnames[] = {
8788 (char *) "self",(char *) "pt", NULL
8789 };
8790
8791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8793 if (!SWIG_IsOK(res1)) {
8794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8795 }
8796 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8797 {
8798 arg2 = &temp2;
8799 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8800 }
8801 {
8802 {
8803 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8804 result = (wxPoint2D *) &_result_ref;
8805 }
8806 if (PyErr_Occurred()) SWIG_fail;
8807 }
8808 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8809 return resultobj;
8810 fail:
8811 return NULL;
8812 }
8813
8814
8815 SWIGINTERN PyObject *_wrap_Point2D___isub__(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___isub__",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___isub__" "', 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___imul__(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___imul__",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___imul__" "', 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___idiv__(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___idiv__",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___idiv__" "', 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___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8930 PyObject *resultobj = 0;
8931 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8932 PyObject *arg2 = (PyObject *) 0 ;
8933 bool result;
8934 void *argp1 = 0 ;
8935 int res1 = 0 ;
8936 PyObject * obj0 = 0 ;
8937 PyObject * obj1 = 0 ;
8938 char * kwnames[] = {
8939 (char *) "self",(char *) "other", NULL
8940 };
8941
8942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8944 if (!SWIG_IsOK(res1)) {
8945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8946 }
8947 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8948 arg2 = obj1;
8949 {
8950 result = (bool)wxPoint2D___eq__(arg1,arg2);
8951 if (PyErr_Occurred()) SWIG_fail;
8952 }
8953 {
8954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8955 }
8956 return resultobj;
8957 fail:
8958 return NULL;
8959 }
8960
8961
8962 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8963 PyObject *resultobj = 0;
8964 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8965 PyObject *arg2 = (PyObject *) 0 ;
8966 bool result;
8967 void *argp1 = 0 ;
8968 int res1 = 0 ;
8969 PyObject * obj0 = 0 ;
8970 PyObject * obj1 = 0 ;
8971 char * kwnames[] = {
8972 (char *) "self",(char *) "other", NULL
8973 };
8974
8975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8977 if (!SWIG_IsOK(res1)) {
8978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8979 }
8980 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8981 arg2 = obj1;
8982 {
8983 result = (bool)wxPoint2D___ne__(arg1,arg2);
8984 if (PyErr_Occurred()) SWIG_fail;
8985 }
8986 {
8987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8988 }
8989 return resultobj;
8990 fail:
8991 return NULL;
8992 }
8993
8994
8995 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8996 PyObject *resultobj = 0;
8997 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8998 double arg2 ;
8999 void *argp1 = 0 ;
9000 int res1 = 0 ;
9001 double val2 ;
9002 int ecode2 = 0 ;
9003 PyObject *swig_obj[2] ;
9004
9005 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
9006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9007 if (!SWIG_IsOK(res1)) {
9008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9009 }
9010 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9011 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9012 if (!SWIG_IsOK(ecode2)) {
9013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
9014 }
9015 arg2 = static_cast< double >(val2);
9016 if (arg1) (arg1)->m_x = arg2;
9017
9018 resultobj = SWIG_Py_Void();
9019 return resultobj;
9020 fail:
9021 return NULL;
9022 }
9023
9024
9025 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9026 PyObject *resultobj = 0;
9027 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9028 double result;
9029 void *argp1 = 0 ;
9030 int res1 = 0 ;
9031 PyObject *swig_obj[1] ;
9032
9033 if (!args) SWIG_fail;
9034 swig_obj[0] = args;
9035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9036 if (!SWIG_IsOK(res1)) {
9037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9038 }
9039 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9040 result = (double) ((arg1)->m_x);
9041 resultobj = SWIG_From_double(static_cast< double >(result));
9042 return resultobj;
9043 fail:
9044 return NULL;
9045 }
9046
9047
9048 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9049 PyObject *resultobj = 0;
9050 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9051 double arg2 ;
9052 void *argp1 = 0 ;
9053 int res1 = 0 ;
9054 double val2 ;
9055 int ecode2 = 0 ;
9056 PyObject *swig_obj[2] ;
9057
9058 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
9059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9060 if (!SWIG_IsOK(res1)) {
9061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9062 }
9063 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9064 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9065 if (!SWIG_IsOK(ecode2)) {
9066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
9067 }
9068 arg2 = static_cast< double >(val2);
9069 if (arg1) (arg1)->m_y = arg2;
9070
9071 resultobj = SWIG_Py_Void();
9072 return resultobj;
9073 fail:
9074 return NULL;
9075 }
9076
9077
9078 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9079 PyObject *resultobj = 0;
9080 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9081 double result;
9082 void *argp1 = 0 ;
9083 int res1 = 0 ;
9084 PyObject *swig_obj[1] ;
9085
9086 if (!args) SWIG_fail;
9087 swig_obj[0] = args;
9088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9089 if (!SWIG_IsOK(res1)) {
9090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9091 }
9092 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9093 result = (double) ((arg1)->m_y);
9094 resultobj = SWIG_From_double(static_cast< double >(result));
9095 return resultobj;
9096 fail:
9097 return NULL;
9098 }
9099
9100
9101 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9102 PyObject *resultobj = 0;
9103 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9104 double arg2 = (double) 0 ;
9105 double arg3 = (double) 0 ;
9106 void *argp1 = 0 ;
9107 int res1 = 0 ;
9108 double val2 ;
9109 int ecode2 = 0 ;
9110 double val3 ;
9111 int ecode3 = 0 ;
9112 PyObject * obj0 = 0 ;
9113 PyObject * obj1 = 0 ;
9114 PyObject * obj2 = 0 ;
9115 char * kwnames[] = {
9116 (char *) "self",(char *) "x",(char *) "y", NULL
9117 };
9118
9119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9121 if (!SWIG_IsOK(res1)) {
9122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9123 }
9124 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9125 if (obj1) {
9126 ecode2 = SWIG_AsVal_double(obj1, &val2);
9127 if (!SWIG_IsOK(ecode2)) {
9128 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
9129 }
9130 arg2 = static_cast< double >(val2);
9131 }
9132 if (obj2) {
9133 ecode3 = SWIG_AsVal_double(obj2, &val3);
9134 if (!SWIG_IsOK(ecode3)) {
9135 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
9136 }
9137 arg3 = static_cast< double >(val3);
9138 }
9139 {
9140 wxPoint2D_Set(arg1,arg2,arg3);
9141 if (PyErr_Occurred()) SWIG_fail;
9142 }
9143 resultobj = SWIG_Py_Void();
9144 return resultobj;
9145 fail:
9146 return NULL;
9147 }
9148
9149
9150 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9151 PyObject *resultobj = 0;
9152 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9153 PyObject *result = 0 ;
9154 void *argp1 = 0 ;
9155 int res1 = 0 ;
9156 PyObject *swig_obj[1] ;
9157
9158 if (!args) SWIG_fail;
9159 swig_obj[0] = args;
9160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9161 if (!SWIG_IsOK(res1)) {
9162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9163 }
9164 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9165 {
9166 result = (PyObject *)wxPoint2D_Get(arg1);
9167 if (PyErr_Occurred()) SWIG_fail;
9168 }
9169 resultobj = result;
9170 return resultobj;
9171 fail:
9172 return NULL;
9173 }
9174
9175
9176 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9177 PyObject *obj;
9178 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9179 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
9180 return SWIG_Py_Void();
9181 }
9182
9183 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9184 return SWIG_Python_InitShadowInstance(args);
9185 }
9186
9187 SWIGINTERN PyObject *_wrap_new_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9188 PyObject *resultobj = 0;
9189 wxDouble arg1 = (wxDouble) 0.0 ;
9190 wxDouble arg2 = (wxDouble) 0.0 ;
9191 wxDouble arg3 = (wxDouble) 0.0 ;
9192 wxDouble arg4 = (wxDouble) 0.0 ;
9193 wxRect2D *result = 0 ;
9194 void *argp1 ;
9195 int res1 = 0 ;
9196 void *argp2 ;
9197 int res2 = 0 ;
9198 void *argp3 ;
9199 int res3 = 0 ;
9200 void *argp4 ;
9201 int res4 = 0 ;
9202 PyObject * obj0 = 0 ;
9203 PyObject * obj1 = 0 ;
9204 PyObject * obj2 = 0 ;
9205 PyObject * obj3 = 0 ;
9206 char * kwnames[] = {
9207 (char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
9208 };
9209
9210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect2D",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9211 if (obj0) {
9212 {
9213 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDouble, 0 | 0);
9214 if (!SWIG_IsOK(res1)) {
9215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9216 }
9217 if (!argp1) {
9218 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9219 } else {
9220 wxDouble * temp = reinterpret_cast< wxDouble * >(argp1);
9221 arg1 = *temp;
9222 if (SWIG_IsNewObj(res1)) delete temp;
9223 }
9224 }
9225 }
9226 if (obj1) {
9227 {
9228 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9229 if (!SWIG_IsOK(res2)) {
9230 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9231 }
9232 if (!argp2) {
9233 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9234 } else {
9235 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9236 arg2 = *temp;
9237 if (SWIG_IsNewObj(res2)) delete temp;
9238 }
9239 }
9240 }
9241 if (obj2) {
9242 {
9243 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
9244 if (!SWIG_IsOK(res3)) {
9245 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9246 }
9247 if (!argp3) {
9248 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9249 } else {
9250 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
9251 arg3 = *temp;
9252 if (SWIG_IsNewObj(res3)) delete temp;
9253 }
9254 }
9255 }
9256 if (obj3) {
9257 {
9258 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
9259 if (!SWIG_IsOK(res4)) {
9260 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9261 }
9262 if (!argp4) {
9263 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9264 } else {
9265 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
9266 arg4 = *temp;
9267 if (SWIG_IsNewObj(res4)) delete temp;
9268 }
9269 }
9270 }
9271 {
9272 result = (wxRect2D *)new wxRect2D(arg1,arg2,arg3,arg4);
9273 if (PyErr_Occurred()) SWIG_fail;
9274 }
9275 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect2D, SWIG_POINTER_NEW | 0 );
9276 return resultobj;
9277 fail:
9278 return NULL;
9279 }
9280
9281
9282 SWIGINTERN PyObject *_wrap_delete_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9283 PyObject *resultobj = 0;
9284 wxRect2D *arg1 = (wxRect2D *) 0 ;
9285 void *argp1 = 0 ;
9286 int res1 = 0 ;
9287 PyObject *swig_obj[1] ;
9288
9289 if (!args) SWIG_fail;
9290 swig_obj[0] = args;
9291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, SWIG_POINTER_DISOWN | 0 );
9292 if (!SWIG_IsOK(res1)) {
9293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect2D" "', expected argument " "1"" of type '" "wxRect2D *""'");
9294 }
9295 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9296 {
9297 delete arg1;
9298
9299 if (PyErr_Occurred()) SWIG_fail;
9300 }
9301 resultobj = SWIG_Py_Void();
9302 return resultobj;
9303 fail:
9304 return NULL;
9305 }
9306
9307
9308 SWIGINTERN PyObject *_wrap_Rect2D_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9309 PyObject *resultobj = 0;
9310 wxRect2D *arg1 = (wxRect2D *) 0 ;
9311 wxPoint2D result;
9312 void *argp1 = 0 ;
9313 int res1 = 0 ;
9314 PyObject *swig_obj[1] ;
9315
9316 if (!args) SWIG_fail;
9317 swig_obj[0] = args;
9318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9319 if (!SWIG_IsOK(res1)) {
9320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetPosition" "', expected argument " "1"" of type '" "wxRect2D *""'");
9321 }
9322 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9323 {
9324 result = (arg1)->GetPosition();
9325 if (PyErr_Occurred()) SWIG_fail;
9326 }
9327 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9328 return resultobj;
9329 fail:
9330 return NULL;
9331 }
9332
9333
9334 SWIGINTERN PyObject *_wrap_Rect2D_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9335 PyObject *resultobj = 0;
9336 wxRect2D *arg1 = (wxRect2D *) 0 ;
9337 wxSize result;
9338 void *argp1 = 0 ;
9339 int res1 = 0 ;
9340 PyObject *swig_obj[1] ;
9341
9342 if (!args) SWIG_fail;
9343 swig_obj[0] = args;
9344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9345 if (!SWIG_IsOK(res1)) {
9346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetSize" "', expected argument " "1"" of type '" "wxRect2D *""'");
9347 }
9348 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9349 {
9350 result = (arg1)->GetSize();
9351 if (PyErr_Occurred()) SWIG_fail;
9352 }
9353 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
9354 return resultobj;
9355 fail:
9356 return NULL;
9357 }
9358
9359
9360 SWIGINTERN PyObject *_wrap_Rect2D_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9361 PyObject *resultobj = 0;
9362 wxRect2D *arg1 = (wxRect2D *) 0 ;
9363 wxDouble result;
9364 void *argp1 = 0 ;
9365 int res1 = 0 ;
9366 PyObject *swig_obj[1] ;
9367
9368 if (!args) SWIG_fail;
9369 swig_obj[0] = args;
9370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9371 if (!SWIG_IsOK(res1)) {
9372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeft" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9373 }
9374 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9375 {
9376 result = ((wxRect2D const *)arg1)->GetLeft();
9377 if (PyErr_Occurred()) SWIG_fail;
9378 }
9379 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9380 return resultobj;
9381 fail:
9382 return NULL;
9383 }
9384
9385
9386 SWIGINTERN PyObject *_wrap_Rect2D_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9387 PyObject *resultobj = 0;
9388 wxRect2D *arg1 = (wxRect2D *) 0 ;
9389 wxDouble arg2 ;
9390 void *argp1 = 0 ;
9391 int res1 = 0 ;
9392 void *argp2 ;
9393 int res2 = 0 ;
9394 PyObject * obj0 = 0 ;
9395 PyObject * obj1 = 0 ;
9396 char * kwnames[] = {
9397 (char *) "self",(char *) "n", NULL
9398 };
9399
9400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
9401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9402 if (!SWIG_IsOK(res1)) {
9403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeft" "', expected argument " "1"" of type '" "wxRect2D *""'");
9404 }
9405 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9406 {
9407 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9408 if (!SWIG_IsOK(res2)) {
9409 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9410 }
9411 if (!argp2) {
9412 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9413 } else {
9414 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9415 arg2 = *temp;
9416 if (SWIG_IsNewObj(res2)) delete temp;
9417 }
9418 }
9419 {
9420 (arg1)->SetLeft(arg2);
9421 if (PyErr_Occurred()) SWIG_fail;
9422 }
9423 resultobj = SWIG_Py_Void();
9424 return resultobj;
9425 fail:
9426 return NULL;
9427 }
9428
9429
9430 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9431 PyObject *resultobj = 0;
9432 wxRect2D *arg1 = (wxRect2D *) 0 ;
9433 wxDouble arg2 ;
9434 void *argp1 = 0 ;
9435 int res1 = 0 ;
9436 void *argp2 ;
9437 int res2 = 0 ;
9438 PyObject * obj0 = 0 ;
9439 PyObject * obj1 = 0 ;
9440 char * kwnames[] = {
9441 (char *) "self",(char *) "n", NULL
9442 };
9443
9444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTo",kwnames,&obj0,&obj1)) SWIG_fail;
9445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9446 if (!SWIG_IsOK(res1)) {
9447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9448 }
9449 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9450 {
9451 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9452 if (!SWIG_IsOK(res2)) {
9453 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9454 }
9455 if (!argp2) {
9456 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9457 } else {
9458 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9459 arg2 = *temp;
9460 if (SWIG_IsNewObj(res2)) delete temp;
9461 }
9462 }
9463 {
9464 (arg1)->MoveLeftTo(arg2);
9465 if (PyErr_Occurred()) SWIG_fail;
9466 }
9467 resultobj = SWIG_Py_Void();
9468 return resultobj;
9469 fail:
9470 return NULL;
9471 }
9472
9473
9474 SWIGINTERN PyObject *_wrap_Rect2D_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9475 PyObject *resultobj = 0;
9476 wxRect2D *arg1 = (wxRect2D *) 0 ;
9477 wxDouble result;
9478 void *argp1 = 0 ;
9479 int res1 = 0 ;
9480 PyObject *swig_obj[1] ;
9481
9482 if (!args) SWIG_fail;
9483 swig_obj[0] = args;
9484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9485 if (!SWIG_IsOK(res1)) {
9486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9487 }
9488 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9489 {
9490 result = ((wxRect2D const *)arg1)->GetTop();
9491 if (PyErr_Occurred()) SWIG_fail;
9492 }
9493 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9494 return resultobj;
9495 fail:
9496 return NULL;
9497 }
9498
9499
9500 SWIGINTERN PyObject *_wrap_Rect2D_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9501 PyObject *resultobj = 0;
9502 wxRect2D *arg1 = (wxRect2D *) 0 ;
9503 wxDouble arg2 ;
9504 void *argp1 = 0 ;
9505 int res1 = 0 ;
9506 void *argp2 ;
9507 int res2 = 0 ;
9508 PyObject * obj0 = 0 ;
9509 PyObject * obj1 = 0 ;
9510 char * kwnames[] = {
9511 (char *) "self",(char *) "n", NULL
9512 };
9513
9514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
9515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9516 if (!SWIG_IsOK(res1)) {
9517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9518 }
9519 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9520 {
9521 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9522 if (!SWIG_IsOK(res2)) {
9523 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9524 }
9525 if (!argp2) {
9526 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9527 } else {
9528 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9529 arg2 = *temp;
9530 if (SWIG_IsNewObj(res2)) delete temp;
9531 }
9532 }
9533 {
9534 (arg1)->SetTop(arg2);
9535 if (PyErr_Occurred()) SWIG_fail;
9536 }
9537 resultobj = SWIG_Py_Void();
9538 return resultobj;
9539 fail:
9540 return NULL;
9541 }
9542
9543
9544 SWIGINTERN PyObject *_wrap_Rect2D_MoveTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9545 PyObject *resultobj = 0;
9546 wxRect2D *arg1 = (wxRect2D *) 0 ;
9547 wxDouble arg2 ;
9548 void *argp1 = 0 ;
9549 int res1 = 0 ;
9550 void *argp2 ;
9551 int res2 = 0 ;
9552 PyObject * obj0 = 0 ;
9553 PyObject * obj1 = 0 ;
9554 char * kwnames[] = {
9555 (char *) "self",(char *) "n", NULL
9556 };
9557
9558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9560 if (!SWIG_IsOK(res1)) {
9561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9562 }
9563 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9564 {
9565 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9566 if (!SWIG_IsOK(res2)) {
9567 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9568 }
9569 if (!argp2) {
9570 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9571 } else {
9572 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9573 arg2 = *temp;
9574 if (SWIG_IsNewObj(res2)) delete temp;
9575 }
9576 }
9577 {
9578 (arg1)->MoveTopTo(arg2);
9579 if (PyErr_Occurred()) SWIG_fail;
9580 }
9581 resultobj = SWIG_Py_Void();
9582 return resultobj;
9583 fail:
9584 return NULL;
9585 }
9586
9587
9588 SWIGINTERN PyObject *_wrap_Rect2D_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9589 PyObject *resultobj = 0;
9590 wxRect2D *arg1 = (wxRect2D *) 0 ;
9591 wxDouble result;
9592 void *argp1 = 0 ;
9593 int res1 = 0 ;
9594 PyObject *swig_obj[1] ;
9595
9596 if (!args) SWIG_fail;
9597 swig_obj[0] = args;
9598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9599 if (!SWIG_IsOK(res1)) {
9600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9601 }
9602 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9603 {
9604 result = ((wxRect2D const *)arg1)->GetBottom();
9605 if (PyErr_Occurred()) SWIG_fail;
9606 }
9607 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9608 return resultobj;
9609 fail:
9610 return NULL;
9611 }
9612
9613
9614 SWIGINTERN PyObject *_wrap_Rect2D_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9615 PyObject *resultobj = 0;
9616 wxRect2D *arg1 = (wxRect2D *) 0 ;
9617 wxDouble arg2 ;
9618 void *argp1 = 0 ;
9619 int res1 = 0 ;
9620 void *argp2 ;
9621 int res2 = 0 ;
9622 PyObject * obj0 = 0 ;
9623 PyObject * obj1 = 0 ;
9624 char * kwnames[] = {
9625 (char *) "self",(char *) "n", NULL
9626 };
9627
9628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9630 if (!SWIG_IsOK(res1)) {
9631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9632 }
9633 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9634 {
9635 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9636 if (!SWIG_IsOK(res2)) {
9637 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9638 }
9639 if (!argp2) {
9640 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9641 } else {
9642 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9643 arg2 = *temp;
9644 if (SWIG_IsNewObj(res2)) delete temp;
9645 }
9646 }
9647 {
9648 (arg1)->SetBottom(arg2);
9649 if (PyErr_Occurred()) SWIG_fail;
9650 }
9651 resultobj = SWIG_Py_Void();
9652 return resultobj;
9653 fail:
9654 return NULL;
9655 }
9656
9657
9658 SWIGINTERN PyObject *_wrap_Rect2D_MoveBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9659 PyObject *resultobj = 0;
9660 wxRect2D *arg1 = (wxRect2D *) 0 ;
9661 wxDouble arg2 ;
9662 void *argp1 = 0 ;
9663 int res1 = 0 ;
9664 void *argp2 ;
9665 int res2 = 0 ;
9666 PyObject * obj0 = 0 ;
9667 PyObject * obj1 = 0 ;
9668 char * kwnames[] = {
9669 (char *) "self",(char *) "n", NULL
9670 };
9671
9672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9674 if (!SWIG_IsOK(res1)) {
9675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9676 }
9677 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9678 {
9679 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9680 if (!SWIG_IsOK(res2)) {
9681 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9682 }
9683 if (!argp2) {
9684 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9685 } else {
9686 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9687 arg2 = *temp;
9688 if (SWIG_IsNewObj(res2)) delete temp;
9689 }
9690 }
9691 {
9692 (arg1)->MoveBottomTo(arg2);
9693 if (PyErr_Occurred()) SWIG_fail;
9694 }
9695 resultobj = SWIG_Py_Void();
9696 return resultobj;
9697 fail:
9698 return NULL;
9699 }
9700
9701
9702 SWIGINTERN PyObject *_wrap_Rect2D_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9703 PyObject *resultobj = 0;
9704 wxRect2D *arg1 = (wxRect2D *) 0 ;
9705 wxDouble result;
9706 void *argp1 = 0 ;
9707 int res1 = 0 ;
9708 PyObject *swig_obj[1] ;
9709
9710 if (!args) SWIG_fail;
9711 swig_obj[0] = args;
9712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9713 if (!SWIG_IsOK(res1)) {
9714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRight" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9715 }
9716 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9717 {
9718 result = ((wxRect2D const *)arg1)->GetRight();
9719 if (PyErr_Occurred()) SWIG_fail;
9720 }
9721 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9722 return resultobj;
9723 fail:
9724 return NULL;
9725 }
9726
9727
9728 SWIGINTERN PyObject *_wrap_Rect2D_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9729 PyObject *resultobj = 0;
9730 wxRect2D *arg1 = (wxRect2D *) 0 ;
9731 wxDouble arg2 ;
9732 void *argp1 = 0 ;
9733 int res1 = 0 ;
9734 void *argp2 ;
9735 int res2 = 0 ;
9736 PyObject * obj0 = 0 ;
9737 PyObject * obj1 = 0 ;
9738 char * kwnames[] = {
9739 (char *) "self",(char *) "n", NULL
9740 };
9741
9742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
9743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9744 if (!SWIG_IsOK(res1)) {
9745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRight" "', expected argument " "1"" of type '" "wxRect2D *""'");
9746 }
9747 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9748 {
9749 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9750 if (!SWIG_IsOK(res2)) {
9751 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9752 }
9753 if (!argp2) {
9754 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9755 } else {
9756 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9757 arg2 = *temp;
9758 if (SWIG_IsNewObj(res2)) delete temp;
9759 }
9760 }
9761 {
9762 (arg1)->SetRight(arg2);
9763 if (PyErr_Occurred()) SWIG_fail;
9764 }
9765 resultobj = SWIG_Py_Void();
9766 return resultobj;
9767 fail:
9768 return NULL;
9769 }
9770
9771
9772 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9773 PyObject *resultobj = 0;
9774 wxRect2D *arg1 = (wxRect2D *) 0 ;
9775 wxDouble arg2 ;
9776 void *argp1 = 0 ;
9777 int res1 = 0 ;
9778 void *argp2 ;
9779 int res2 = 0 ;
9780 PyObject * obj0 = 0 ;
9781 PyObject * obj1 = 0 ;
9782 char * kwnames[] = {
9783 (char *) "self",(char *) "n", NULL
9784 };
9785
9786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTo",kwnames,&obj0,&obj1)) SWIG_fail;
9787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9788 if (!SWIG_IsOK(res1)) {
9789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9790 }
9791 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9792 {
9793 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9794 if (!SWIG_IsOK(res2)) {
9795 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9796 }
9797 if (!argp2) {
9798 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9799 } else {
9800 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9801 arg2 = *temp;
9802 if (SWIG_IsNewObj(res2)) delete temp;
9803 }
9804 }
9805 {
9806 (arg1)->MoveRightTo(arg2);
9807 if (PyErr_Occurred()) SWIG_fail;
9808 }
9809 resultobj = SWIG_Py_Void();
9810 return resultobj;
9811 fail:
9812 return NULL;
9813 }
9814
9815
9816 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9817 PyObject *resultobj = 0;
9818 wxRect2D *arg1 = (wxRect2D *) 0 ;
9819 wxPoint2D result;
9820 void *argp1 = 0 ;
9821 int res1 = 0 ;
9822 PyObject *swig_obj[1] ;
9823
9824 if (!args) SWIG_fail;
9825 swig_obj[0] = args;
9826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9827 if (!SWIG_IsOK(res1)) {
9828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9829 }
9830 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9831 {
9832 result = ((wxRect2D const *)arg1)->GetLeftTop();
9833 if (PyErr_Occurred()) SWIG_fail;
9834 }
9835 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9836 return resultobj;
9837 fail:
9838 return NULL;
9839 }
9840
9841
9842 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9843 PyObject *resultobj = 0;
9844 wxRect2D *arg1 = (wxRect2D *) 0 ;
9845 wxPoint2D *arg2 = 0 ;
9846 void *argp1 = 0 ;
9847 int res1 = 0 ;
9848 wxPoint2D temp2 ;
9849 PyObject * obj0 = 0 ;
9850 PyObject * obj1 = 0 ;
9851 char * kwnames[] = {
9852 (char *) "self",(char *) "pt", NULL
9853 };
9854
9855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftTop",kwnames,&obj0,&obj1)) SWIG_fail;
9856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9857 if (!SWIG_IsOK(res1)) {
9858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9859 }
9860 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9861 {
9862 arg2 = &temp2;
9863 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9864 }
9865 {
9866 (arg1)->SetLeftTop((wxPoint2D const &)*arg2);
9867 if (PyErr_Occurred()) SWIG_fail;
9868 }
9869 resultobj = SWIG_Py_Void();
9870 return resultobj;
9871 fail:
9872 return NULL;
9873 }
9874
9875
9876 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9877 PyObject *resultobj = 0;
9878 wxRect2D *arg1 = (wxRect2D *) 0 ;
9879 wxPoint2D *arg2 = 0 ;
9880 void *argp1 = 0 ;
9881 int res1 = 0 ;
9882 wxPoint2D temp2 ;
9883 PyObject * obj0 = 0 ;
9884 PyObject * obj1 = 0 ;
9885 char * kwnames[] = {
9886 (char *) "self",(char *) "pt", NULL
9887 };
9888
9889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9891 if (!SWIG_IsOK(res1)) {
9892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9893 }
9894 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9895 {
9896 arg2 = &temp2;
9897 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9898 }
9899 {
9900 (arg1)->MoveLeftTopTo((wxPoint2D const &)*arg2);
9901 if (PyErr_Occurred()) SWIG_fail;
9902 }
9903 resultobj = SWIG_Py_Void();
9904 return resultobj;
9905 fail:
9906 return NULL;
9907 }
9908
9909
9910 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9911 PyObject *resultobj = 0;
9912 wxRect2D *arg1 = (wxRect2D *) 0 ;
9913 wxPoint2D result;
9914 void *argp1 = 0 ;
9915 int res1 = 0 ;
9916 PyObject *swig_obj[1] ;
9917
9918 if (!args) SWIG_fail;
9919 swig_obj[0] = args;
9920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9921 if (!SWIG_IsOK(res1)) {
9922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9923 }
9924 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9925 {
9926 result = ((wxRect2D const *)arg1)->GetLeftBottom();
9927 if (PyErr_Occurred()) SWIG_fail;
9928 }
9929 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9930 return resultobj;
9931 fail:
9932 return NULL;
9933 }
9934
9935
9936 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9937 PyObject *resultobj = 0;
9938 wxRect2D *arg1 = (wxRect2D *) 0 ;
9939 wxPoint2D *arg2 = 0 ;
9940 void *argp1 = 0 ;
9941 int res1 = 0 ;
9942 wxPoint2D temp2 ;
9943 PyObject * obj0 = 0 ;
9944 PyObject * obj1 = 0 ;
9945 char * kwnames[] = {
9946 (char *) "self",(char *) "pt", NULL
9947 };
9948
9949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9951 if (!SWIG_IsOK(res1)) {
9952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9953 }
9954 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9955 {
9956 arg2 = &temp2;
9957 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9958 }
9959 {
9960 (arg1)->SetLeftBottom((wxPoint2D const &)*arg2);
9961 if (PyErr_Occurred()) SWIG_fail;
9962 }
9963 resultobj = SWIG_Py_Void();
9964 return resultobj;
9965 fail:
9966 return NULL;
9967 }
9968
9969
9970 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9971 PyObject *resultobj = 0;
9972 wxRect2D *arg1 = (wxRect2D *) 0 ;
9973 wxPoint2D *arg2 = 0 ;
9974 void *argp1 = 0 ;
9975 int res1 = 0 ;
9976 wxPoint2D temp2 ;
9977 PyObject * obj0 = 0 ;
9978 PyObject * obj1 = 0 ;
9979 char * kwnames[] = {
9980 (char *) "self",(char *) "pt", NULL
9981 };
9982
9983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9985 if (!SWIG_IsOK(res1)) {
9986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9987 }
9988 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9989 {
9990 arg2 = &temp2;
9991 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9992 }
9993 {
9994 (arg1)->MoveLeftBottomTo((wxPoint2D const &)*arg2);
9995 if (PyErr_Occurred()) SWIG_fail;
9996 }
9997 resultobj = SWIG_Py_Void();
9998 return resultobj;
9999 fail:
10000 return NULL;
10001 }
10002
10003
10004 SWIGINTERN PyObject *_wrap_Rect2D_GetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10005 PyObject *resultobj = 0;
10006 wxRect2D *arg1 = (wxRect2D *) 0 ;
10007 wxPoint2D result;
10008 void *argp1 = 0 ;
10009 int res1 = 0 ;
10010 PyObject *swig_obj[1] ;
10011
10012 if (!args) SWIG_fail;
10013 swig_obj[0] = args;
10014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10015 if (!SWIG_IsOK(res1)) {
10016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10017 }
10018 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10019 {
10020 result = ((wxRect2D const *)arg1)->GetRightTop();
10021 if (PyErr_Occurred()) SWIG_fail;
10022 }
10023 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10024 return resultobj;
10025 fail:
10026 return NULL;
10027 }
10028
10029
10030 SWIGINTERN PyObject *_wrap_Rect2D_SetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10031 PyObject *resultobj = 0;
10032 wxRect2D *arg1 = (wxRect2D *) 0 ;
10033 wxPoint2D *arg2 = 0 ;
10034 void *argp1 = 0 ;
10035 int res1 = 0 ;
10036 wxPoint2D temp2 ;
10037 PyObject * obj0 = 0 ;
10038 PyObject * obj1 = 0 ;
10039 char * kwnames[] = {
10040 (char *) "self",(char *) "pt", NULL
10041 };
10042
10043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightTop",kwnames,&obj0,&obj1)) SWIG_fail;
10044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10045 if (!SWIG_IsOK(res1)) {
10046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
10047 }
10048 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10049 {
10050 arg2 = &temp2;
10051 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10052 }
10053 {
10054 (arg1)->SetRightTop((wxPoint2D const &)*arg2);
10055 if (PyErr_Occurred()) SWIG_fail;
10056 }
10057 resultobj = SWIG_Py_Void();
10058 return resultobj;
10059 fail:
10060 return NULL;
10061 }
10062
10063
10064 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10065 PyObject *resultobj = 0;
10066 wxRect2D *arg1 = (wxRect2D *) 0 ;
10067 wxPoint2D *arg2 = 0 ;
10068 void *argp1 = 0 ;
10069 int res1 = 0 ;
10070 wxPoint2D temp2 ;
10071 PyObject * obj0 = 0 ;
10072 PyObject * obj1 = 0 ;
10073 char * kwnames[] = {
10074 (char *) "self",(char *) "pt", NULL
10075 };
10076
10077 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
10078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10079 if (!SWIG_IsOK(res1)) {
10080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10081 }
10082 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10083 {
10084 arg2 = &temp2;
10085 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10086 }
10087 {
10088 (arg1)->MoveRightTopTo((wxPoint2D const &)*arg2);
10089 if (PyErr_Occurred()) SWIG_fail;
10090 }
10091 resultobj = SWIG_Py_Void();
10092 return resultobj;
10093 fail:
10094 return NULL;
10095 }
10096
10097
10098 SWIGINTERN PyObject *_wrap_Rect2D_GetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10099 PyObject *resultobj = 0;
10100 wxRect2D *arg1 = (wxRect2D *) 0 ;
10101 wxPoint2D result;
10102 void *argp1 = 0 ;
10103 int res1 = 0 ;
10104 PyObject *swig_obj[1] ;
10105
10106 if (!args) SWIG_fail;
10107 swig_obj[0] = args;
10108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10109 if (!SWIG_IsOK(res1)) {
10110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10111 }
10112 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10113 {
10114 result = ((wxRect2D const *)arg1)->GetRightBottom();
10115 if (PyErr_Occurred()) SWIG_fail;
10116 }
10117 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10118 return resultobj;
10119 fail:
10120 return NULL;
10121 }
10122
10123
10124 SWIGINTERN PyObject *_wrap_Rect2D_SetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10125 PyObject *resultobj = 0;
10126 wxRect2D *arg1 = (wxRect2D *) 0 ;
10127 wxPoint2D *arg2 = 0 ;
10128 void *argp1 = 0 ;
10129 int res1 = 0 ;
10130 wxPoint2D temp2 ;
10131 PyObject * obj0 = 0 ;
10132 PyObject * obj1 = 0 ;
10133 char * kwnames[] = {
10134 (char *) "self",(char *) "pt", NULL
10135 };
10136
10137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightBottom",kwnames,&obj0,&obj1)) SWIG_fail;
10138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10139 if (!SWIG_IsOK(res1)) {
10140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
10141 }
10142 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10143 {
10144 arg2 = &temp2;
10145 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10146 }
10147 {
10148 (arg1)->SetRightBottom((wxPoint2D const &)*arg2);
10149 if (PyErr_Occurred()) SWIG_fail;
10150 }
10151 resultobj = SWIG_Py_Void();
10152 return resultobj;
10153 fail:
10154 return NULL;
10155 }
10156
10157
10158 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10159 PyObject *resultobj = 0;
10160 wxRect2D *arg1 = (wxRect2D *) 0 ;
10161 wxPoint2D *arg2 = 0 ;
10162 void *argp1 = 0 ;
10163 int res1 = 0 ;
10164 wxPoint2D temp2 ;
10165 PyObject * obj0 = 0 ;
10166 PyObject * obj1 = 0 ;
10167 char * kwnames[] = {
10168 (char *) "self",(char *) "pt", NULL
10169 };
10170
10171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
10172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10173 if (!SWIG_IsOK(res1)) {
10174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10175 }
10176 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10177 {
10178 arg2 = &temp2;
10179 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10180 }
10181 {
10182 (arg1)->MoveRightBottomTo((wxPoint2D const &)*arg2);
10183 if (PyErr_Occurred()) SWIG_fail;
10184 }
10185 resultobj = SWIG_Py_Void();
10186 return resultobj;
10187 fail:
10188 return NULL;
10189 }
10190
10191
10192 SWIGINTERN PyObject *_wrap_Rect2D_GetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10193 PyObject *resultobj = 0;
10194 wxRect2D *arg1 = (wxRect2D *) 0 ;
10195 wxPoint2D result;
10196 void *argp1 = 0 ;
10197 int res1 = 0 ;
10198 PyObject *swig_obj[1] ;
10199
10200 if (!args) SWIG_fail;
10201 swig_obj[0] = args;
10202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10203 if (!SWIG_IsOK(res1)) {
10204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetCentre" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10205 }
10206 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10207 {
10208 result = ((wxRect2D const *)arg1)->GetCentre();
10209 if (PyErr_Occurred()) SWIG_fail;
10210 }
10211 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10212 return resultobj;
10213 fail:
10214 return NULL;
10215 }
10216
10217
10218 SWIGINTERN PyObject *_wrap_Rect2D_SetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10219 PyObject *resultobj = 0;
10220 wxRect2D *arg1 = (wxRect2D *) 0 ;
10221 wxPoint2D *arg2 = 0 ;
10222 void *argp1 = 0 ;
10223 int res1 = 0 ;
10224 wxPoint2D temp2 ;
10225 PyObject * obj0 = 0 ;
10226 PyObject * obj1 = 0 ;
10227 char * kwnames[] = {
10228 (char *) "self",(char *) "pt", NULL
10229 };
10230
10231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetCentre",kwnames,&obj0,&obj1)) SWIG_fail;
10232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10233 if (!SWIG_IsOK(res1)) {
10234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetCentre" "', expected argument " "1"" of type '" "wxRect2D *""'");
10235 }
10236 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10237 {
10238 arg2 = &temp2;
10239 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10240 }
10241 {
10242 (arg1)->SetCentre((wxPoint2D const &)*arg2);
10243 if (PyErr_Occurred()) SWIG_fail;
10244 }
10245 resultobj = SWIG_Py_Void();
10246 return resultobj;
10247 fail:
10248 return NULL;
10249 }
10250
10251
10252 SWIGINTERN PyObject *_wrap_Rect2D_MoveCentreTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10253 PyObject *resultobj = 0;
10254 wxRect2D *arg1 = (wxRect2D *) 0 ;
10255 wxPoint2D *arg2 = 0 ;
10256 void *argp1 = 0 ;
10257 int res1 = 0 ;
10258 wxPoint2D temp2 ;
10259 PyObject * obj0 = 0 ;
10260 PyObject * obj1 = 0 ;
10261 char * kwnames[] = {
10262 (char *) "self",(char *) "pt", NULL
10263 };
10264
10265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveCentreTo",kwnames,&obj0,&obj1)) SWIG_fail;
10266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10267 if (!SWIG_IsOK(res1)) {
10268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveCentreTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10269 }
10270 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10271 {
10272 arg2 = &temp2;
10273 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10274 }
10275 {
10276 (arg1)->MoveCentreTo((wxPoint2D const &)*arg2);
10277 if (PyErr_Occurred()) SWIG_fail;
10278 }
10279 resultobj = SWIG_Py_Void();
10280 return resultobj;
10281 fail:
10282 return NULL;
10283 }
10284
10285
10286 SWIGINTERN PyObject *_wrap_Rect2D_GetOutcode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10287 PyObject *resultobj = 0;
10288 wxRect2D *arg1 = (wxRect2D *) 0 ;
10289 wxPoint2D *arg2 = 0 ;
10290 wxOutCode result;
10291 void *argp1 = 0 ;
10292 int res1 = 0 ;
10293 wxPoint2D temp2 ;
10294 PyObject * obj0 = 0 ;
10295 PyObject * obj1 = 0 ;
10296 char * kwnames[] = {
10297 (char *) "self",(char *) "pt", NULL
10298 };
10299
10300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_GetOutcode",kwnames,&obj0,&obj1)) SWIG_fail;
10301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10302 if (!SWIG_IsOK(res1)) {
10303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetOutcode" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10304 }
10305 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10306 {
10307 arg2 = &temp2;
10308 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10309 }
10310 {
10311 result = (wxOutCode)((wxRect2D const *)arg1)->GetOutcode((wxPoint2D const &)*arg2);
10312 if (PyErr_Occurred()) SWIG_fail;
10313 }
10314 resultobj = SWIG_From_int(static_cast< int >(result));
10315 return resultobj;
10316 fail:
10317 return NULL;
10318 }
10319
10320
10321 SWIGINTERN PyObject *_wrap_Rect2D_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10322 PyObject *resultobj = 0;
10323 wxRect2D *arg1 = (wxRect2D *) 0 ;
10324 wxPoint2D *arg2 = 0 ;
10325 bool result;
10326 void *argp1 = 0 ;
10327 int res1 = 0 ;
10328 wxPoint2D temp2 ;
10329 PyObject * obj0 = 0 ;
10330 PyObject * obj1 = 0 ;
10331 char * kwnames[] = {
10332 (char *) "self",(char *) "pt", NULL
10333 };
10334
10335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
10336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10337 if (!SWIG_IsOK(res1)) {
10338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Contains" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10339 }
10340 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10341 {
10342 arg2 = &temp2;
10343 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10344 }
10345 {
10346 result = (bool)((wxRect2D const *)arg1)->Contains((wxPoint2D const &)*arg2);
10347 if (PyErr_Occurred()) SWIG_fail;
10348 }
10349 {
10350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10351 }
10352 return resultobj;
10353 fail:
10354 return NULL;
10355 }
10356
10357
10358 SWIGINTERN PyObject *_wrap_Rect2D_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10359 PyObject *resultobj = 0;
10360 wxRect2D *arg1 = (wxRect2D *) 0 ;
10361 wxRect2D *arg2 = 0 ;
10362 bool result;
10363 void *argp1 = 0 ;
10364 int res1 = 0 ;
10365 wxRect2D temp2 ;
10366 PyObject * obj0 = 0 ;
10367 PyObject * obj1 = 0 ;
10368 char * kwnames[] = {
10369 (char *) "self",(char *) "rect", NULL
10370 };
10371
10372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
10373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10374 if (!SWIG_IsOK(res1)) {
10375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ContainsRect" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10376 }
10377 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10378 {
10379 arg2 = &temp2;
10380 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10381 }
10382 {
10383 result = (bool)((wxRect2D const *)arg1)->Contains((wxRect2D const &)*arg2);
10384 if (PyErr_Occurred()) SWIG_fail;
10385 }
10386 {
10387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10388 }
10389 return resultobj;
10390 fail:
10391 return NULL;
10392 }
10393
10394
10395 SWIGINTERN PyObject *_wrap_Rect2D_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10396 PyObject *resultobj = 0;
10397 wxRect2D *arg1 = (wxRect2D *) 0 ;
10398 bool result;
10399 void *argp1 = 0 ;
10400 int res1 = 0 ;
10401 PyObject *swig_obj[1] ;
10402
10403 if (!args) SWIG_fail;
10404 swig_obj[0] = args;
10405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10406 if (!SWIG_IsOK(res1)) {
10407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_IsEmpty" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10408 }
10409 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10410 {
10411 result = (bool)((wxRect2D const *)arg1)->IsEmpty();
10412 if (PyErr_Occurred()) SWIG_fail;
10413 }
10414 {
10415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10416 }
10417 return resultobj;
10418 fail:
10419 return NULL;
10420 }
10421
10422
10423 SWIGINTERN PyObject *_wrap_Rect2D_HaveEqualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10424 PyObject *resultobj = 0;
10425 wxRect2D *arg1 = (wxRect2D *) 0 ;
10426 wxRect2D *arg2 = 0 ;
10427 bool result;
10428 void *argp1 = 0 ;
10429 int res1 = 0 ;
10430 wxRect2D temp2 ;
10431 PyObject * obj0 = 0 ;
10432 PyObject * obj1 = 0 ;
10433 char * kwnames[] = {
10434 (char *) "self",(char *) "rect", NULL
10435 };
10436
10437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_HaveEqualSize",kwnames,&obj0,&obj1)) SWIG_fail;
10438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10439 if (!SWIG_IsOK(res1)) {
10440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_HaveEqualSize" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10441 }
10442 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10443 {
10444 arg2 = &temp2;
10445 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10446 }
10447 {
10448 result = (bool)((wxRect2D const *)arg1)->HaveEqualSize((wxRect2D const &)*arg2);
10449 if (PyErr_Occurred()) SWIG_fail;
10450 }
10451 {
10452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10453 }
10454 return resultobj;
10455 fail:
10456 return NULL;
10457 }
10458
10459
10460 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10461 PyObject *resultobj = 0;
10462 wxRect2D *arg1 = (wxRect2D *) 0 ;
10463 wxDouble arg2 ;
10464 wxDouble arg3 ;
10465 void *argp1 = 0 ;
10466 int res1 = 0 ;
10467 void *argp2 ;
10468 int res2 = 0 ;
10469 void *argp3 ;
10470 int res3 = 0 ;
10471
10472 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10474 if (!SWIG_IsOK(res1)) {
10475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10476 }
10477 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10478 {
10479 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10480 if (!SWIG_IsOK(res2)) {
10481 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10482 }
10483 if (!argp2) {
10484 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10485 } else {
10486 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10487 arg2 = *temp;
10488 if (SWIG_IsNewObj(res2)) delete temp;
10489 }
10490 }
10491 {
10492 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10493 if (!SWIG_IsOK(res3)) {
10494 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10495 }
10496 if (!argp3) {
10497 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10498 } else {
10499 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10500 arg3 = *temp;
10501 if (SWIG_IsNewObj(res3)) delete temp;
10502 }
10503 }
10504 {
10505 (arg1)->Inset(arg2,arg3);
10506 if (PyErr_Occurred()) SWIG_fail;
10507 }
10508 resultobj = SWIG_Py_Void();
10509 return resultobj;
10510 fail:
10511 return NULL;
10512 }
10513
10514
10515 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10516 PyObject *resultobj = 0;
10517 wxRect2D *arg1 = (wxRect2D *) 0 ;
10518 wxDouble arg2 ;
10519 wxDouble arg3 ;
10520 wxDouble arg4 ;
10521 wxDouble arg5 ;
10522 void *argp1 = 0 ;
10523 int res1 = 0 ;
10524 void *argp2 ;
10525 int res2 = 0 ;
10526 void *argp3 ;
10527 int res3 = 0 ;
10528 void *argp4 ;
10529 int res4 = 0 ;
10530 void *argp5 ;
10531 int res5 = 0 ;
10532
10533 if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
10534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10535 if (!SWIG_IsOK(res1)) {
10536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10537 }
10538 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10539 {
10540 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10541 if (!SWIG_IsOK(res2)) {
10542 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10543 }
10544 if (!argp2) {
10545 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10546 } else {
10547 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10548 arg2 = *temp;
10549 if (SWIG_IsNewObj(res2)) delete temp;
10550 }
10551 }
10552 {
10553 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10554 if (!SWIG_IsOK(res3)) {
10555 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10556 }
10557 if (!argp3) {
10558 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10559 } else {
10560 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10561 arg3 = *temp;
10562 if (SWIG_IsNewObj(res3)) delete temp;
10563 }
10564 }
10565 {
10566 res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
10567 if (!SWIG_IsOK(res4)) {
10568 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10569 }
10570 if (!argp4) {
10571 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10572 } else {
10573 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
10574 arg4 = *temp;
10575 if (SWIG_IsNewObj(res4)) delete temp;
10576 }
10577 }
10578 {
10579 res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
10580 if (!SWIG_IsOK(res5)) {
10581 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10582 }
10583 if (!argp5) {
10584 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10585 } else {
10586 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
10587 arg5 = *temp;
10588 if (SWIG_IsNewObj(res5)) delete temp;
10589 }
10590 }
10591 {
10592 (arg1)->Inset(arg2,arg3,arg4,arg5);
10593 if (PyErr_Occurred()) SWIG_fail;
10594 }
10595 resultobj = SWIG_Py_Void();
10596 return resultobj;
10597 fail:
10598 return NULL;
10599 }
10600
10601
10602 SWIGINTERN PyObject *_wrap_Rect2D_Inset(PyObject *self, PyObject *args) {
10603 int argc;
10604 PyObject *argv[6];
10605
10606 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Inset",0,5,argv))) SWIG_fail;
10607 --argc;
10608 if (argc == 3) {
10609 return _wrap_Rect2D_Inset__SWIG_0(self, argc, argv);
10610 }
10611 if (argc == 5) {
10612 return _wrap_Rect2D_Inset__SWIG_1(self, argc, argv);
10613 }
10614
10615 fail:
10616 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Inset'");
10617 return NULL;
10618 }
10619
10620
10621 SWIGINTERN PyObject *_wrap_Rect2D_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10622 PyObject *resultobj = 0;
10623 wxRect2D *arg1 = (wxRect2D *) 0 ;
10624 wxPoint2D *arg2 = 0 ;
10625 void *argp1 = 0 ;
10626 int res1 = 0 ;
10627 wxPoint2D temp2 ;
10628 PyObject * obj0 = 0 ;
10629 PyObject * obj1 = 0 ;
10630 char * kwnames[] = {
10631 (char *) "self",(char *) "pt", NULL
10632 };
10633
10634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
10635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10636 if (!SWIG_IsOK(res1)) {
10637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Offset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10638 }
10639 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10640 {
10641 arg2 = &temp2;
10642 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10643 }
10644 {
10645 (arg1)->Offset((wxPoint2D const &)*arg2);
10646 if (PyErr_Occurred()) SWIG_fail;
10647 }
10648 resultobj = SWIG_Py_Void();
10649 return resultobj;
10650 fail:
10651 return NULL;
10652 }
10653
10654
10655 SWIGINTERN PyObject *_wrap_Rect2D_ConstrainTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10656 PyObject *resultobj = 0;
10657 wxRect2D *arg1 = (wxRect2D *) 0 ;
10658 wxRect2D *arg2 = 0 ;
10659 void *argp1 = 0 ;
10660 int res1 = 0 ;
10661 wxRect2D temp2 ;
10662 PyObject * obj0 = 0 ;
10663 PyObject * obj1 = 0 ;
10664 char * kwnames[] = {
10665 (char *) "self",(char *) "rect", NULL
10666 };
10667
10668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ConstrainTo",kwnames,&obj0,&obj1)) SWIG_fail;
10669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10670 if (!SWIG_IsOK(res1)) {
10671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ConstrainTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10672 }
10673 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10674 {
10675 arg2 = &temp2;
10676 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10677 }
10678 {
10679 (arg1)->ConstrainTo((wxRect2D const &)*arg2);
10680 if (PyErr_Occurred()) SWIG_fail;
10681 }
10682 resultobj = SWIG_Py_Void();
10683 return resultobj;
10684 fail:
10685 return NULL;
10686 }
10687
10688
10689 SWIGINTERN PyObject *_wrap_Rect2D_Interpolate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10690 PyObject *resultobj = 0;
10691 wxRect2D *arg1 = (wxRect2D *) 0 ;
10692 int arg2 ;
10693 int arg3 ;
10694 wxPoint2D result;
10695 void *argp1 = 0 ;
10696 int res1 = 0 ;
10697 int val2 ;
10698 int ecode2 = 0 ;
10699 int val3 ;
10700 int ecode3 = 0 ;
10701 PyObject * obj0 = 0 ;
10702 PyObject * obj1 = 0 ;
10703 PyObject * obj2 = 0 ;
10704 char * kwnames[] = {
10705 (char *) "self",(char *) "widthfactor",(char *) "heightfactor", NULL
10706 };
10707
10708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect2D_Interpolate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10710 if (!SWIG_IsOK(res1)) {
10711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Interpolate" "', expected argument " "1"" of type '" "wxRect2D *""'");
10712 }
10713 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10714 ecode2 = SWIG_AsVal_int(obj1, &val2);
10715 if (!SWIG_IsOK(ecode2)) {
10716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Interpolate" "', expected argument " "2"" of type '" "int""'");
10717 }
10718 arg2 = static_cast< int >(val2);
10719 ecode3 = SWIG_AsVal_int(obj2, &val3);
10720 if (!SWIG_IsOK(ecode3)) {
10721 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Interpolate" "', expected argument " "3"" of type '" "int""'");
10722 }
10723 arg3 = static_cast< int >(val3);
10724 {
10725 result = (arg1)->Interpolate(arg2,arg3);
10726 if (PyErr_Occurred()) SWIG_fail;
10727 }
10728 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10729 return resultobj;
10730 fail:
10731 return NULL;
10732 }
10733
10734
10735 SWIGINTERN PyObject *_wrap_Rect2D_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10736 PyObject *resultobj = 0;
10737 wxRect2D *arg1 = (wxRect2D *) 0 ;
10738 wxRect2D *arg2 = 0 ;
10739 void *argp1 = 0 ;
10740 int res1 = 0 ;
10741 wxRect2D temp2 ;
10742 PyObject * obj0 = 0 ;
10743 PyObject * obj1 = 0 ;
10744 char * kwnames[] = {
10745 (char *) "self",(char *) "otherRect", NULL
10746 };
10747
10748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
10749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10750 if (!SWIG_IsOK(res1)) {
10751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersect" "', expected argument " "1"" of type '" "wxRect2D *""'");
10752 }
10753 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10754 {
10755 arg2 = &temp2;
10756 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10757 }
10758 {
10759 (arg1)->Intersect((wxRect2D const &)*arg2);
10760 if (PyErr_Occurred()) SWIG_fail;
10761 }
10762 resultobj = SWIG_Py_Void();
10763 return resultobj;
10764 fail:
10765 return NULL;
10766 }
10767
10768
10769 SWIGINTERN PyObject *_wrap_Rect2D_CreateIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10770 PyObject *resultobj = 0;
10771 wxRect2D *arg1 = (wxRect2D *) 0 ;
10772 wxRect2D *arg2 = 0 ;
10773 wxRect2D result;
10774 void *argp1 = 0 ;
10775 int res1 = 0 ;
10776 wxRect2D temp2 ;
10777 PyObject * obj0 = 0 ;
10778 PyObject * obj1 = 0 ;
10779 char * kwnames[] = {
10780 (char *) "self",(char *) "otherRect", NULL
10781 };
10782
10783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateIntersection",kwnames,&obj0,&obj1)) SWIG_fail;
10784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10785 if (!SWIG_IsOK(res1)) {
10786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateIntersection" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10787 }
10788 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10789 {
10790 arg2 = &temp2;
10791 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10792 }
10793 {
10794 result = ((wxRect2D const *)arg1)->CreateIntersection((wxRect2D const &)*arg2);
10795 if (PyErr_Occurred()) SWIG_fail;
10796 }
10797 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10798 return resultobj;
10799 fail:
10800 return NULL;
10801 }
10802
10803
10804 SWIGINTERN PyObject *_wrap_Rect2D_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10805 PyObject *resultobj = 0;
10806 wxRect2D *arg1 = (wxRect2D *) 0 ;
10807 wxRect2D *arg2 = 0 ;
10808 bool result;
10809 void *argp1 = 0 ;
10810 int res1 = 0 ;
10811 wxRect2D temp2 ;
10812 PyObject * obj0 = 0 ;
10813 PyObject * obj1 = 0 ;
10814 char * kwnames[] = {
10815 (char *) "self",(char *) "rect", NULL
10816 };
10817
10818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
10819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10820 if (!SWIG_IsOK(res1)) {
10821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersects" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10822 }
10823 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10824 {
10825 arg2 = &temp2;
10826 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10827 }
10828 {
10829 result = (bool)((wxRect2D const *)arg1)->Intersects((wxRect2D const &)*arg2);
10830 if (PyErr_Occurred()) SWIG_fail;
10831 }
10832 {
10833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10834 }
10835 return resultobj;
10836 fail:
10837 return NULL;
10838 }
10839
10840
10841 SWIGINTERN PyObject *_wrap_Rect2D_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10842 PyObject *resultobj = 0;
10843 wxRect2D *arg1 = (wxRect2D *) 0 ;
10844 wxRect2D *arg2 = 0 ;
10845 void *argp1 = 0 ;
10846 int res1 = 0 ;
10847 wxRect2D temp2 ;
10848 PyObject * obj0 = 0 ;
10849 PyObject * obj1 = 0 ;
10850 char * kwnames[] = {
10851 (char *) "self",(char *) "otherRect", NULL
10852 };
10853
10854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Union",kwnames,&obj0,&obj1)) SWIG_fail;
10855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10856 if (!SWIG_IsOK(res1)) {
10857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Union" "', expected argument " "1"" of type '" "wxRect2D *""'");
10858 }
10859 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10860 {
10861 arg2 = &temp2;
10862 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10863 }
10864 {
10865 (arg1)->Union((wxRect2D const &)*arg2);
10866 if (PyErr_Occurred()) SWIG_fail;
10867 }
10868 resultobj = SWIG_Py_Void();
10869 return resultobj;
10870 fail:
10871 return NULL;
10872 }
10873
10874
10875 SWIGINTERN PyObject *_wrap_Rect2D_CreateUnion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10876 PyObject *resultobj = 0;
10877 wxRect2D *arg1 = (wxRect2D *) 0 ;
10878 wxRect2D *arg2 = 0 ;
10879 wxRect2D result;
10880 void *argp1 = 0 ;
10881 int res1 = 0 ;
10882 wxRect2D temp2 ;
10883 PyObject * obj0 = 0 ;
10884 PyObject * obj1 = 0 ;
10885 char * kwnames[] = {
10886 (char *) "self",(char *) "otherRect", NULL
10887 };
10888
10889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateUnion",kwnames,&obj0,&obj1)) SWIG_fail;
10890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10891 if (!SWIG_IsOK(res1)) {
10892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateUnion" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10893 }
10894 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10895 {
10896 arg2 = &temp2;
10897 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10898 }
10899 {
10900 result = ((wxRect2D const *)arg1)->CreateUnion((wxRect2D const &)*arg2);
10901 if (PyErr_Occurred()) SWIG_fail;
10902 }
10903 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10904 return resultobj;
10905 fail:
10906 return NULL;
10907 }
10908
10909
10910 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10911 PyObject *resultobj = 0;
10912 wxRect2D *arg1 = (wxRect2D *) 0 ;
10913 wxDouble arg2 ;
10914 void *argp1 = 0 ;
10915 int res1 = 0 ;
10916 void *argp2 ;
10917 int res2 = 0 ;
10918
10919 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
10920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10921 if (!SWIG_IsOK(res1)) {
10922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10923 }
10924 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10925 {
10926 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10927 if (!SWIG_IsOK(res2)) {
10928 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10929 }
10930 if (!argp2) {
10931 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10932 } else {
10933 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10934 arg2 = *temp;
10935 if (SWIG_IsNewObj(res2)) delete temp;
10936 }
10937 }
10938 {
10939 (arg1)->Scale(arg2);
10940 if (PyErr_Occurred()) SWIG_fail;
10941 }
10942 resultobj = SWIG_Py_Void();
10943 return resultobj;
10944 fail:
10945 return NULL;
10946 }
10947
10948
10949 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10950 PyObject *resultobj = 0;
10951 wxRect2D *arg1 = (wxRect2D *) 0 ;
10952 int arg2 ;
10953 int arg3 ;
10954 void *argp1 = 0 ;
10955 int res1 = 0 ;
10956 int val2 ;
10957 int ecode2 = 0 ;
10958 int val3 ;
10959 int ecode3 = 0 ;
10960
10961 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10963 if (!SWIG_IsOK(res1)) {
10964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10965 }
10966 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10967 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10968 if (!SWIG_IsOK(ecode2)) {
10969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "int""'");
10970 }
10971 arg2 = static_cast< int >(val2);
10972 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10973 if (!SWIG_IsOK(ecode3)) {
10974 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Scale" "', expected argument " "3"" of type '" "int""'");
10975 }
10976 arg3 = static_cast< int >(val3);
10977 {
10978 (arg1)->Scale(arg2,arg3);
10979 if (PyErr_Occurred()) SWIG_fail;
10980 }
10981 resultobj = SWIG_Py_Void();
10982 return resultobj;
10983 fail:
10984 return NULL;
10985 }
10986
10987
10988 SWIGINTERN PyObject *_wrap_Rect2D_Scale(PyObject *self, PyObject *args) {
10989 int argc;
10990 PyObject *argv[4];
10991
10992 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Scale",0,3,argv))) SWIG_fail;
10993 --argc;
10994 if (argc == 2) {
10995 return _wrap_Rect2D_Scale__SWIG_0(self, argc, argv);
10996 }
10997 if (argc == 3) {
10998 return _wrap_Rect2D_Scale__SWIG_1(self, argc, argv);
10999 }
11000
11001 fail:
11002 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Scale'");
11003 return NULL;
11004 }
11005
11006
11007 SWIGINTERN PyObject *_wrap_Rect2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11008 PyObject *resultobj = 0;
11009 wxRect2D *arg1 = (wxRect2D *) 0 ;
11010 PyObject *arg2 = (PyObject *) 0 ;
11011 bool result;
11012 void *argp1 = 0 ;
11013 int res1 = 0 ;
11014 PyObject * obj0 = 0 ;
11015 PyObject * obj1 = 0 ;
11016 char * kwnames[] = {
11017 (char *) "self",(char *) "other", NULL
11018 };
11019
11020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
11021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11022 if (!SWIG_IsOK(res1)) {
11023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___eq__" "', expected argument " "1"" of type '" "wxRect2D *""'");
11024 }
11025 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11026 arg2 = obj1;
11027 {
11028 result = (bool)wxRect2D___eq__(arg1,arg2);
11029 if (PyErr_Occurred()) SWIG_fail;
11030 }
11031 {
11032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11033 }
11034 return resultobj;
11035 fail:
11036 return NULL;
11037 }
11038
11039
11040 SWIGINTERN PyObject *_wrap_Rect2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11041 PyObject *resultobj = 0;
11042 wxRect2D *arg1 = (wxRect2D *) 0 ;
11043 PyObject *arg2 = (PyObject *) 0 ;
11044 bool result;
11045 void *argp1 = 0 ;
11046 int res1 = 0 ;
11047 PyObject * obj0 = 0 ;
11048 PyObject * obj1 = 0 ;
11049 char * kwnames[] = {
11050 (char *) "self",(char *) "other", NULL
11051 };
11052
11053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
11054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11055 if (!SWIG_IsOK(res1)) {
11056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___ne__" "', expected argument " "1"" of type '" "wxRect2D *""'");
11057 }
11058 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11059 arg2 = obj1;
11060 {
11061 result = (bool)wxRect2D___ne__(arg1,arg2);
11062 if (PyErr_Occurred()) SWIG_fail;
11063 }
11064 {
11065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11066 }
11067 return resultobj;
11068 fail:
11069 return NULL;
11070 }
11071
11072
11073 SWIGINTERN PyObject *_wrap_Rect2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11074 PyObject *resultobj = 0;
11075 wxRect2D *arg1 = (wxRect2D *) 0 ;
11076 wxDouble arg2 ;
11077 void *argp1 = 0 ;
11078 int res1 = 0 ;
11079 void *argp2 ;
11080 int res2 = 0 ;
11081 PyObject *swig_obj[2] ;
11082
11083 if (!SWIG_Python_UnpackTuple(args,"Rect2D_x_set",2,2,swig_obj)) SWIG_fail;
11084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11085 if (!SWIG_IsOK(res1)) {
11086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11087 }
11088 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11089 {
11090 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11091 if (!SWIG_IsOK(res2)) {
11092 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11093 }
11094 if (!argp2) {
11095 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11096 } else {
11097 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11098 arg2 = *temp;
11099 if (SWIG_IsNewObj(res2)) delete temp;
11100 }
11101 }
11102 if (arg1) (arg1)->m_x = arg2;
11103
11104 resultobj = SWIG_Py_Void();
11105 return resultobj;
11106 fail:
11107 return NULL;
11108 }
11109
11110
11111 SWIGINTERN PyObject *_wrap_Rect2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11112 PyObject *resultobj = 0;
11113 wxRect2D *arg1 = (wxRect2D *) 0 ;
11114 wxDouble result;
11115 void *argp1 = 0 ;
11116 int res1 = 0 ;
11117 PyObject *swig_obj[1] ;
11118
11119 if (!args) SWIG_fail;
11120 swig_obj[0] = args;
11121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11122 if (!SWIG_IsOK(res1)) {
11123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11124 }
11125 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11126 result = ((arg1)->m_x);
11127 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11128 return resultobj;
11129 fail:
11130 return NULL;
11131 }
11132
11133
11134 SWIGINTERN PyObject *_wrap_Rect2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11135 PyObject *resultobj = 0;
11136 wxRect2D *arg1 = (wxRect2D *) 0 ;
11137 wxDouble arg2 ;
11138 void *argp1 = 0 ;
11139 int res1 = 0 ;
11140 void *argp2 ;
11141 int res2 = 0 ;
11142 PyObject *swig_obj[2] ;
11143
11144 if (!SWIG_Python_UnpackTuple(args,"Rect2D_y_set",2,2,swig_obj)) SWIG_fail;
11145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11146 if (!SWIG_IsOK(res1)) {
11147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11148 }
11149 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11150 {
11151 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11152 if (!SWIG_IsOK(res2)) {
11153 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11154 }
11155 if (!argp2) {
11156 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11157 } else {
11158 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11159 arg2 = *temp;
11160 if (SWIG_IsNewObj(res2)) delete temp;
11161 }
11162 }
11163 if (arg1) (arg1)->m_y = arg2;
11164
11165 resultobj = SWIG_Py_Void();
11166 return resultobj;
11167 fail:
11168 return NULL;
11169 }
11170
11171
11172 SWIGINTERN PyObject *_wrap_Rect2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11173 PyObject *resultobj = 0;
11174 wxRect2D *arg1 = (wxRect2D *) 0 ;
11175 wxDouble result;
11176 void *argp1 = 0 ;
11177 int res1 = 0 ;
11178 PyObject *swig_obj[1] ;
11179
11180 if (!args) SWIG_fail;
11181 swig_obj[0] = args;
11182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11183 if (!SWIG_IsOK(res1)) {
11184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11185 }
11186 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11187 result = ((arg1)->m_y);
11188 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11189 return resultobj;
11190 fail:
11191 return NULL;
11192 }
11193
11194
11195 SWIGINTERN PyObject *_wrap_Rect2D_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11196 PyObject *resultobj = 0;
11197 wxRect2D *arg1 = (wxRect2D *) 0 ;
11198 wxDouble arg2 ;
11199 void *argp1 = 0 ;
11200 int res1 = 0 ;
11201 void *argp2 ;
11202 int res2 = 0 ;
11203 PyObject *swig_obj[2] ;
11204
11205 if (!SWIG_Python_UnpackTuple(args,"Rect2D_width_set",2,2,swig_obj)) SWIG_fail;
11206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11207 if (!SWIG_IsOK(res1)) {
11208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11209 }
11210 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11211 {
11212 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11213 if (!SWIG_IsOK(res2)) {
11214 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11215 }
11216 if (!argp2) {
11217 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11218 } else {
11219 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11220 arg2 = *temp;
11221 if (SWIG_IsNewObj(res2)) delete temp;
11222 }
11223 }
11224 if (arg1) (arg1)->m_width = arg2;
11225
11226 resultobj = SWIG_Py_Void();
11227 return resultobj;
11228 fail:
11229 return NULL;
11230 }
11231
11232
11233 SWIGINTERN PyObject *_wrap_Rect2D_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11234 PyObject *resultobj = 0;
11235 wxRect2D *arg1 = (wxRect2D *) 0 ;
11236 wxDouble result;
11237 void *argp1 = 0 ;
11238 int res1 = 0 ;
11239 PyObject *swig_obj[1] ;
11240
11241 if (!args) SWIG_fail;
11242 swig_obj[0] = args;
11243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11244 if (!SWIG_IsOK(res1)) {
11245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11246 }
11247 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11248 result = ((arg1)->m_width);
11249 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11250 return resultobj;
11251 fail:
11252 return NULL;
11253 }
11254
11255
11256 SWIGINTERN PyObject *_wrap_Rect2D_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11257 PyObject *resultobj = 0;
11258 wxRect2D *arg1 = (wxRect2D *) 0 ;
11259 wxDouble arg2 ;
11260 void *argp1 = 0 ;
11261 int res1 = 0 ;
11262 void *argp2 ;
11263 int res2 = 0 ;
11264 PyObject *swig_obj[2] ;
11265
11266 if (!SWIG_Python_UnpackTuple(args,"Rect2D_height_set",2,2,swig_obj)) SWIG_fail;
11267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11268 if (!SWIG_IsOK(res1)) {
11269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11270 }
11271 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11272 {
11273 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11274 if (!SWIG_IsOK(res2)) {
11275 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11276 }
11277 if (!argp2) {
11278 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11279 } else {
11280 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11281 arg2 = *temp;
11282 if (SWIG_IsNewObj(res2)) delete temp;
11283 }
11284 }
11285 if (arg1) (arg1)->m_height = arg2;
11286
11287 resultobj = SWIG_Py_Void();
11288 return resultobj;
11289 fail:
11290 return NULL;
11291 }
11292
11293
11294 SWIGINTERN PyObject *_wrap_Rect2D_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11295 PyObject *resultobj = 0;
11296 wxRect2D *arg1 = (wxRect2D *) 0 ;
11297 wxDouble result;
11298 void *argp1 = 0 ;
11299 int res1 = 0 ;
11300 PyObject *swig_obj[1] ;
11301
11302 if (!args) SWIG_fail;
11303 swig_obj[0] = args;
11304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11305 if (!SWIG_IsOK(res1)) {
11306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11307 }
11308 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11309 result = ((arg1)->m_height);
11310 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11311 return resultobj;
11312 fail:
11313 return NULL;
11314 }
11315
11316
11317 SWIGINTERN PyObject *_wrap_Rect2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11318 PyObject *resultobj = 0;
11319 wxRect2D *arg1 = (wxRect2D *) 0 ;
11320 wxDouble arg2 = (wxDouble) 0 ;
11321 wxDouble arg3 = (wxDouble) 0 ;
11322 wxDouble arg4 = (wxDouble) 0 ;
11323 wxDouble arg5 = (wxDouble) 0 ;
11324 void *argp1 = 0 ;
11325 int res1 = 0 ;
11326 void *argp2 ;
11327 int res2 = 0 ;
11328 void *argp3 ;
11329 int res3 = 0 ;
11330 void *argp4 ;
11331 int res4 = 0 ;
11332 void *argp5 ;
11333 int res5 = 0 ;
11334 PyObject * obj0 = 0 ;
11335 PyObject * obj1 = 0 ;
11336 PyObject * obj2 = 0 ;
11337 PyObject * obj3 = 0 ;
11338 PyObject * obj4 = 0 ;
11339 char * kwnames[] = {
11340 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
11341 };
11342
11343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect2D_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11345 if (!SWIG_IsOK(res1)) {
11346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11347 }
11348 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11349 if (obj1) {
11350 {
11351 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11352 if (!SWIG_IsOK(res2)) {
11353 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11354 }
11355 if (!argp2) {
11356 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11357 } else {
11358 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11359 arg2 = *temp;
11360 if (SWIG_IsNewObj(res2)) delete temp;
11361 }
11362 }
11363 }
11364 if (obj2) {
11365 {
11366 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
11367 if (!SWIG_IsOK(res3)) {
11368 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11369 }
11370 if (!argp3) {
11371 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11372 } else {
11373 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
11374 arg3 = *temp;
11375 if (SWIG_IsNewObj(res3)) delete temp;
11376 }
11377 }
11378 }
11379 if (obj3) {
11380 {
11381 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
11382 if (!SWIG_IsOK(res4)) {
11383 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11384 }
11385 if (!argp4) {
11386 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11387 } else {
11388 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
11389 arg4 = *temp;
11390 if (SWIG_IsNewObj(res4)) delete temp;
11391 }
11392 }
11393 }
11394 if (obj4) {
11395 {
11396 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
11397 if (!SWIG_IsOK(res5)) {
11398 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11399 }
11400 if (!argp5) {
11401 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11402 } else {
11403 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
11404 arg5 = *temp;
11405 if (SWIG_IsNewObj(res5)) delete temp;
11406 }
11407 }
11408 }
11409 {
11410 wxRect2D_Set(arg1,arg2,arg3,arg4,arg5);
11411 if (PyErr_Occurred()) SWIG_fail;
11412 }
11413 resultobj = SWIG_Py_Void();
11414 return resultobj;
11415 fail:
11416 return NULL;
11417 }
11418
11419
11420 SWIGINTERN PyObject *_wrap_Rect2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11421 PyObject *resultobj = 0;
11422 wxRect2D *arg1 = (wxRect2D *) 0 ;
11423 PyObject *result = 0 ;
11424 void *argp1 = 0 ;
11425 int res1 = 0 ;
11426 PyObject *swig_obj[1] ;
11427
11428 if (!args) SWIG_fail;
11429 swig_obj[0] = args;
11430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11431 if (!SWIG_IsOK(res1)) {
11432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11433 }
11434 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11435 {
11436 result = (PyObject *)wxRect2D_Get(arg1);
11437 if (PyErr_Occurred()) SWIG_fail;
11438 }
11439 resultobj = result;
11440 return resultobj;
11441 fail:
11442 return NULL;
11443 }
11444
11445
11446 SWIGINTERN PyObject *Rect2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11447 PyObject *obj;
11448 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11449 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect2D, SWIG_NewClientData(obj));
11450 return SWIG_Py_Void();
11451 }
11452
11453 SWIGINTERN PyObject *Rect2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11454 return SWIG_Python_InitShadowInstance(args);
11455 }
11456
11457 SWIGINTERN int DefaultPosition_set(PyObject *) {
11458 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
11459 return 1;
11460 }
11461
11462
11463 SWIGINTERN PyObject *DefaultPosition_get(void) {
11464 PyObject *pyobj = 0;
11465
11466 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
11467 return pyobj;
11468 }
11469
11470
11471 SWIGINTERN int DefaultSize_set(PyObject *) {
11472 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
11473 return 1;
11474 }
11475
11476
11477 SWIGINTERN PyObject *DefaultSize_get(void) {
11478 PyObject *pyobj = 0;
11479
11480 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
11481 return pyobj;
11482 }
11483
11484
11485 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11486 PyObject *resultobj = 0;
11487 PyObject *arg1 = (PyObject *) 0 ;
11488 wxPyInputStream *result = 0 ;
11489 PyObject * obj0 = 0 ;
11490 char * kwnames[] = {
11491 (char *) "p", NULL
11492 };
11493
11494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
11495 arg1 = obj0;
11496 {
11497 PyThreadState* __tstate = wxPyBeginAllowThreads();
11498 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
11499 wxPyEndAllowThreads(__tstate);
11500 if (PyErr_Occurred()) SWIG_fail;
11501 }
11502 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
11503 return resultobj;
11504 fail:
11505 return NULL;
11506 }
11507
11508
11509 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11510 PyObject *resultobj = 0;
11511 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11512 void *argp1 = 0 ;
11513 int res1 = 0 ;
11514 PyObject *swig_obj[1] ;
11515
11516 if (!args) SWIG_fail;
11517 swig_obj[0] = args;
11518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
11519 if (!SWIG_IsOK(res1)) {
11520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11521 }
11522 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11523 {
11524 PyThreadState* __tstate = wxPyBeginAllowThreads();
11525 delete arg1;
11526
11527 wxPyEndAllowThreads(__tstate);
11528 if (PyErr_Occurred()) SWIG_fail;
11529 }
11530 resultobj = SWIG_Py_Void();
11531 return resultobj;
11532 fail:
11533 return NULL;
11534 }
11535
11536
11537 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11538 PyObject *resultobj = 0;
11539 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11540 void *argp1 = 0 ;
11541 int res1 = 0 ;
11542 PyObject *swig_obj[1] ;
11543
11544 if (!args) SWIG_fail;
11545 swig_obj[0] = args;
11546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11547 if (!SWIG_IsOK(res1)) {
11548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11549 }
11550 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11551 {
11552 PyThreadState* __tstate = wxPyBeginAllowThreads();
11553 (arg1)->close();
11554 wxPyEndAllowThreads(__tstate);
11555 if (PyErr_Occurred()) SWIG_fail;
11556 }
11557 resultobj = SWIG_Py_Void();
11558 return resultobj;
11559 fail:
11560 return NULL;
11561 }
11562
11563
11564 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11565 PyObject *resultobj = 0;
11566 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11567 void *argp1 = 0 ;
11568 int res1 = 0 ;
11569 PyObject *swig_obj[1] ;
11570
11571 if (!args) SWIG_fail;
11572 swig_obj[0] = args;
11573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11574 if (!SWIG_IsOK(res1)) {
11575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11576 }
11577 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11578 {
11579 PyThreadState* __tstate = wxPyBeginAllowThreads();
11580 (arg1)->flush();
11581 wxPyEndAllowThreads(__tstate);
11582 if (PyErr_Occurred()) SWIG_fail;
11583 }
11584 resultobj = SWIG_Py_Void();
11585 return resultobj;
11586 fail:
11587 return NULL;
11588 }
11589
11590
11591 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11592 PyObject *resultobj = 0;
11593 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11594 bool result;
11595 void *argp1 = 0 ;
11596 int res1 = 0 ;
11597 PyObject *swig_obj[1] ;
11598
11599 if (!args) SWIG_fail;
11600 swig_obj[0] = args;
11601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11602 if (!SWIG_IsOK(res1)) {
11603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11604 }
11605 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11606 {
11607 PyThreadState* __tstate = wxPyBeginAllowThreads();
11608 result = (bool)(arg1)->eof();
11609 wxPyEndAllowThreads(__tstate);
11610 if (PyErr_Occurred()) SWIG_fail;
11611 }
11612 {
11613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11614 }
11615 return resultobj;
11616 fail:
11617 return NULL;
11618 }
11619
11620
11621 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11622 PyObject *resultobj = 0;
11623 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11624 int arg2 = (int) -1 ;
11625 PyObject *result = 0 ;
11626 void *argp1 = 0 ;
11627 int res1 = 0 ;
11628 int val2 ;
11629 int ecode2 = 0 ;
11630 PyObject * obj0 = 0 ;
11631 PyObject * obj1 = 0 ;
11632 char * kwnames[] = {
11633 (char *) "self",(char *) "size", NULL
11634 };
11635
11636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
11637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11638 if (!SWIG_IsOK(res1)) {
11639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11640 }
11641 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11642 if (obj1) {
11643 ecode2 = SWIG_AsVal_int(obj1, &val2);
11644 if (!SWIG_IsOK(ecode2)) {
11645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
11646 }
11647 arg2 = static_cast< int >(val2);
11648 }
11649 {
11650 PyThreadState* __tstate = wxPyBeginAllowThreads();
11651 result = (PyObject *)(arg1)->read(arg2);
11652 wxPyEndAllowThreads(__tstate);
11653 if (PyErr_Occurred()) SWIG_fail;
11654 }
11655 resultobj = result;
11656 return resultobj;
11657 fail:
11658 return NULL;
11659 }
11660
11661
11662 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11663 PyObject *resultobj = 0;
11664 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11665 int arg2 = (int) -1 ;
11666 PyObject *result = 0 ;
11667 void *argp1 = 0 ;
11668 int res1 = 0 ;
11669 int val2 ;
11670 int ecode2 = 0 ;
11671 PyObject * obj0 = 0 ;
11672 PyObject * obj1 = 0 ;
11673 char * kwnames[] = {
11674 (char *) "self",(char *) "size", NULL
11675 };
11676
11677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
11678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11679 if (!SWIG_IsOK(res1)) {
11680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11681 }
11682 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11683 if (obj1) {
11684 ecode2 = SWIG_AsVal_int(obj1, &val2);
11685 if (!SWIG_IsOK(ecode2)) {
11686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
11687 }
11688 arg2 = static_cast< int >(val2);
11689 }
11690 {
11691 PyThreadState* __tstate = wxPyBeginAllowThreads();
11692 result = (PyObject *)(arg1)->readline(arg2);
11693 wxPyEndAllowThreads(__tstate);
11694 if (PyErr_Occurred()) SWIG_fail;
11695 }
11696 resultobj = result;
11697 return resultobj;
11698 fail:
11699 return NULL;
11700 }
11701
11702
11703 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11704 PyObject *resultobj = 0;
11705 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11706 int arg2 = (int) -1 ;
11707 PyObject *result = 0 ;
11708 void *argp1 = 0 ;
11709 int res1 = 0 ;
11710 int val2 ;
11711 int ecode2 = 0 ;
11712 PyObject * obj0 = 0 ;
11713 PyObject * obj1 = 0 ;
11714 char * kwnames[] = {
11715 (char *) "self",(char *) "sizehint", NULL
11716 };
11717
11718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
11719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11720 if (!SWIG_IsOK(res1)) {
11721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11722 }
11723 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11724 if (obj1) {
11725 ecode2 = SWIG_AsVal_int(obj1, &val2);
11726 if (!SWIG_IsOK(ecode2)) {
11727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
11728 }
11729 arg2 = static_cast< int >(val2);
11730 }
11731 {
11732 PyThreadState* __tstate = wxPyBeginAllowThreads();
11733 result = (PyObject *)(arg1)->readlines(arg2);
11734 wxPyEndAllowThreads(__tstate);
11735 if (PyErr_Occurred()) SWIG_fail;
11736 }
11737 resultobj = result;
11738 return resultobj;
11739 fail:
11740 return NULL;
11741 }
11742
11743
11744 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11745 PyObject *resultobj = 0;
11746 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11747 int arg2 ;
11748 int arg3 = (int) 0 ;
11749 void *argp1 = 0 ;
11750 int res1 = 0 ;
11751 int val2 ;
11752 int ecode2 = 0 ;
11753 int val3 ;
11754 int ecode3 = 0 ;
11755 PyObject * obj0 = 0 ;
11756 PyObject * obj1 = 0 ;
11757 PyObject * obj2 = 0 ;
11758 char * kwnames[] = {
11759 (char *) "self",(char *) "offset",(char *) "whence", NULL
11760 };
11761
11762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11764 if (!SWIG_IsOK(res1)) {
11765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11766 }
11767 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11768 ecode2 = SWIG_AsVal_int(obj1, &val2);
11769 if (!SWIG_IsOK(ecode2)) {
11770 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
11771 }
11772 arg2 = static_cast< int >(val2);
11773 if (obj2) {
11774 ecode3 = SWIG_AsVal_int(obj2, &val3);
11775 if (!SWIG_IsOK(ecode3)) {
11776 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
11777 }
11778 arg3 = static_cast< int >(val3);
11779 }
11780 {
11781 PyThreadState* __tstate = wxPyBeginAllowThreads();
11782 (arg1)->seek(arg2,arg3);
11783 wxPyEndAllowThreads(__tstate);
11784 if (PyErr_Occurred()) SWIG_fail;
11785 }
11786 resultobj = SWIG_Py_Void();
11787 return resultobj;
11788 fail:
11789 return NULL;
11790 }
11791
11792
11793 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11794 PyObject *resultobj = 0;
11795 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11796 int result;
11797 void *argp1 = 0 ;
11798 int res1 = 0 ;
11799 PyObject *swig_obj[1] ;
11800
11801 if (!args) SWIG_fail;
11802 swig_obj[0] = args;
11803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11804 if (!SWIG_IsOK(res1)) {
11805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11806 }
11807 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11808 {
11809 PyThreadState* __tstate = wxPyBeginAllowThreads();
11810 result = (int)(arg1)->tell();
11811 wxPyEndAllowThreads(__tstate);
11812 if (PyErr_Occurred()) SWIG_fail;
11813 }
11814 resultobj = SWIG_From_int(static_cast< int >(result));
11815 return resultobj;
11816 fail:
11817 return NULL;
11818 }
11819
11820
11821 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11822 PyObject *resultobj = 0;
11823 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11824 char result;
11825 void *argp1 = 0 ;
11826 int res1 = 0 ;
11827 PyObject *swig_obj[1] ;
11828
11829 if (!args) SWIG_fail;
11830 swig_obj[0] = args;
11831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11832 if (!SWIG_IsOK(res1)) {
11833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11834 }
11835 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11836 {
11837 PyThreadState* __tstate = wxPyBeginAllowThreads();
11838 result = (char)(arg1)->Peek();
11839 wxPyEndAllowThreads(__tstate);
11840 if (PyErr_Occurred()) SWIG_fail;
11841 }
11842 resultobj = SWIG_From_char(static_cast< char >(result));
11843 return resultobj;
11844 fail:
11845 return NULL;
11846 }
11847
11848
11849 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11850 PyObject *resultobj = 0;
11851 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11852 char result;
11853 void *argp1 = 0 ;
11854 int res1 = 0 ;
11855 PyObject *swig_obj[1] ;
11856
11857 if (!args) SWIG_fail;
11858 swig_obj[0] = args;
11859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11860 if (!SWIG_IsOK(res1)) {
11861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11862 }
11863 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11864 {
11865 PyThreadState* __tstate = wxPyBeginAllowThreads();
11866 result = (char)(arg1)->GetC();
11867 wxPyEndAllowThreads(__tstate);
11868 if (PyErr_Occurred()) SWIG_fail;
11869 }
11870 resultobj = SWIG_From_char(static_cast< char >(result));
11871 return resultobj;
11872 fail:
11873 return NULL;
11874 }
11875
11876
11877 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11878 PyObject *resultobj = 0;
11879 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11880 size_t result;
11881 void *argp1 = 0 ;
11882 int res1 = 0 ;
11883 PyObject *swig_obj[1] ;
11884
11885 if (!args) SWIG_fail;
11886 swig_obj[0] = args;
11887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11888 if (!SWIG_IsOK(res1)) {
11889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11890 }
11891 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11892 {
11893 PyThreadState* __tstate = wxPyBeginAllowThreads();
11894 result = (size_t)(arg1)->LastRead();
11895 wxPyEndAllowThreads(__tstate);
11896 if (PyErr_Occurred()) SWIG_fail;
11897 }
11898 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11899 return resultobj;
11900 fail:
11901 return NULL;
11902 }
11903
11904
11905 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11906 PyObject *resultobj = 0;
11907 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11908 bool result;
11909 void *argp1 = 0 ;
11910 int res1 = 0 ;
11911 PyObject *swig_obj[1] ;
11912
11913 if (!args) SWIG_fail;
11914 swig_obj[0] = args;
11915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11916 if (!SWIG_IsOK(res1)) {
11917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11918 }
11919 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11920 {
11921 PyThreadState* __tstate = wxPyBeginAllowThreads();
11922 result = (bool)(arg1)->CanRead();
11923 wxPyEndAllowThreads(__tstate);
11924 if (PyErr_Occurred()) SWIG_fail;
11925 }
11926 {
11927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11928 }
11929 return resultobj;
11930 fail:
11931 return NULL;
11932 }
11933
11934
11935 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11936 PyObject *resultobj = 0;
11937 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11938 bool result;
11939 void *argp1 = 0 ;
11940 int res1 = 0 ;
11941 PyObject *swig_obj[1] ;
11942
11943 if (!args) SWIG_fail;
11944 swig_obj[0] = args;
11945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11946 if (!SWIG_IsOK(res1)) {
11947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11948 }
11949 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11950 {
11951 PyThreadState* __tstate = wxPyBeginAllowThreads();
11952 result = (bool)(arg1)->Eof();
11953 wxPyEndAllowThreads(__tstate);
11954 if (PyErr_Occurred()) SWIG_fail;
11955 }
11956 {
11957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11958 }
11959 return resultobj;
11960 fail:
11961 return NULL;
11962 }
11963
11964
11965 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11966 PyObject *resultobj = 0;
11967 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11968 char arg2 ;
11969 bool result;
11970 void *argp1 = 0 ;
11971 int res1 = 0 ;
11972 char val2 ;
11973 int ecode2 = 0 ;
11974 PyObject * obj0 = 0 ;
11975 PyObject * obj1 = 0 ;
11976 char * kwnames[] = {
11977 (char *) "self",(char *) "c", NULL
11978 };
11979
11980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
11981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11982 if (!SWIG_IsOK(res1)) {
11983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11984 }
11985 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11986 ecode2 = SWIG_AsVal_char(obj1, &val2);
11987 if (!SWIG_IsOK(ecode2)) {
11988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
11989 }
11990 arg2 = static_cast< char >(val2);
11991 {
11992 PyThreadState* __tstate = wxPyBeginAllowThreads();
11993 result = (bool)(arg1)->Ungetch(arg2);
11994 wxPyEndAllowThreads(__tstate);
11995 if (PyErr_Occurred()) SWIG_fail;
11996 }
11997 {
11998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11999 }
12000 return resultobj;
12001 fail:
12002 return NULL;
12003 }
12004
12005
12006 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12007 PyObject *resultobj = 0;
12008 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12009 long arg2 ;
12010 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
12011 long result;
12012 void *argp1 = 0 ;
12013 int res1 = 0 ;
12014 long val2 ;
12015 int ecode2 = 0 ;
12016 int val3 ;
12017 int ecode3 = 0 ;
12018 PyObject * obj0 = 0 ;
12019 PyObject * obj1 = 0 ;
12020 PyObject * obj2 = 0 ;
12021 char * kwnames[] = {
12022 (char *) "self",(char *) "pos",(char *) "mode", NULL
12023 };
12024
12025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12027 if (!SWIG_IsOK(res1)) {
12028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12029 }
12030 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12031 ecode2 = SWIG_AsVal_long(obj1, &val2);
12032 if (!SWIG_IsOK(ecode2)) {
12033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
12034 }
12035 arg2 = static_cast< long >(val2);
12036 if (obj2) {
12037 ecode3 = SWIG_AsVal_int(obj2, &val3);
12038 if (!SWIG_IsOK(ecode3)) {
12039 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
12040 }
12041 arg3 = static_cast< wxSeekMode >(val3);
12042 }
12043 {
12044 PyThreadState* __tstate = wxPyBeginAllowThreads();
12045 result = (long)(arg1)->SeekI(arg2,arg3);
12046 wxPyEndAllowThreads(__tstate);
12047 if (PyErr_Occurred()) SWIG_fail;
12048 }
12049 resultobj = SWIG_From_long(static_cast< long >(result));
12050 return resultobj;
12051 fail:
12052 return NULL;
12053 }
12054
12055
12056 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12057 PyObject *resultobj = 0;
12058 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12059 long result;
12060 void *argp1 = 0 ;
12061 int res1 = 0 ;
12062 PyObject *swig_obj[1] ;
12063
12064 if (!args) SWIG_fail;
12065 swig_obj[0] = args;
12066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12067 if (!SWIG_IsOK(res1)) {
12068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12069 }
12070 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12071 {
12072 PyThreadState* __tstate = wxPyBeginAllowThreads();
12073 result = (long)(arg1)->TellI();
12074 wxPyEndAllowThreads(__tstate);
12075 if (PyErr_Occurred()) SWIG_fail;
12076 }
12077 resultobj = SWIG_From_long(static_cast< long >(result));
12078 return resultobj;
12079 fail:
12080 return NULL;
12081 }
12082
12083
12084 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12085 PyObject *obj;
12086 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12087 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
12088 return SWIG_Py_Void();
12089 }
12090
12091 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12092 return SWIG_Python_InitShadowInstance(args);
12093 }
12094
12095 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12096 PyObject *resultobj = 0;
12097 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12098 PyObject *arg2 = (PyObject *) 0 ;
12099 void *argp1 = 0 ;
12100 int res1 = 0 ;
12101 PyObject * obj0 = 0 ;
12102 PyObject * obj1 = 0 ;
12103 char * kwnames[] = {
12104 (char *) "self",(char *) "obj", NULL
12105 };
12106
12107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
12108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12109 if (!SWIG_IsOK(res1)) {
12110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
12111 }
12112 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12113 arg2 = obj1;
12114 {
12115 PyThreadState* __tstate = wxPyBeginAllowThreads();
12116 wxOutputStream_write(arg1,arg2);
12117 wxPyEndAllowThreads(__tstate);
12118 if (PyErr_Occurred()) SWIG_fail;
12119 }
12120 resultobj = SWIG_Py_Void();
12121 return resultobj;
12122 fail:
12123 return NULL;
12124 }
12125
12126
12127 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12128 PyObject *resultobj = 0;
12129 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12130 size_t result;
12131 void *argp1 = 0 ;
12132 int res1 = 0 ;
12133 PyObject *swig_obj[1] ;
12134
12135 if (!args) SWIG_fail;
12136 swig_obj[0] = args;
12137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12138 if (!SWIG_IsOK(res1)) {
12139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
12140 }
12141 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12142 {
12143 PyThreadState* __tstate = wxPyBeginAllowThreads();
12144 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
12145 wxPyEndAllowThreads(__tstate);
12146 if (PyErr_Occurred()) SWIG_fail;
12147 }
12148 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12149 return resultobj;
12150 fail:
12151 return NULL;
12152 }
12153
12154
12155 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12156 PyObject *obj;
12157 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12158 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
12159 return SWIG_Py_Void();
12160 }
12161
12162 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12163 PyObject *resultobj = 0;
12164 wxInputStream *arg1 = (wxInputStream *) 0 ;
12165 wxString *arg2 = 0 ;
12166 wxString *arg3 = 0 ;
12167 wxString *arg4 = 0 ;
12168 wxDateTime arg5 ;
12169 wxFSFile *result = 0 ;
12170 wxPyInputStream *temp1 ;
12171 bool temp2 = false ;
12172 bool temp3 = false ;
12173 bool temp4 = false ;
12174 void *argp5 ;
12175 int res5 = 0 ;
12176 PyObject * obj0 = 0 ;
12177 PyObject * obj1 = 0 ;
12178 PyObject * obj2 = 0 ;
12179 PyObject * obj3 = 0 ;
12180 PyObject * obj4 = 0 ;
12181 char * kwnames[] = {
12182 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
12183 };
12184
12185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
12186 {
12187 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12188 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
12189 } else {
12190 PyErr_Clear(); // clear the failure of the wxPyConvert above
12191 arg1 = wxPyCBInputStream_create(obj0, true);
12192 if (arg1 == NULL) {
12193 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12194 SWIG_fail;
12195 }
12196 }
12197 }
12198 {
12199 arg2 = wxString_in_helper(obj1);
12200 if (arg2 == NULL) SWIG_fail;
12201 temp2 = true;
12202 }
12203 {
12204 arg3 = wxString_in_helper(obj2);
12205 if (arg3 == NULL) SWIG_fail;
12206 temp3 = true;
12207 }
12208 {
12209 arg4 = wxString_in_helper(obj3);
12210 if (arg4 == NULL) SWIG_fail;
12211 temp4 = true;
12212 }
12213 {
12214 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
12215 if (!SWIG_IsOK(res5)) {
12216 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12217 }
12218 if (!argp5) {
12219 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12220 } else {
12221 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
12222 arg5 = *temp;
12223 if (SWIG_IsNewObj(res5)) delete temp;
12224 }
12225 }
12226 {
12227 PyThreadState* __tstate = wxPyBeginAllowThreads();
12228 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
12229 wxPyEndAllowThreads(__tstate);
12230 if (PyErr_Occurred()) SWIG_fail;
12231 }
12232 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
12233 {
12234 if (temp2)
12235 delete arg2;
12236 }
12237 {
12238 if (temp3)
12239 delete arg3;
12240 }
12241 {
12242 if (temp4)
12243 delete arg4;
12244 }
12245 return resultobj;
12246 fail:
12247 {
12248 if (temp2)
12249 delete arg2;
12250 }
12251 {
12252 if (temp3)
12253 delete arg3;
12254 }
12255 {
12256 if (temp4)
12257 delete arg4;
12258 }
12259 return NULL;
12260 }
12261
12262
12263 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12264 PyObject *resultobj = 0;
12265 wxFSFile *arg1 = (wxFSFile *) 0 ;
12266 void *argp1 = 0 ;
12267 int res1 = 0 ;
12268 PyObject *swig_obj[1] ;
12269
12270 if (!args) SWIG_fail;
12271 swig_obj[0] = args;
12272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
12273 if (!SWIG_IsOK(res1)) {
12274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
12275 }
12276 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12277 {
12278 PyThreadState* __tstate = wxPyBeginAllowThreads();
12279 delete arg1;
12280
12281 wxPyEndAllowThreads(__tstate);
12282 if (PyErr_Occurred()) SWIG_fail;
12283 }
12284 resultobj = SWIG_Py_Void();
12285 return resultobj;
12286 fail:
12287 return NULL;
12288 }
12289
12290
12291 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12292 PyObject *resultobj = 0;
12293 wxFSFile *arg1 = (wxFSFile *) 0 ;
12294 wxInputStream *result = 0 ;
12295 void *argp1 = 0 ;
12296 int res1 = 0 ;
12297 PyObject *swig_obj[1] ;
12298
12299 if (!args) SWIG_fail;
12300 swig_obj[0] = args;
12301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12302 if (!SWIG_IsOK(res1)) {
12303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12304 }
12305 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12306 {
12307 PyThreadState* __tstate = wxPyBeginAllowThreads();
12308 result = (wxInputStream *)(arg1)->GetStream();
12309 wxPyEndAllowThreads(__tstate);
12310 if (PyErr_Occurred()) SWIG_fail;
12311 }
12312 {
12313 wxPyInputStream * _ptr = NULL;
12314
12315 if (result) {
12316 _ptr = new wxPyInputStream(result);
12317 }
12318 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
12319 }
12320 return resultobj;
12321 fail:
12322 return NULL;
12323 }
12324
12325
12326 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12327 PyObject *resultobj = 0;
12328 wxFSFile *arg1 = (wxFSFile *) 0 ;
12329 void *argp1 = 0 ;
12330 int res1 = 0 ;
12331 PyObject *swig_obj[1] ;
12332
12333 if (!args) SWIG_fail;
12334 swig_obj[0] = args;
12335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12336 if (!SWIG_IsOK(res1)) {
12337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12338 }
12339 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12340 {
12341 PyThreadState* __tstate = wxPyBeginAllowThreads();
12342 (arg1)->DetachStream();
12343 wxPyEndAllowThreads(__tstate);
12344 if (PyErr_Occurred()) SWIG_fail;
12345 }
12346 resultobj = SWIG_Py_Void();
12347 return resultobj;
12348 fail:
12349 return NULL;
12350 }
12351
12352
12353 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12354 PyObject *resultobj = 0;
12355 wxFSFile *arg1 = (wxFSFile *) 0 ;
12356 wxString *result = 0 ;
12357 void *argp1 = 0 ;
12358 int res1 = 0 ;
12359 PyObject *swig_obj[1] ;
12360
12361 if (!args) SWIG_fail;
12362 swig_obj[0] = args;
12363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12364 if (!SWIG_IsOK(res1)) {
12365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
12366 }
12367 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12368 {
12369 PyThreadState* __tstate = wxPyBeginAllowThreads();
12370 {
12371 wxString const &_result_ref = (arg1)->GetMimeType();
12372 result = (wxString *) &_result_ref;
12373 }
12374 wxPyEndAllowThreads(__tstate);
12375 if (PyErr_Occurred()) SWIG_fail;
12376 }
12377 {
12378 #if wxUSE_UNICODE
12379 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12380 #else
12381 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12382 #endif
12383 }
12384 return resultobj;
12385 fail:
12386 return NULL;
12387 }
12388
12389
12390 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12391 PyObject *resultobj = 0;
12392 wxFSFile *arg1 = (wxFSFile *) 0 ;
12393 wxString *result = 0 ;
12394 void *argp1 = 0 ;
12395 int res1 = 0 ;
12396 PyObject *swig_obj[1] ;
12397
12398 if (!args) SWIG_fail;
12399 swig_obj[0] = args;
12400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12401 if (!SWIG_IsOK(res1)) {
12402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
12403 }
12404 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12405 {
12406 PyThreadState* __tstate = wxPyBeginAllowThreads();
12407 {
12408 wxString const &_result_ref = (arg1)->GetLocation();
12409 result = (wxString *) &_result_ref;
12410 }
12411 wxPyEndAllowThreads(__tstate);
12412 if (PyErr_Occurred()) SWIG_fail;
12413 }
12414 {
12415 #if wxUSE_UNICODE
12416 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12417 #else
12418 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12419 #endif
12420 }
12421 return resultobj;
12422 fail:
12423 return NULL;
12424 }
12425
12426
12427 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12428 PyObject *resultobj = 0;
12429 wxFSFile *arg1 = (wxFSFile *) 0 ;
12430 wxString *result = 0 ;
12431 void *argp1 = 0 ;
12432 int res1 = 0 ;
12433 PyObject *swig_obj[1] ;
12434
12435 if (!args) SWIG_fail;
12436 swig_obj[0] = args;
12437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12438 if (!SWIG_IsOK(res1)) {
12439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
12440 }
12441 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12442 {
12443 PyThreadState* __tstate = wxPyBeginAllowThreads();
12444 {
12445 wxString const &_result_ref = (arg1)->GetAnchor();
12446 result = (wxString *) &_result_ref;
12447 }
12448 wxPyEndAllowThreads(__tstate);
12449 if (PyErr_Occurred()) SWIG_fail;
12450 }
12451 {
12452 #if wxUSE_UNICODE
12453 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12454 #else
12455 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12456 #endif
12457 }
12458 return resultobj;
12459 fail:
12460 return NULL;
12461 }
12462
12463
12464 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12465 PyObject *resultobj = 0;
12466 wxFSFile *arg1 = (wxFSFile *) 0 ;
12467 wxDateTime result;
12468 void *argp1 = 0 ;
12469 int res1 = 0 ;
12470 PyObject *swig_obj[1] ;
12471
12472 if (!args) SWIG_fail;
12473 swig_obj[0] = args;
12474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12475 if (!SWIG_IsOK(res1)) {
12476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
12477 }
12478 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12479 {
12480 PyThreadState* __tstate = wxPyBeginAllowThreads();
12481 result = (arg1)->GetModificationTime();
12482 wxPyEndAllowThreads(__tstate);
12483 if (PyErr_Occurred()) SWIG_fail;
12484 }
12485 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
12486 return resultobj;
12487 fail:
12488 return NULL;
12489 }
12490
12491
12492 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12493 PyObject *obj;
12494 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12495 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
12496 return SWIG_Py_Void();
12497 }
12498
12499 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12500 return SWIG_Python_InitShadowInstance(args);
12501 }
12502
12503 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12504 PyObject *resultobj = 0;
12505 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
12506 void *argp1 = 0 ;
12507 int res1 = 0 ;
12508 PyObject *swig_obj[1] ;
12509
12510 if (!args) SWIG_fail;
12511 swig_obj[0] = args;
12512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
12513 if (!SWIG_IsOK(res1)) {
12514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
12515 }
12516 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
12517 {
12518 PyThreadState* __tstate = wxPyBeginAllowThreads();
12519 delete arg1;
12520
12521 wxPyEndAllowThreads(__tstate);
12522 if (PyErr_Occurred()) SWIG_fail;
12523 }
12524 resultobj = SWIG_Py_Void();
12525 return resultobj;
12526 fail:
12527 return NULL;
12528 }
12529
12530
12531 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12532 PyObject *obj;
12533 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12534 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
12535 return SWIG_Py_Void();
12536 }
12537
12538 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12539 PyObject *resultobj = 0;
12540 wxPyFileSystemHandler *result = 0 ;
12541
12542 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
12543 {
12544 PyThreadState* __tstate = wxPyBeginAllowThreads();
12545 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
12546 wxPyEndAllowThreads(__tstate);
12547 if (PyErr_Occurred()) SWIG_fail;
12548 }
12549 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
12550 return resultobj;
12551 fail:
12552 return NULL;
12553 }
12554
12555
12556 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12557 PyObject *resultobj = 0;
12558 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12559 PyObject *arg2 = (PyObject *) 0 ;
12560 PyObject *arg3 = (PyObject *) 0 ;
12561 void *argp1 = 0 ;
12562 int res1 = 0 ;
12563 PyObject * obj0 = 0 ;
12564 PyObject * obj1 = 0 ;
12565 PyObject * obj2 = 0 ;
12566 char * kwnames[] = {
12567 (char *) "self",(char *) "self",(char *) "_class", NULL
12568 };
12569
12570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12572 if (!SWIG_IsOK(res1)) {
12573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12574 }
12575 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12576 arg2 = obj1;
12577 arg3 = obj2;
12578 {
12579 PyThreadState* __tstate = wxPyBeginAllowThreads();
12580 (arg1)->_setCallbackInfo(arg2,arg3);
12581 wxPyEndAllowThreads(__tstate);
12582 if (PyErr_Occurred()) SWIG_fail;
12583 }
12584 resultobj = SWIG_Py_Void();
12585 return resultobj;
12586 fail:
12587 return NULL;
12588 }
12589
12590
12591 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12592 PyObject *resultobj = 0;
12593 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12594 wxString *arg2 = 0 ;
12595 bool result;
12596 void *argp1 = 0 ;
12597 int res1 = 0 ;
12598 bool temp2 = false ;
12599 PyObject * obj0 = 0 ;
12600 PyObject * obj1 = 0 ;
12601 char * kwnames[] = {
12602 (char *) "self",(char *) "location", NULL
12603 };
12604
12605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
12606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12607 if (!SWIG_IsOK(res1)) {
12608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12609 }
12610 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12611 {
12612 arg2 = wxString_in_helper(obj1);
12613 if (arg2 == NULL) SWIG_fail;
12614 temp2 = true;
12615 }
12616 {
12617 PyThreadState* __tstate = wxPyBeginAllowThreads();
12618 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
12619 wxPyEndAllowThreads(__tstate);
12620 if (PyErr_Occurred()) SWIG_fail;
12621 }
12622 {
12623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12624 }
12625 {
12626 if (temp2)
12627 delete arg2;
12628 }
12629 return resultobj;
12630 fail:
12631 {
12632 if (temp2)
12633 delete arg2;
12634 }
12635 return NULL;
12636 }
12637
12638
12639 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12640 PyObject *resultobj = 0;
12641 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12642 wxFileSystem *arg2 = 0 ;
12643 wxString *arg3 = 0 ;
12644 wxFSFile *result = 0 ;
12645 void *argp1 = 0 ;
12646 int res1 = 0 ;
12647 void *argp2 = 0 ;
12648 int res2 = 0 ;
12649 bool temp3 = false ;
12650 PyObject * obj0 = 0 ;
12651 PyObject * obj1 = 0 ;
12652 PyObject * obj2 = 0 ;
12653 char * kwnames[] = {
12654 (char *) "self",(char *) "fs",(char *) "location", NULL
12655 };
12656
12657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12659 if (!SWIG_IsOK(res1)) {
12660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12661 }
12662 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12663 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
12664 if (!SWIG_IsOK(res2)) {
12665 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12666 }
12667 if (!argp2) {
12668 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12669 }
12670 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
12671 {
12672 arg3 = wxString_in_helper(obj2);
12673 if (arg3 == NULL) SWIG_fail;
12674 temp3 = true;
12675 }
12676 {
12677 PyThreadState* __tstate = wxPyBeginAllowThreads();
12678 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
12679 wxPyEndAllowThreads(__tstate);
12680 if (PyErr_Occurred()) SWIG_fail;
12681 }
12682 {
12683 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
12684 }
12685 {
12686 if (temp3)
12687 delete arg3;
12688 }
12689 return resultobj;
12690 fail:
12691 {
12692 if (temp3)
12693 delete arg3;
12694 }
12695 return NULL;
12696 }
12697
12698
12699 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12700 PyObject *resultobj = 0;
12701 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12702 wxString *arg2 = 0 ;
12703 int arg3 = (int) 0 ;
12704 wxString result;
12705 void *argp1 = 0 ;
12706 int res1 = 0 ;
12707 bool temp2 = false ;
12708 int val3 ;
12709 int ecode3 = 0 ;
12710 PyObject * obj0 = 0 ;
12711 PyObject * obj1 = 0 ;
12712 PyObject * obj2 = 0 ;
12713 char * kwnames[] = {
12714 (char *) "self",(char *) "spec",(char *) "flags", NULL
12715 };
12716
12717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12719 if (!SWIG_IsOK(res1)) {
12720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12721 }
12722 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12723 {
12724 arg2 = wxString_in_helper(obj1);
12725 if (arg2 == NULL) SWIG_fail;
12726 temp2 = true;
12727 }
12728 if (obj2) {
12729 ecode3 = SWIG_AsVal_int(obj2, &val3);
12730 if (!SWIG_IsOK(ecode3)) {
12731 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
12732 }
12733 arg3 = static_cast< int >(val3);
12734 }
12735 {
12736 PyThreadState* __tstate = wxPyBeginAllowThreads();
12737 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
12738 wxPyEndAllowThreads(__tstate);
12739 if (PyErr_Occurred()) SWIG_fail;
12740 }
12741 {
12742 #if wxUSE_UNICODE
12743 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12744 #else
12745 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12746 #endif
12747 }
12748 {
12749 if (temp2)
12750 delete arg2;
12751 }
12752 return resultobj;
12753 fail:
12754 {
12755 if (temp2)
12756 delete arg2;
12757 }
12758 return NULL;
12759 }
12760
12761
12762 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12763 PyObject *resultobj = 0;
12764 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12765 wxString result;
12766 void *argp1 = 0 ;
12767 int res1 = 0 ;
12768 PyObject *swig_obj[1] ;
12769
12770 if (!args) SWIG_fail;
12771 swig_obj[0] = args;
12772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12773 if (!SWIG_IsOK(res1)) {
12774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12775 }
12776 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12777 {
12778 PyThreadState* __tstate = wxPyBeginAllowThreads();
12779 result = (arg1)->FindNext();
12780 wxPyEndAllowThreads(__tstate);
12781 if (PyErr_Occurred()) SWIG_fail;
12782 }
12783 {
12784 #if wxUSE_UNICODE
12785 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12786 #else
12787 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12788 #endif
12789 }
12790 return resultobj;
12791 fail:
12792 return NULL;
12793 }
12794
12795
12796 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12797 PyObject *resultobj = 0;
12798 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12799 wxString *arg2 = 0 ;
12800 wxString result;
12801 void *argp1 = 0 ;
12802 int res1 = 0 ;
12803 bool temp2 = false ;
12804 PyObject * obj0 = 0 ;
12805 PyObject * obj1 = 0 ;
12806 char * kwnames[] = {
12807 (char *) "self",(char *) "location", NULL
12808 };
12809
12810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
12811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12812 if (!SWIG_IsOK(res1)) {
12813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12814 }
12815 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12816 {
12817 arg2 = wxString_in_helper(obj1);
12818 if (arg2 == NULL) SWIG_fail;
12819 temp2 = true;
12820 }
12821 {
12822 PyThreadState* __tstate = wxPyBeginAllowThreads();
12823 result = (arg1)->GetProtocol((wxString const &)*arg2);
12824 wxPyEndAllowThreads(__tstate);
12825 if (PyErr_Occurred()) SWIG_fail;
12826 }
12827 {
12828 #if wxUSE_UNICODE
12829 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12830 #else
12831 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12832 #endif
12833 }
12834 {
12835 if (temp2)
12836 delete arg2;
12837 }
12838 return resultobj;
12839 fail:
12840 {
12841 if (temp2)
12842 delete arg2;
12843 }
12844 return NULL;
12845 }
12846
12847
12848 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12849 PyObject *resultobj = 0;
12850 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12851 wxString *arg2 = 0 ;
12852 wxString result;
12853 void *argp1 = 0 ;
12854 int res1 = 0 ;
12855 bool temp2 = false ;
12856 PyObject * obj0 = 0 ;
12857 PyObject * obj1 = 0 ;
12858 char * kwnames[] = {
12859 (char *) "self",(char *) "location", NULL
12860 };
12861
12862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12864 if (!SWIG_IsOK(res1)) {
12865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12866 }
12867 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12868 {
12869 arg2 = wxString_in_helper(obj1);
12870 if (arg2 == NULL) SWIG_fail;
12871 temp2 = true;
12872 }
12873 {
12874 PyThreadState* __tstate = wxPyBeginAllowThreads();
12875 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
12876 wxPyEndAllowThreads(__tstate);
12877 if (PyErr_Occurred()) SWIG_fail;
12878 }
12879 {
12880 #if wxUSE_UNICODE
12881 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12882 #else
12883 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12884 #endif
12885 }
12886 {
12887 if (temp2)
12888 delete arg2;
12889 }
12890 return resultobj;
12891 fail:
12892 {
12893 if (temp2)
12894 delete arg2;
12895 }
12896 return NULL;
12897 }
12898
12899
12900 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12901 PyObject *resultobj = 0;
12902 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12903 wxString *arg2 = 0 ;
12904 wxString result;
12905 void *argp1 = 0 ;
12906 int res1 = 0 ;
12907 bool temp2 = false ;
12908 PyObject * obj0 = 0 ;
12909 PyObject * obj1 = 0 ;
12910 char * kwnames[] = {
12911 (char *) "self",(char *) "location", NULL
12912 };
12913
12914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
12915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12916 if (!SWIG_IsOK(res1)) {
12917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12918 }
12919 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12920 {
12921 arg2 = wxString_in_helper(obj1);
12922 if (arg2 == NULL) SWIG_fail;
12923 temp2 = true;
12924 }
12925 {
12926 PyThreadState* __tstate = wxPyBeginAllowThreads();
12927 result = (arg1)->GetAnchor((wxString const &)*arg2);
12928 wxPyEndAllowThreads(__tstate);
12929 if (PyErr_Occurred()) SWIG_fail;
12930 }
12931 {
12932 #if wxUSE_UNICODE
12933 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12934 #else
12935 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12936 #endif
12937 }
12938 {
12939 if (temp2)
12940 delete arg2;
12941 }
12942 return resultobj;
12943 fail:
12944 {
12945 if (temp2)
12946 delete arg2;
12947 }
12948 return NULL;
12949 }
12950
12951
12952 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12953 PyObject *resultobj = 0;
12954 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12955 wxString *arg2 = 0 ;
12956 wxString result;
12957 void *argp1 = 0 ;
12958 int res1 = 0 ;
12959 bool temp2 = false ;
12960 PyObject * obj0 = 0 ;
12961 PyObject * obj1 = 0 ;
12962 char * kwnames[] = {
12963 (char *) "self",(char *) "location", NULL
12964 };
12965
12966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12968 if (!SWIG_IsOK(res1)) {
12969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12970 }
12971 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12972 {
12973 arg2 = wxString_in_helper(obj1);
12974 if (arg2 == NULL) SWIG_fail;
12975 temp2 = true;
12976 }
12977 {
12978 PyThreadState* __tstate = wxPyBeginAllowThreads();
12979 result = (arg1)->GetRightLocation((wxString const &)*arg2);
12980 wxPyEndAllowThreads(__tstate);
12981 if (PyErr_Occurred()) SWIG_fail;
12982 }
12983 {
12984 #if wxUSE_UNICODE
12985 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12986 #else
12987 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12988 #endif
12989 }
12990 {
12991 if (temp2)
12992 delete arg2;
12993 }
12994 return resultobj;
12995 fail:
12996 {
12997 if (temp2)
12998 delete arg2;
12999 }
13000 return NULL;
13001 }
13002
13003
13004 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13005 PyObject *resultobj = 0;
13006 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13007 wxString *arg2 = 0 ;
13008 wxString result;
13009 void *argp1 = 0 ;
13010 int res1 = 0 ;
13011 bool temp2 = false ;
13012 PyObject * obj0 = 0 ;
13013 PyObject * obj1 = 0 ;
13014 char * kwnames[] = {
13015 (char *) "self",(char *) "location", NULL
13016 };
13017
13018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
13019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13020 if (!SWIG_IsOK(res1)) {
13021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13022 }
13023 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13024 {
13025 arg2 = wxString_in_helper(obj1);
13026 if (arg2 == NULL) SWIG_fail;
13027 temp2 = true;
13028 }
13029 {
13030 PyThreadState* __tstate = wxPyBeginAllowThreads();
13031 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
13032 wxPyEndAllowThreads(__tstate);
13033 if (PyErr_Occurred()) SWIG_fail;
13034 }
13035 {
13036 #if wxUSE_UNICODE
13037 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13038 #else
13039 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13040 #endif
13041 }
13042 {
13043 if (temp2)
13044 delete arg2;
13045 }
13046 return resultobj;
13047 fail:
13048 {
13049 if (temp2)
13050 delete arg2;
13051 }
13052 return NULL;
13053 }
13054
13055
13056 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13057 PyObject *obj;
13058 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13059 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
13060 return SWIG_Py_Void();
13061 }
13062
13063 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13064 return SWIG_Python_InitShadowInstance(args);
13065 }
13066
13067 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13068 PyObject *resultobj = 0;
13069 wxFileSystem *result = 0 ;
13070
13071 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
13072 {
13073 PyThreadState* __tstate = wxPyBeginAllowThreads();
13074 result = (wxFileSystem *)new wxFileSystem();
13075 wxPyEndAllowThreads(__tstate);
13076 if (PyErr_Occurred()) SWIG_fail;
13077 }
13078 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystem, SWIG_POINTER_NEW | 0 );
13079 return resultobj;
13080 fail:
13081 return NULL;
13082 }
13083
13084
13085 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13086 PyObject *resultobj = 0;
13087 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13088 void *argp1 = 0 ;
13089 int res1 = 0 ;
13090 PyObject *swig_obj[1] ;
13091
13092 if (!args) SWIG_fail;
13093 swig_obj[0] = args;
13094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
13095 if (!SWIG_IsOK(res1)) {
13096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13097 }
13098 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13099 {
13100 PyThreadState* __tstate = wxPyBeginAllowThreads();
13101 delete arg1;
13102
13103 wxPyEndAllowThreads(__tstate);
13104 if (PyErr_Occurred()) SWIG_fail;
13105 }
13106 resultobj = SWIG_Py_Void();
13107 return resultobj;
13108 fail:
13109 return NULL;
13110 }
13111
13112
13113 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13114 PyObject *resultobj = 0;
13115 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13116 wxString *arg2 = 0 ;
13117 bool arg3 = (bool) false ;
13118 void *argp1 = 0 ;
13119 int res1 = 0 ;
13120 bool temp2 = false ;
13121 bool val3 ;
13122 int ecode3 = 0 ;
13123 PyObject * obj0 = 0 ;
13124 PyObject * obj1 = 0 ;
13125 PyObject * obj2 = 0 ;
13126 char * kwnames[] = {
13127 (char *) "self",(char *) "location",(char *) "is_dir", NULL
13128 };
13129
13130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13132 if (!SWIG_IsOK(res1)) {
13133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13134 }
13135 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13136 {
13137 arg2 = wxString_in_helper(obj1);
13138 if (arg2 == NULL) SWIG_fail;
13139 temp2 = true;
13140 }
13141 if (obj2) {
13142 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13143 if (!SWIG_IsOK(ecode3)) {
13144 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
13145 }
13146 arg3 = static_cast< bool >(val3);
13147 }
13148 {
13149 PyThreadState* __tstate = wxPyBeginAllowThreads();
13150 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
13151 wxPyEndAllowThreads(__tstate);
13152 if (PyErr_Occurred()) SWIG_fail;
13153 }
13154 resultobj = SWIG_Py_Void();
13155 {
13156 if (temp2)
13157 delete arg2;
13158 }
13159 return resultobj;
13160 fail:
13161 {
13162 if (temp2)
13163 delete arg2;
13164 }
13165 return NULL;
13166 }
13167
13168
13169 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13170 PyObject *resultobj = 0;
13171 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13172 wxString result;
13173 void *argp1 = 0 ;
13174 int res1 = 0 ;
13175 PyObject *swig_obj[1] ;
13176
13177 if (!args) SWIG_fail;
13178 swig_obj[0] = args;
13179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13180 if (!SWIG_IsOK(res1)) {
13181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13182 }
13183 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13184 {
13185 PyThreadState* __tstate = wxPyBeginAllowThreads();
13186 result = (arg1)->GetPath();
13187 wxPyEndAllowThreads(__tstate);
13188 if (PyErr_Occurred()) SWIG_fail;
13189 }
13190 {
13191 #if wxUSE_UNICODE
13192 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13193 #else
13194 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13195 #endif
13196 }
13197 return resultobj;
13198 fail:
13199 return NULL;
13200 }
13201
13202
13203 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13204 PyObject *resultobj = 0;
13205 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13206 wxString *arg2 = 0 ;
13207 wxFSFile *result = 0 ;
13208 void *argp1 = 0 ;
13209 int res1 = 0 ;
13210 bool temp2 = false ;
13211 PyObject * obj0 = 0 ;
13212 PyObject * obj1 = 0 ;
13213 char * kwnames[] = {
13214 (char *) "self",(char *) "location", NULL
13215 };
13216
13217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
13218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13219 if (!SWIG_IsOK(res1)) {
13220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13221 }
13222 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13223 {
13224 arg2 = wxString_in_helper(obj1);
13225 if (arg2 == NULL) SWIG_fail;
13226 temp2 = true;
13227 }
13228 {
13229 PyThreadState* __tstate = wxPyBeginAllowThreads();
13230 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
13231 wxPyEndAllowThreads(__tstate);
13232 if (PyErr_Occurred()) SWIG_fail;
13233 }
13234 {
13235 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13236 }
13237 {
13238 if (temp2)
13239 delete arg2;
13240 }
13241 return resultobj;
13242 fail:
13243 {
13244 if (temp2)
13245 delete arg2;
13246 }
13247 return NULL;
13248 }
13249
13250
13251 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13252 PyObject *resultobj = 0;
13253 wxFileSystem *arg1 = (wxFileSystem *) 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:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13271 if (!SWIG_IsOK(res1)) {
13272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13273 }
13274 arg1 = reinterpret_cast< wxFileSystem * >(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 '" "FileSystem_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_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13315 PyObject *resultobj = 0;
13316 wxFileSystem *arg1 = (wxFileSystem *) 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_wxFileSystem, 0 | 0 );
13325 if (!SWIG_IsOK(res1)) {
13326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13327 }
13328 arg1 = reinterpret_cast< wxFileSystem * >(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_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13349 PyObject *resultobj = 0;
13350 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13351 int res1 = 0 ;
13352 PyObject * obj0 = 0 ;
13353 char * kwnames[] = {
13354 (char *) "handler", NULL
13355 };
13356
13357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
13358 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
13359 if (!SWIG_IsOK(res1)) {
13360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13361 }
13362 {
13363 PyThreadState* __tstate = wxPyBeginAllowThreads();
13364 wxFileSystem::AddHandler(arg1);
13365 wxPyEndAllowThreads(__tstate);
13366 if (PyErr_Occurred()) SWIG_fail;
13367 }
13368 resultobj = SWIG_Py_Void();
13369 return resultobj;
13370 fail:
13371 return NULL;
13372 }
13373
13374
13375 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13376 PyObject *resultobj = 0;
13377 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13378 wxFileSystemHandler *result = 0 ;
13379 void *argp1 = 0 ;
13380 int res1 = 0 ;
13381 PyObject * obj0 = 0 ;
13382 char * kwnames[] = {
13383 (char *) "handler", NULL
13384 };
13385
13386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
13387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
13388 if (!SWIG_IsOK(res1)) {
13389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13390 }
13391 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
13392 {
13393 PyThreadState* __tstate = wxPyBeginAllowThreads();
13394 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
13395 wxPyEndAllowThreads(__tstate);
13396 if (PyErr_Occurred()) SWIG_fail;
13397 }
13398 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
13399 return resultobj;
13400 fail:
13401 return NULL;
13402 }
13403
13404
13405 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13406 PyObject *resultobj = 0;
13407
13408 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
13409 {
13410 PyThreadState* __tstate = wxPyBeginAllowThreads();
13411 wxFileSystem::CleanUpHandlers();
13412 wxPyEndAllowThreads(__tstate);
13413 if (PyErr_Occurred()) SWIG_fail;
13414 }
13415 resultobj = SWIG_Py_Void();
13416 return resultobj;
13417 fail:
13418 return NULL;
13419 }
13420
13421
13422 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13423 PyObject *resultobj = 0;
13424 wxString *arg1 = 0 ;
13425 wxString result;
13426 bool temp1 = false ;
13427 PyObject * obj0 = 0 ;
13428 char * kwnames[] = {
13429 (char *) "filename", NULL
13430 };
13431
13432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
13433 {
13434 arg1 = wxString_in_helper(obj0);
13435 if (arg1 == NULL) SWIG_fail;
13436 temp1 = true;
13437 }
13438 {
13439 PyThreadState* __tstate = wxPyBeginAllowThreads();
13440 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
13441 wxPyEndAllowThreads(__tstate);
13442 if (PyErr_Occurred()) SWIG_fail;
13443 }
13444 {
13445 #if wxUSE_UNICODE
13446 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13447 #else
13448 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13449 #endif
13450 }
13451 {
13452 if (temp1)
13453 delete arg1;
13454 }
13455 return resultobj;
13456 fail:
13457 {
13458 if (temp1)
13459 delete arg1;
13460 }
13461 return NULL;
13462 }
13463
13464
13465 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13466 PyObject *resultobj = 0;
13467 wxString *arg1 = 0 ;
13468 wxString result;
13469 bool temp1 = false ;
13470 PyObject * obj0 = 0 ;
13471 char * kwnames[] = {
13472 (char *) "url", NULL
13473 };
13474
13475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
13476 {
13477 arg1 = wxString_in_helper(obj0);
13478 if (arg1 == NULL) SWIG_fail;
13479 temp1 = true;
13480 }
13481 {
13482 PyThreadState* __tstate = wxPyBeginAllowThreads();
13483 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
13484 wxPyEndAllowThreads(__tstate);
13485 if (PyErr_Occurred()) SWIG_fail;
13486 }
13487 {
13488 #if wxUSE_UNICODE
13489 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13490 #else
13491 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13492 #endif
13493 }
13494 {
13495 if (temp1)
13496 delete arg1;
13497 }
13498 return resultobj;
13499 fail:
13500 {
13501 if (temp1)
13502 delete arg1;
13503 }
13504 return NULL;
13505 }
13506
13507
13508 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13509 PyObject *obj;
13510 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13511 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
13512 return SWIG_Py_Void();
13513 }
13514
13515 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13516 return SWIG_Python_InitShadowInstance(args);
13517 }
13518
13519 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13520 PyObject *resultobj = 0;
13521 wxInternetFSHandler *result = 0 ;
13522
13523 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
13524 {
13525 PyThreadState* __tstate = wxPyBeginAllowThreads();
13526 result = (wxInternetFSHandler *)new wxInternetFSHandler();
13527 wxPyEndAllowThreads(__tstate);
13528 if (PyErr_Occurred()) SWIG_fail;
13529 }
13530 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
13531 return resultobj;
13532 fail:
13533 return NULL;
13534 }
13535
13536
13537 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13538 PyObject *resultobj = 0;
13539 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13540 wxString *arg2 = 0 ;
13541 bool result;
13542 void *argp1 = 0 ;
13543 int res1 = 0 ;
13544 bool temp2 = false ;
13545 PyObject * obj0 = 0 ;
13546 PyObject * obj1 = 0 ;
13547 char * kwnames[] = {
13548 (char *) "self",(char *) "location", NULL
13549 };
13550
13551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13553 if (!SWIG_IsOK(res1)) {
13554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13555 }
13556 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13557 {
13558 arg2 = wxString_in_helper(obj1);
13559 if (arg2 == NULL) SWIG_fail;
13560 temp2 = true;
13561 }
13562 {
13563 PyThreadState* __tstate = wxPyBeginAllowThreads();
13564 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13565 wxPyEndAllowThreads(__tstate);
13566 if (PyErr_Occurred()) SWIG_fail;
13567 }
13568 {
13569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13570 }
13571 {
13572 if (temp2)
13573 delete arg2;
13574 }
13575 return resultobj;
13576 fail:
13577 {
13578 if (temp2)
13579 delete arg2;
13580 }
13581 return NULL;
13582 }
13583
13584
13585 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13586 PyObject *resultobj = 0;
13587 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13588 wxFileSystem *arg2 = 0 ;
13589 wxString *arg3 = 0 ;
13590 wxFSFile *result = 0 ;
13591 void *argp1 = 0 ;
13592 int res1 = 0 ;
13593 void *argp2 = 0 ;
13594 int res2 = 0 ;
13595 bool temp3 = false ;
13596 PyObject * obj0 = 0 ;
13597 PyObject * obj1 = 0 ;
13598 PyObject * obj2 = 0 ;
13599 char * kwnames[] = {
13600 (char *) "self",(char *) "fs",(char *) "location", NULL
13601 };
13602
13603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13605 if (!SWIG_IsOK(res1)) {
13606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13607 }
13608 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13609 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13610 if (!SWIG_IsOK(res2)) {
13611 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13612 }
13613 if (!argp2) {
13614 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13615 }
13616 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13617 {
13618 arg3 = wxString_in_helper(obj2);
13619 if (arg3 == NULL) SWIG_fail;
13620 temp3 = true;
13621 }
13622 {
13623 PyThreadState* __tstate = wxPyBeginAllowThreads();
13624 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13625 wxPyEndAllowThreads(__tstate);
13626 if (PyErr_Occurred()) SWIG_fail;
13627 }
13628 {
13629 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13630 }
13631 {
13632 if (temp3)
13633 delete arg3;
13634 }
13635 return resultobj;
13636 fail:
13637 {
13638 if (temp3)
13639 delete arg3;
13640 }
13641 return NULL;
13642 }
13643
13644
13645 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13646 PyObject *obj;
13647 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13648 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
13649 return SWIG_Py_Void();
13650 }
13651
13652 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13653 return SWIG_Python_InitShadowInstance(args);
13654 }
13655
13656 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13657 PyObject *resultobj = 0;
13658 wxZipFSHandler *result = 0 ;
13659
13660 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
13661 {
13662 PyThreadState* __tstate = wxPyBeginAllowThreads();
13663 result = (wxZipFSHandler *)new wxZipFSHandler();
13664 wxPyEndAllowThreads(__tstate);
13665 if (PyErr_Occurred()) SWIG_fail;
13666 }
13667 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
13668 return resultobj;
13669 fail:
13670 return NULL;
13671 }
13672
13673
13674 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13675 PyObject *resultobj = 0;
13676 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13677 wxString *arg2 = 0 ;
13678 bool result;
13679 void *argp1 = 0 ;
13680 int res1 = 0 ;
13681 bool temp2 = false ;
13682 PyObject * obj0 = 0 ;
13683 PyObject * obj1 = 0 ;
13684 char * kwnames[] = {
13685 (char *) "self",(char *) "location", NULL
13686 };
13687
13688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13690 if (!SWIG_IsOK(res1)) {
13691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13692 }
13693 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13694 {
13695 arg2 = wxString_in_helper(obj1);
13696 if (arg2 == NULL) SWIG_fail;
13697 temp2 = true;
13698 }
13699 {
13700 PyThreadState* __tstate = wxPyBeginAllowThreads();
13701 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13702 wxPyEndAllowThreads(__tstate);
13703 if (PyErr_Occurred()) SWIG_fail;
13704 }
13705 {
13706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13707 }
13708 {
13709 if (temp2)
13710 delete arg2;
13711 }
13712 return resultobj;
13713 fail:
13714 {
13715 if (temp2)
13716 delete arg2;
13717 }
13718 return NULL;
13719 }
13720
13721
13722 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13723 PyObject *resultobj = 0;
13724 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13725 wxFileSystem *arg2 = 0 ;
13726 wxString *arg3 = 0 ;
13727 wxFSFile *result = 0 ;
13728 void *argp1 = 0 ;
13729 int res1 = 0 ;
13730 void *argp2 = 0 ;
13731 int res2 = 0 ;
13732 bool temp3 = false ;
13733 PyObject * obj0 = 0 ;
13734 PyObject * obj1 = 0 ;
13735 PyObject * obj2 = 0 ;
13736 char * kwnames[] = {
13737 (char *) "self",(char *) "fs",(char *) "location", NULL
13738 };
13739
13740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13742 if (!SWIG_IsOK(res1)) {
13743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13744 }
13745 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13746 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13747 if (!SWIG_IsOK(res2)) {
13748 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13749 }
13750 if (!argp2) {
13751 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13752 }
13753 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13754 {
13755 arg3 = wxString_in_helper(obj2);
13756 if (arg3 == NULL) SWIG_fail;
13757 temp3 = true;
13758 }
13759 {
13760 PyThreadState* __tstate = wxPyBeginAllowThreads();
13761 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13762 wxPyEndAllowThreads(__tstate);
13763 if (PyErr_Occurred()) SWIG_fail;
13764 }
13765 {
13766 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13767 }
13768 {
13769 if (temp3)
13770 delete arg3;
13771 }
13772 return resultobj;
13773 fail:
13774 {
13775 if (temp3)
13776 delete arg3;
13777 }
13778 return NULL;
13779 }
13780
13781
13782 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13783 PyObject *resultobj = 0;
13784 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13785 wxString *arg2 = 0 ;
13786 int arg3 = (int) 0 ;
13787 wxString result;
13788 void *argp1 = 0 ;
13789 int res1 = 0 ;
13790 bool temp2 = false ;
13791 int val3 ;
13792 int ecode3 = 0 ;
13793 PyObject * obj0 = 0 ;
13794 PyObject * obj1 = 0 ;
13795 PyObject * obj2 = 0 ;
13796 char * kwnames[] = {
13797 (char *) "self",(char *) "spec",(char *) "flags", NULL
13798 };
13799
13800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13802 if (!SWIG_IsOK(res1)) {
13803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13804 }
13805 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13806 {
13807 arg2 = wxString_in_helper(obj1);
13808 if (arg2 == NULL) SWIG_fail;
13809 temp2 = true;
13810 }
13811 if (obj2) {
13812 ecode3 = SWIG_AsVal_int(obj2, &val3);
13813 if (!SWIG_IsOK(ecode3)) {
13814 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
13815 }
13816 arg3 = static_cast< int >(val3);
13817 }
13818 {
13819 PyThreadState* __tstate = wxPyBeginAllowThreads();
13820 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13821 wxPyEndAllowThreads(__tstate);
13822 if (PyErr_Occurred()) SWIG_fail;
13823 }
13824 {
13825 #if wxUSE_UNICODE
13826 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13827 #else
13828 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13829 #endif
13830 }
13831 {
13832 if (temp2)
13833 delete arg2;
13834 }
13835 return resultobj;
13836 fail:
13837 {
13838 if (temp2)
13839 delete arg2;
13840 }
13841 return NULL;
13842 }
13843
13844
13845 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13846 PyObject *resultobj = 0;
13847 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13848 wxString result;
13849 void *argp1 = 0 ;
13850 int res1 = 0 ;
13851 PyObject *swig_obj[1] ;
13852
13853 if (!args) SWIG_fail;
13854 swig_obj[0] = args;
13855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13856 if (!SWIG_IsOK(res1)) {
13857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13858 }
13859 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13860 {
13861 PyThreadState* __tstate = wxPyBeginAllowThreads();
13862 result = (arg1)->FindNext();
13863 wxPyEndAllowThreads(__tstate);
13864 if (PyErr_Occurred()) SWIG_fail;
13865 }
13866 {
13867 #if wxUSE_UNICODE
13868 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13869 #else
13870 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13871 #endif
13872 }
13873 return resultobj;
13874 fail:
13875 return NULL;
13876 }
13877
13878
13879 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13880 PyObject *obj;
13881 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13882 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
13883 return SWIG_Py_Void();
13884 }
13885
13886 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13887 return SWIG_Python_InitShadowInstance(args);
13888 }
13889
13890 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13891 PyObject *resultobj = 0;
13892 wxString *arg1 = 0 ;
13893 wxImage *arg2 = 0 ;
13894 long arg3 ;
13895 bool temp1 = false ;
13896 void *argp2 = 0 ;
13897 int res2 = 0 ;
13898 long val3 ;
13899 int ecode3 = 0 ;
13900 PyObject * obj0 = 0 ;
13901 PyObject * obj1 = 0 ;
13902 PyObject * obj2 = 0 ;
13903 char * kwnames[] = {
13904 (char *) "filename",(char *) "image",(char *) "type", NULL
13905 };
13906
13907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13908 {
13909 arg1 = wxString_in_helper(obj0);
13910 if (arg1 == NULL) SWIG_fail;
13911 temp1 = true;
13912 }
13913 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
13914 if (!SWIG_IsOK(res2)) {
13915 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13916 }
13917 if (!argp2) {
13918 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13919 }
13920 arg2 = reinterpret_cast< wxImage * >(argp2);
13921 ecode3 = SWIG_AsVal_long(obj2, &val3);
13922 if (!SWIG_IsOK(ecode3)) {
13923 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
13924 }
13925 arg3 = static_cast< long >(val3);
13926 {
13927 PyThreadState* __tstate = wxPyBeginAllowThreads();
13928 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
13929 wxPyEndAllowThreads(__tstate);
13930 if (PyErr_Occurred()) SWIG_fail;
13931 }
13932 resultobj = SWIG_Py_Void();
13933 {
13934 if (temp1)
13935 delete arg1;
13936 }
13937 return resultobj;
13938 fail:
13939 {
13940 if (temp1)
13941 delete arg1;
13942 }
13943 return NULL;
13944 }
13945
13946
13947 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13948 PyObject *resultobj = 0;
13949 wxString *arg1 = 0 ;
13950 wxBitmap *arg2 = 0 ;
13951 long arg3 ;
13952 bool temp1 = false ;
13953 void *argp2 = 0 ;
13954 int res2 = 0 ;
13955 long val3 ;
13956 int ecode3 = 0 ;
13957 PyObject * obj0 = 0 ;
13958 PyObject * obj1 = 0 ;
13959 PyObject * obj2 = 0 ;
13960 char * kwnames[] = {
13961 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
13962 };
13963
13964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13965 {
13966 arg1 = wxString_in_helper(obj0);
13967 if (arg1 == NULL) SWIG_fail;
13968 temp1 = true;
13969 }
13970 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
13971 if (!SWIG_IsOK(res2)) {
13972 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13973 }
13974 if (!argp2) {
13975 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13976 }
13977 arg2 = reinterpret_cast< wxBitmap * >(argp2);
13978 ecode3 = SWIG_AsVal_long(obj2, &val3);
13979 if (!SWIG_IsOK(ecode3)) {
13980 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
13981 }
13982 arg3 = static_cast< long >(val3);
13983 {
13984 PyThreadState* __tstate = wxPyBeginAllowThreads();
13985 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
13986 wxPyEndAllowThreads(__tstate);
13987 if (PyErr_Occurred()) SWIG_fail;
13988 }
13989 resultobj = SWIG_Py_Void();
13990 {
13991 if (temp1)
13992 delete arg1;
13993 }
13994 return resultobj;
13995 fail:
13996 {
13997 if (temp1)
13998 delete arg1;
13999 }
14000 return NULL;
14001 }
14002
14003
14004 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14005 PyObject *resultobj = 0;
14006 wxString *arg1 = 0 ;
14007 PyObject *arg2 = (PyObject *) 0 ;
14008 bool temp1 = false ;
14009 PyObject * obj0 = 0 ;
14010 PyObject * obj1 = 0 ;
14011 char * kwnames[] = {
14012 (char *) "filename",(char *) "data", NULL
14013 };
14014
14015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
14016 {
14017 arg1 = wxString_in_helper(obj0);
14018 if (arg1 == NULL) SWIG_fail;
14019 temp1 = true;
14020 }
14021 arg2 = obj1;
14022 {
14023 PyThreadState* __tstate = wxPyBeginAllowThreads();
14024 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
14025 wxPyEndAllowThreads(__tstate);
14026 if (PyErr_Occurred()) SWIG_fail;
14027 }
14028 resultobj = SWIG_Py_Void();
14029 {
14030 if (temp1)
14031 delete arg1;
14032 }
14033 return resultobj;
14034 fail:
14035 {
14036 if (temp1)
14037 delete arg1;
14038 }
14039 return NULL;
14040 }
14041
14042
14043 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14044 PyObject *resultobj = 0;
14045 wxMemoryFSHandler *result = 0 ;
14046
14047 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
14048 {
14049 PyThreadState* __tstate = wxPyBeginAllowThreads();
14050 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
14051 wxPyEndAllowThreads(__tstate);
14052 if (PyErr_Occurred()) SWIG_fail;
14053 }
14054 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
14055 return resultobj;
14056 fail:
14057 return NULL;
14058 }
14059
14060
14061 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14062 PyObject *resultobj = 0;
14063 wxString *arg1 = 0 ;
14064 bool temp1 = false ;
14065 PyObject * obj0 = 0 ;
14066 char * kwnames[] = {
14067 (char *) "filename", NULL
14068 };
14069
14070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
14071 {
14072 arg1 = wxString_in_helper(obj0);
14073 if (arg1 == NULL) SWIG_fail;
14074 temp1 = true;
14075 }
14076 {
14077 PyThreadState* __tstate = wxPyBeginAllowThreads();
14078 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
14079 wxPyEndAllowThreads(__tstate);
14080 if (PyErr_Occurred()) SWIG_fail;
14081 }
14082 resultobj = SWIG_Py_Void();
14083 {
14084 if (temp1)
14085 delete arg1;
14086 }
14087 return resultobj;
14088 fail:
14089 {
14090 if (temp1)
14091 delete arg1;
14092 }
14093 return NULL;
14094 }
14095
14096
14097 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14098 PyObject *resultobj = 0;
14099 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14100 wxString *arg2 = 0 ;
14101 bool result;
14102 void *argp1 = 0 ;
14103 int res1 = 0 ;
14104 bool temp2 = false ;
14105 PyObject * obj0 = 0 ;
14106 PyObject * obj1 = 0 ;
14107 char * kwnames[] = {
14108 (char *) "self",(char *) "location", NULL
14109 };
14110
14111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
14112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14113 if (!SWIG_IsOK(res1)) {
14114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14115 }
14116 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14117 {
14118 arg2 = wxString_in_helper(obj1);
14119 if (arg2 == NULL) SWIG_fail;
14120 temp2 = true;
14121 }
14122 {
14123 PyThreadState* __tstate = wxPyBeginAllowThreads();
14124 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
14125 wxPyEndAllowThreads(__tstate);
14126 if (PyErr_Occurred()) SWIG_fail;
14127 }
14128 {
14129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14130 }
14131 {
14132 if (temp2)
14133 delete arg2;
14134 }
14135 return resultobj;
14136 fail:
14137 {
14138 if (temp2)
14139 delete arg2;
14140 }
14141 return NULL;
14142 }
14143
14144
14145 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14146 PyObject *resultobj = 0;
14147 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14148 wxFileSystem *arg2 = 0 ;
14149 wxString *arg3 = 0 ;
14150 wxFSFile *result = 0 ;
14151 void *argp1 = 0 ;
14152 int res1 = 0 ;
14153 void *argp2 = 0 ;
14154 int res2 = 0 ;
14155 bool temp3 = false ;
14156 PyObject * obj0 = 0 ;
14157 PyObject * obj1 = 0 ;
14158 PyObject * obj2 = 0 ;
14159 char * kwnames[] = {
14160 (char *) "self",(char *) "fs",(char *) "location", NULL
14161 };
14162
14163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14165 if (!SWIG_IsOK(res1)) {
14166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14167 }
14168 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14169 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
14170 if (!SWIG_IsOK(res2)) {
14171 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14172 }
14173 if (!argp2) {
14174 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14175 }
14176 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
14177 {
14178 arg3 = wxString_in_helper(obj2);
14179 if (arg3 == NULL) SWIG_fail;
14180 temp3 = true;
14181 }
14182 {
14183 PyThreadState* __tstate = wxPyBeginAllowThreads();
14184 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
14185 wxPyEndAllowThreads(__tstate);
14186 if (PyErr_Occurred()) SWIG_fail;
14187 }
14188 {
14189 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
14190 }
14191 {
14192 if (temp3)
14193 delete arg3;
14194 }
14195 return resultobj;
14196 fail:
14197 {
14198 if (temp3)
14199 delete arg3;
14200 }
14201 return NULL;
14202 }
14203
14204
14205 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14206 PyObject *resultobj = 0;
14207 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14208 wxString *arg2 = 0 ;
14209 int arg3 = (int) 0 ;
14210 wxString result;
14211 void *argp1 = 0 ;
14212 int res1 = 0 ;
14213 bool temp2 = false ;
14214 int val3 ;
14215 int ecode3 = 0 ;
14216 PyObject * obj0 = 0 ;
14217 PyObject * obj1 = 0 ;
14218 PyObject * obj2 = 0 ;
14219 char * kwnames[] = {
14220 (char *) "self",(char *) "spec",(char *) "flags", NULL
14221 };
14222
14223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14225 if (!SWIG_IsOK(res1)) {
14226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14227 }
14228 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14229 {
14230 arg2 = wxString_in_helper(obj1);
14231 if (arg2 == NULL) SWIG_fail;
14232 temp2 = true;
14233 }
14234 if (obj2) {
14235 ecode3 = SWIG_AsVal_int(obj2, &val3);
14236 if (!SWIG_IsOK(ecode3)) {
14237 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
14238 }
14239 arg3 = static_cast< int >(val3);
14240 }
14241 {
14242 PyThreadState* __tstate = wxPyBeginAllowThreads();
14243 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
14244 wxPyEndAllowThreads(__tstate);
14245 if (PyErr_Occurred()) SWIG_fail;
14246 }
14247 {
14248 #if wxUSE_UNICODE
14249 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14250 #else
14251 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14252 #endif
14253 }
14254 {
14255 if (temp2)
14256 delete arg2;
14257 }
14258 return resultobj;
14259 fail:
14260 {
14261 if (temp2)
14262 delete arg2;
14263 }
14264 return NULL;
14265 }
14266
14267
14268 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14269 PyObject *resultobj = 0;
14270 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14271 wxString result;
14272 void *argp1 = 0 ;
14273 int res1 = 0 ;
14274 PyObject *swig_obj[1] ;
14275
14276 if (!args) SWIG_fail;
14277 swig_obj[0] = args;
14278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14279 if (!SWIG_IsOK(res1)) {
14280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14281 }
14282 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14283 {
14284 PyThreadState* __tstate = wxPyBeginAllowThreads();
14285 result = (arg1)->FindNext();
14286 wxPyEndAllowThreads(__tstate);
14287 if (PyErr_Occurred()) SWIG_fail;
14288 }
14289 {
14290 #if wxUSE_UNICODE
14291 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14292 #else
14293 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14294 #endif
14295 }
14296 return resultobj;
14297 fail:
14298 return NULL;
14299 }
14300
14301
14302 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14303 PyObject *obj;
14304 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14305 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
14306 return SWIG_Py_Void();
14307 }
14308
14309 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14310 return SWIG_Python_InitShadowInstance(args);
14311 }
14312
14313 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14314 PyObject *resultobj = 0;
14315 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14316 wxString result;
14317 void *argp1 = 0 ;
14318 int res1 = 0 ;
14319 PyObject *swig_obj[1] ;
14320
14321 if (!args) SWIG_fail;
14322 swig_obj[0] = args;
14323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14324 if (!SWIG_IsOK(res1)) {
14325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14326 }
14327 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14328 {
14329 PyThreadState* __tstate = wxPyBeginAllowThreads();
14330 result = (arg1)->GetName();
14331 wxPyEndAllowThreads(__tstate);
14332 if (PyErr_Occurred()) SWIG_fail;
14333 }
14334 {
14335 #if wxUSE_UNICODE
14336 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14337 #else
14338 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14339 #endif
14340 }
14341 return resultobj;
14342 fail:
14343 return NULL;
14344 }
14345
14346
14347 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14348 PyObject *resultobj = 0;
14349 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14350 wxString result;
14351 void *argp1 = 0 ;
14352 int res1 = 0 ;
14353 PyObject *swig_obj[1] ;
14354
14355 if (!args) SWIG_fail;
14356 swig_obj[0] = args;
14357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14358 if (!SWIG_IsOK(res1)) {
14359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14360 }
14361 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14362 {
14363 PyThreadState* __tstate = wxPyBeginAllowThreads();
14364 result = (arg1)->GetExtension();
14365 wxPyEndAllowThreads(__tstate);
14366 if (PyErr_Occurred()) SWIG_fail;
14367 }
14368 {
14369 #if wxUSE_UNICODE
14370 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14371 #else
14372 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14373 #endif
14374 }
14375 return resultobj;
14376 fail:
14377 return NULL;
14378 }
14379
14380
14381 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14382 PyObject *resultobj = 0;
14383 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14384 long result;
14385 void *argp1 = 0 ;
14386 int res1 = 0 ;
14387 PyObject *swig_obj[1] ;
14388
14389 if (!args) SWIG_fail;
14390 swig_obj[0] = args;
14391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14392 if (!SWIG_IsOK(res1)) {
14393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14394 }
14395 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14396 {
14397 PyThreadState* __tstate = wxPyBeginAllowThreads();
14398 result = (long)(arg1)->GetType();
14399 wxPyEndAllowThreads(__tstate);
14400 if (PyErr_Occurred()) SWIG_fail;
14401 }
14402 resultobj = SWIG_From_long(static_cast< long >(result));
14403 return resultobj;
14404 fail:
14405 return NULL;
14406 }
14407
14408
14409 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14410 PyObject *resultobj = 0;
14411 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14412 wxString result;
14413 void *argp1 = 0 ;
14414 int res1 = 0 ;
14415 PyObject *swig_obj[1] ;
14416
14417 if (!args) SWIG_fail;
14418 swig_obj[0] = args;
14419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14420 if (!SWIG_IsOK(res1)) {
14421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14422 }
14423 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14424 {
14425 PyThreadState* __tstate = wxPyBeginAllowThreads();
14426 result = (arg1)->GetMimeType();
14427 wxPyEndAllowThreads(__tstate);
14428 if (PyErr_Occurred()) SWIG_fail;
14429 }
14430 {
14431 #if wxUSE_UNICODE
14432 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14433 #else
14434 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14435 #endif
14436 }
14437 return resultobj;
14438 fail:
14439 return NULL;
14440 }
14441
14442
14443 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14444 PyObject *resultobj = 0;
14445 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14446 wxString *arg2 = 0 ;
14447 bool result;
14448 void *argp1 = 0 ;
14449 int res1 = 0 ;
14450 bool temp2 = false ;
14451 PyObject * obj0 = 0 ;
14452 PyObject * obj1 = 0 ;
14453 char * kwnames[] = {
14454 (char *) "self",(char *) "name", NULL
14455 };
14456
14457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
14458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14459 if (!SWIG_IsOK(res1)) {
14460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14461 }
14462 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14463 {
14464 arg2 = wxString_in_helper(obj1);
14465 if (arg2 == NULL) SWIG_fail;
14466 temp2 = true;
14467 }
14468 {
14469 PyThreadState* __tstate = wxPyBeginAllowThreads();
14470 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
14471 wxPyEndAllowThreads(__tstate);
14472 if (PyErr_Occurred()) SWIG_fail;
14473 }
14474 {
14475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14476 }
14477 {
14478 if (temp2)
14479 delete arg2;
14480 }
14481 return resultobj;
14482 fail:
14483 {
14484 if (temp2)
14485 delete arg2;
14486 }
14487 return NULL;
14488 }
14489
14490
14491 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14492 PyObject *resultobj = 0;
14493 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14494 wxInputStream *arg2 = 0 ;
14495 bool result;
14496 void *argp1 = 0 ;
14497 int res1 = 0 ;
14498 wxPyInputStream *temp2 ;
14499 bool created2 ;
14500 PyObject * obj0 = 0 ;
14501 PyObject * obj1 = 0 ;
14502 char * kwnames[] = {
14503 (char *) "self",(char *) "stream", NULL
14504 };
14505
14506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
14507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14508 if (!SWIG_IsOK(res1)) {
14509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14510 }
14511 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14512 {
14513 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14514 arg2 = temp2->m_wxis;
14515 created2 = false;
14516 } else {
14517 PyErr_Clear(); // clear the failure of the wxPyConvert above
14518 arg2 = wxPyCBInputStream_create(obj1, false);
14519 if (arg2 == NULL) {
14520 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14521 SWIG_fail;
14522 }
14523 created2 = true;
14524 }
14525 }
14526 {
14527 PyThreadState* __tstate = wxPyBeginAllowThreads();
14528 result = (bool)(arg1)->CanRead(*arg2);
14529 wxPyEndAllowThreads(__tstate);
14530 if (PyErr_Occurred()) SWIG_fail;
14531 }
14532 {
14533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14534 }
14535 {
14536 if (created2) delete arg2;
14537 }
14538 return resultobj;
14539 fail:
14540 {
14541 if (created2) delete arg2;
14542 }
14543 return NULL;
14544 }
14545
14546
14547 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14548 PyObject *resultobj = 0;
14549 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14550 wxString *arg2 = 0 ;
14551 void *argp1 = 0 ;
14552 int res1 = 0 ;
14553 bool temp2 = false ;
14554 PyObject * obj0 = 0 ;
14555 PyObject * obj1 = 0 ;
14556 char * kwnames[] = {
14557 (char *) "self",(char *) "name", NULL
14558 };
14559
14560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
14561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14562 if (!SWIG_IsOK(res1)) {
14563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14564 }
14565 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14566 {
14567 arg2 = wxString_in_helper(obj1);
14568 if (arg2 == NULL) SWIG_fail;
14569 temp2 = true;
14570 }
14571 {
14572 PyThreadState* __tstate = wxPyBeginAllowThreads();
14573 (arg1)->SetName((wxString const &)*arg2);
14574 wxPyEndAllowThreads(__tstate);
14575 if (PyErr_Occurred()) SWIG_fail;
14576 }
14577 resultobj = SWIG_Py_Void();
14578 {
14579 if (temp2)
14580 delete arg2;
14581 }
14582 return resultobj;
14583 fail:
14584 {
14585 if (temp2)
14586 delete arg2;
14587 }
14588 return NULL;
14589 }
14590
14591
14592 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14593 PyObject *resultobj = 0;
14594 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14595 wxString *arg2 = 0 ;
14596 void *argp1 = 0 ;
14597 int res1 = 0 ;
14598 bool temp2 = false ;
14599 PyObject * obj0 = 0 ;
14600 PyObject * obj1 = 0 ;
14601 char * kwnames[] = {
14602 (char *) "self",(char *) "extension", NULL
14603 };
14604
14605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
14606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14607 if (!SWIG_IsOK(res1)) {
14608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14609 }
14610 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14611 {
14612 arg2 = wxString_in_helper(obj1);
14613 if (arg2 == NULL) SWIG_fail;
14614 temp2 = true;
14615 }
14616 {
14617 PyThreadState* __tstate = wxPyBeginAllowThreads();
14618 (arg1)->SetExtension((wxString const &)*arg2);
14619 wxPyEndAllowThreads(__tstate);
14620 if (PyErr_Occurred()) SWIG_fail;
14621 }
14622 resultobj = SWIG_Py_Void();
14623 {
14624 if (temp2)
14625 delete arg2;
14626 }
14627 return resultobj;
14628 fail:
14629 {
14630 if (temp2)
14631 delete arg2;
14632 }
14633 return NULL;
14634 }
14635
14636
14637 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14638 PyObject *resultobj = 0;
14639 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14640 long arg2 ;
14641 void *argp1 = 0 ;
14642 int res1 = 0 ;
14643 long val2 ;
14644 int ecode2 = 0 ;
14645 PyObject * obj0 = 0 ;
14646 PyObject * obj1 = 0 ;
14647 char * kwnames[] = {
14648 (char *) "self",(char *) "type", NULL
14649 };
14650
14651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
14652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14653 if (!SWIG_IsOK(res1)) {
14654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14655 }
14656 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14657 ecode2 = SWIG_AsVal_long(obj1, &val2);
14658 if (!SWIG_IsOK(ecode2)) {
14659 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
14660 }
14661 arg2 = static_cast< long >(val2);
14662 {
14663 PyThreadState* __tstate = wxPyBeginAllowThreads();
14664 (arg1)->SetType(arg2);
14665 wxPyEndAllowThreads(__tstate);
14666 if (PyErr_Occurred()) SWIG_fail;
14667 }
14668 resultobj = SWIG_Py_Void();
14669 return resultobj;
14670 fail:
14671 return NULL;
14672 }
14673
14674
14675 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14676 PyObject *resultobj = 0;
14677 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14678 wxString *arg2 = 0 ;
14679 void *argp1 = 0 ;
14680 int res1 = 0 ;
14681 bool temp2 = false ;
14682 PyObject * obj0 = 0 ;
14683 PyObject * obj1 = 0 ;
14684 char * kwnames[] = {
14685 (char *) "self",(char *) "mimetype", NULL
14686 };
14687
14688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
14689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14690 if (!SWIG_IsOK(res1)) {
14691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14692 }
14693 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14694 {
14695 arg2 = wxString_in_helper(obj1);
14696 if (arg2 == NULL) SWIG_fail;
14697 temp2 = true;
14698 }
14699 {
14700 PyThreadState* __tstate = wxPyBeginAllowThreads();
14701 (arg1)->SetMimeType((wxString const &)*arg2);
14702 wxPyEndAllowThreads(__tstate);
14703 if (PyErr_Occurred()) SWIG_fail;
14704 }
14705 resultobj = SWIG_Py_Void();
14706 {
14707 if (temp2)
14708 delete arg2;
14709 }
14710 return resultobj;
14711 fail:
14712 {
14713 if (temp2)
14714 delete arg2;
14715 }
14716 return NULL;
14717 }
14718
14719
14720 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14721 PyObject *obj;
14722 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14723 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
14724 return SWIG_Py_Void();
14725 }
14726
14727 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14728 PyObject *resultobj = 0;
14729 wxPyImageHandler *result = 0 ;
14730
14731 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
14732 {
14733 PyThreadState* __tstate = wxPyBeginAllowThreads();
14734 result = (wxPyImageHandler *)new wxPyImageHandler();
14735 wxPyEndAllowThreads(__tstate);
14736 if (PyErr_Occurred()) SWIG_fail;
14737 }
14738 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
14739 return resultobj;
14740 fail:
14741 return NULL;
14742 }
14743
14744
14745 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14746 PyObject *resultobj = 0;
14747 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
14748 PyObject *arg2 = (PyObject *) 0 ;
14749 void *argp1 = 0 ;
14750 int res1 = 0 ;
14751 PyObject * obj0 = 0 ;
14752 PyObject * obj1 = 0 ;
14753 char * kwnames[] = {
14754 (char *) "self",(char *) "self", NULL
14755 };
14756
14757 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
14758 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
14759 if (!SWIG_IsOK(res1)) {
14760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
14761 }
14762 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
14763 arg2 = obj1;
14764 {
14765 PyThreadState* __tstate = wxPyBeginAllowThreads();
14766 (arg1)->_SetSelf(arg2);
14767 wxPyEndAllowThreads(__tstate);
14768 if (PyErr_Occurred()) SWIG_fail;
14769 }
14770 resultobj = SWIG_Py_Void();
14771 return resultobj;
14772 fail:
14773 return NULL;
14774 }
14775
14776
14777 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14778 PyObject *obj;
14779 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14780 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
14781 return SWIG_Py_Void();
14782 }
14783
14784 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14785 return SWIG_Python_InitShadowInstance(args);
14786 }
14787
14788 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14789 PyObject *resultobj = 0;
14790 wxImageHistogram *result = 0 ;
14791
14792 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
14793 {
14794 PyThreadState* __tstate = wxPyBeginAllowThreads();
14795 result = (wxImageHistogram *)new wxImageHistogram();
14796 wxPyEndAllowThreads(__tstate);
14797 if (PyErr_Occurred()) SWIG_fail;
14798 }
14799 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
14800 return resultobj;
14801 fail:
14802 return NULL;
14803 }
14804
14805
14806 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14807 PyObject *resultobj = 0;
14808 byte arg1 ;
14809 byte arg2 ;
14810 byte arg3 ;
14811 unsigned long result;
14812 unsigned char val1 ;
14813 int ecode1 = 0 ;
14814 unsigned char val2 ;
14815 int ecode2 = 0 ;
14816 unsigned char val3 ;
14817 int ecode3 = 0 ;
14818 PyObject * obj0 = 0 ;
14819 PyObject * obj1 = 0 ;
14820 PyObject * obj2 = 0 ;
14821 char * kwnames[] = {
14822 (char *) "r",(char *) "g",(char *) "b", NULL
14823 };
14824
14825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14826 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
14827 if (!SWIG_IsOK(ecode1)) {
14828 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
14829 }
14830 arg1 = static_cast< byte >(val1);
14831 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14832 if (!SWIG_IsOK(ecode2)) {
14833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
14834 }
14835 arg2 = static_cast< byte >(val2);
14836 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14837 if (!SWIG_IsOK(ecode3)) {
14838 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
14839 }
14840 arg3 = static_cast< byte >(val3);
14841 {
14842 PyThreadState* __tstate = wxPyBeginAllowThreads();
14843 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
14844 wxPyEndAllowThreads(__tstate);
14845 if (PyErr_Occurred()) SWIG_fail;
14846 }
14847 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14848 return resultobj;
14849 fail:
14850 return NULL;
14851 }
14852
14853
14854 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14855 PyObject *resultobj = 0;
14856 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14857 byte *arg2 = (byte *) 0 ;
14858 byte *arg3 = (byte *) 0 ;
14859 byte *arg4 = (byte *) 0 ;
14860 byte arg5 = (byte) 1 ;
14861 byte arg6 = (byte) 0 ;
14862 byte arg7 = (byte) 0 ;
14863 bool result;
14864 void *argp1 = 0 ;
14865 int res1 = 0 ;
14866 byte temp2 ;
14867 int res2 = SWIG_TMPOBJ ;
14868 byte temp3 ;
14869 int res3 = SWIG_TMPOBJ ;
14870 byte temp4 ;
14871 int res4 = SWIG_TMPOBJ ;
14872 unsigned char val5 ;
14873 int ecode5 = 0 ;
14874 unsigned char val6 ;
14875 int ecode6 = 0 ;
14876 unsigned char val7 ;
14877 int ecode7 = 0 ;
14878 PyObject * obj0 = 0 ;
14879 PyObject * obj1 = 0 ;
14880 PyObject * obj2 = 0 ;
14881 PyObject * obj3 = 0 ;
14882 char * kwnames[] = {
14883 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14884 };
14885
14886 arg2 = &temp2;
14887 arg3 = &temp3;
14888 arg4 = &temp4;
14889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14891 if (!SWIG_IsOK(res1)) {
14892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
14893 }
14894 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14895 if (obj1) {
14896 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14897 if (!SWIG_IsOK(ecode5)) {
14898 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14899 }
14900 arg5 = static_cast< byte >(val5);
14901 }
14902 if (obj2) {
14903 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14904 if (!SWIG_IsOK(ecode6)) {
14905 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14906 }
14907 arg6 = static_cast< byte >(val6);
14908 }
14909 if (obj3) {
14910 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14911 if (!SWIG_IsOK(ecode7)) {
14912 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14913 }
14914 arg7 = static_cast< byte >(val7);
14915 }
14916 {
14917 PyThreadState* __tstate = wxPyBeginAllowThreads();
14918 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14919 wxPyEndAllowThreads(__tstate);
14920 if (PyErr_Occurred()) SWIG_fail;
14921 }
14922 {
14923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14924 }
14925 if (SWIG_IsTmpObj(res2)) {
14926 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14927 } else {
14928 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14929 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14930 }
14931 if (SWIG_IsTmpObj(res3)) {
14932 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14933 } else {
14934 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14935 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14936 }
14937 if (SWIG_IsTmpObj(res4)) {
14938 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14939 } else {
14940 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14941 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14942 }
14943 return resultobj;
14944 fail:
14945 return NULL;
14946 }
14947
14948
14949 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14950 PyObject *resultobj = 0;
14951 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14952 unsigned long arg2 ;
14953 unsigned long result;
14954 void *argp1 = 0 ;
14955 int res1 = 0 ;
14956 unsigned long val2 ;
14957 int ecode2 = 0 ;
14958 PyObject * obj0 = 0 ;
14959 PyObject * obj1 = 0 ;
14960 char * kwnames[] = {
14961 (char *) "self",(char *) "key", NULL
14962 };
14963
14964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
14965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14966 if (!SWIG_IsOK(res1)) {
14967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14968 }
14969 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14970 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
14971 if (!SWIG_IsOK(ecode2)) {
14972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
14973 }
14974 arg2 = static_cast< unsigned long >(val2);
14975 {
14976 PyThreadState* __tstate = wxPyBeginAllowThreads();
14977 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
14978 wxPyEndAllowThreads(__tstate);
14979 if (PyErr_Occurred()) SWIG_fail;
14980 }
14981 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14982 return resultobj;
14983 fail:
14984 return NULL;
14985 }
14986
14987
14988 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14989 PyObject *resultobj = 0;
14990 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14991 byte arg2 ;
14992 byte arg3 ;
14993 byte arg4 ;
14994 unsigned long result;
14995 void *argp1 = 0 ;
14996 int res1 = 0 ;
14997 unsigned char val2 ;
14998 int ecode2 = 0 ;
14999 unsigned char val3 ;
15000 int ecode3 = 0 ;
15001 unsigned char val4 ;
15002 int ecode4 = 0 ;
15003 PyObject * obj0 = 0 ;
15004 PyObject * obj1 = 0 ;
15005 PyObject * obj2 = 0 ;
15006 PyObject * obj3 = 0 ;
15007 char * kwnames[] = {
15008 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15009 };
15010
15011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
15013 if (!SWIG_IsOK(res1)) {
15014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
15015 }
15016 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
15017 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15018 if (!SWIG_IsOK(ecode2)) {
15019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
15020 }
15021 arg2 = static_cast< byte >(val2);
15022 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15023 if (!SWIG_IsOK(ecode3)) {
15024 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
15025 }
15026 arg3 = static_cast< byte >(val3);
15027 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15028 if (!SWIG_IsOK(ecode4)) {
15029 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
15030 }
15031 arg4 = static_cast< byte >(val4);
15032 {
15033 PyThreadState* __tstate = wxPyBeginAllowThreads();
15034 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
15035 wxPyEndAllowThreads(__tstate);
15036 if (PyErr_Occurred()) SWIG_fail;
15037 }
15038 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15039 return resultobj;
15040 fail:
15041 return NULL;
15042 }
15043
15044
15045 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15046 PyObject *resultobj = 0;
15047 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
15048 wxColour *arg2 = 0 ;
15049 unsigned long result;
15050 void *argp1 = 0 ;
15051 int res1 = 0 ;
15052 wxColour temp2 ;
15053 PyObject * obj0 = 0 ;
15054 PyObject * obj1 = 0 ;
15055 char * kwnames[] = {
15056 (char *) "self",(char *) "colour", NULL
15057 };
15058
15059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
15060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
15061 if (!SWIG_IsOK(res1)) {
15062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
15063 }
15064 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
15065 {
15066 arg2 = &temp2;
15067 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
15068 }
15069 {
15070 PyThreadState* __tstate = wxPyBeginAllowThreads();
15071 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
15072 wxPyEndAllowThreads(__tstate);
15073 if (PyErr_Occurred()) SWIG_fail;
15074 }
15075 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15076 return resultobj;
15077 fail:
15078 return NULL;
15079 }
15080
15081
15082 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15083 PyObject *obj;
15084 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15085 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
15086 return SWIG_Py_Void();
15087 }
15088
15089 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15090 return SWIG_Python_InitShadowInstance(args);
15091 }
15092
15093 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15094 PyObject *resultobj = 0;
15095 byte arg1 = (byte) 0 ;
15096 byte arg2 = (byte) 0 ;
15097 byte arg3 = (byte) 0 ;
15098 wxImage_RGBValue *result = 0 ;
15099 unsigned char val1 ;
15100 int ecode1 = 0 ;
15101 unsigned char val2 ;
15102 int ecode2 = 0 ;
15103 unsigned char val3 ;
15104 int ecode3 = 0 ;
15105 PyObject * obj0 = 0 ;
15106 PyObject * obj1 = 0 ;
15107 PyObject * obj2 = 0 ;
15108 char * kwnames[] = {
15109 (char *) "r",(char *) "g",(char *) "b", NULL
15110 };
15111
15112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15113 if (obj0) {
15114 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
15115 if (!SWIG_IsOK(ecode1)) {
15116 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
15117 }
15118 arg1 = static_cast< byte >(val1);
15119 }
15120 if (obj1) {
15121 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15122 if (!SWIG_IsOK(ecode2)) {
15123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
15124 }
15125 arg2 = static_cast< byte >(val2);
15126 }
15127 if (obj2) {
15128 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15129 if (!SWIG_IsOK(ecode3)) {
15130 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
15131 }
15132 arg3 = static_cast< byte >(val3);
15133 }
15134 {
15135 PyThreadState* __tstate = wxPyBeginAllowThreads();
15136 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
15137 wxPyEndAllowThreads(__tstate);
15138 if (PyErr_Occurred()) SWIG_fail;
15139 }
15140 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
15141 return resultobj;
15142 fail:
15143 return NULL;
15144 }
15145
15146
15147 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15148 PyObject *resultobj = 0;
15149 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15150 byte arg2 ;
15151 void *argp1 = 0 ;
15152 int res1 = 0 ;
15153 unsigned char val2 ;
15154 int ecode2 = 0 ;
15155 PyObject *swig_obj[2] ;
15156
15157 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
15158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15159 if (!SWIG_IsOK(res1)) {
15160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15161 }
15162 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15163 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15164 if (!SWIG_IsOK(ecode2)) {
15165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
15166 }
15167 arg2 = static_cast< byte >(val2);
15168 if (arg1) (arg1)->red = arg2;
15169
15170 resultobj = SWIG_Py_Void();
15171 return resultobj;
15172 fail:
15173 return NULL;
15174 }
15175
15176
15177 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15178 PyObject *resultobj = 0;
15179 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15180 byte result;
15181 void *argp1 = 0 ;
15182 int res1 = 0 ;
15183 PyObject *swig_obj[1] ;
15184
15185 if (!args) SWIG_fail;
15186 swig_obj[0] = args;
15187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15188 if (!SWIG_IsOK(res1)) {
15189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15190 }
15191 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15192 result = (byte) ((arg1)->red);
15193 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15194 return resultobj;
15195 fail:
15196 return NULL;
15197 }
15198
15199
15200 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15201 PyObject *resultobj = 0;
15202 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15203 byte arg2 ;
15204 void *argp1 = 0 ;
15205 int res1 = 0 ;
15206 unsigned char val2 ;
15207 int ecode2 = 0 ;
15208 PyObject *swig_obj[2] ;
15209
15210 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
15211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15212 if (!SWIG_IsOK(res1)) {
15213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15214 }
15215 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15216 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15217 if (!SWIG_IsOK(ecode2)) {
15218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
15219 }
15220 arg2 = static_cast< byte >(val2);
15221 if (arg1) (arg1)->green = arg2;
15222
15223 resultobj = SWIG_Py_Void();
15224 return resultobj;
15225 fail:
15226 return NULL;
15227 }
15228
15229
15230 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15231 PyObject *resultobj = 0;
15232 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15233 byte result;
15234 void *argp1 = 0 ;
15235 int res1 = 0 ;
15236 PyObject *swig_obj[1] ;
15237
15238 if (!args) SWIG_fail;
15239 swig_obj[0] = args;
15240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15241 if (!SWIG_IsOK(res1)) {
15242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15243 }
15244 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15245 result = (byte) ((arg1)->green);
15246 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15247 return resultobj;
15248 fail:
15249 return NULL;
15250 }
15251
15252
15253 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15254 PyObject *resultobj = 0;
15255 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15256 byte arg2 ;
15257 void *argp1 = 0 ;
15258 int res1 = 0 ;
15259 unsigned char val2 ;
15260 int ecode2 = 0 ;
15261 PyObject *swig_obj[2] ;
15262
15263 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
15264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15265 if (!SWIG_IsOK(res1)) {
15266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15267 }
15268 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15269 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15270 if (!SWIG_IsOK(ecode2)) {
15271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
15272 }
15273 arg2 = static_cast< byte >(val2);
15274 if (arg1) (arg1)->blue = arg2;
15275
15276 resultobj = SWIG_Py_Void();
15277 return resultobj;
15278 fail:
15279 return NULL;
15280 }
15281
15282
15283 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15284 PyObject *resultobj = 0;
15285 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15286 byte result;
15287 void *argp1 = 0 ;
15288 int res1 = 0 ;
15289 PyObject *swig_obj[1] ;
15290
15291 if (!args) SWIG_fail;
15292 swig_obj[0] = args;
15293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15294 if (!SWIG_IsOK(res1)) {
15295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15296 }
15297 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15298 result = (byte) ((arg1)->blue);
15299 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15300 return resultobj;
15301 fail:
15302 return NULL;
15303 }
15304
15305
15306 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15307 PyObject *obj;
15308 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15309 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
15310 return SWIG_Py_Void();
15311 }
15312
15313 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15314 return SWIG_Python_InitShadowInstance(args);
15315 }
15316
15317 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15318 PyObject *resultobj = 0;
15319 double arg1 = (double) 0.0 ;
15320 double arg2 = (double) 0.0 ;
15321 double arg3 = (double) 0.0 ;
15322 wxImage_HSVValue *result = 0 ;
15323 double val1 ;
15324 int ecode1 = 0 ;
15325 double val2 ;
15326 int ecode2 = 0 ;
15327 double val3 ;
15328 int ecode3 = 0 ;
15329 PyObject * obj0 = 0 ;
15330 PyObject * obj1 = 0 ;
15331 PyObject * obj2 = 0 ;
15332 char * kwnames[] = {
15333 (char *) "h",(char *) "s",(char *) "v", NULL
15334 };
15335
15336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15337 if (obj0) {
15338 ecode1 = SWIG_AsVal_double(obj0, &val1);
15339 if (!SWIG_IsOK(ecode1)) {
15340 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
15341 }
15342 arg1 = static_cast< double >(val1);
15343 }
15344 if (obj1) {
15345 ecode2 = SWIG_AsVal_double(obj1, &val2);
15346 if (!SWIG_IsOK(ecode2)) {
15347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
15348 }
15349 arg2 = static_cast< double >(val2);
15350 }
15351 if (obj2) {
15352 ecode3 = SWIG_AsVal_double(obj2, &val3);
15353 if (!SWIG_IsOK(ecode3)) {
15354 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
15355 }
15356 arg3 = static_cast< double >(val3);
15357 }
15358 {
15359 PyThreadState* __tstate = wxPyBeginAllowThreads();
15360 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
15361 wxPyEndAllowThreads(__tstate);
15362 if (PyErr_Occurred()) SWIG_fail;
15363 }
15364 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
15365 return resultobj;
15366 fail:
15367 return NULL;
15368 }
15369
15370
15371 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15372 PyObject *resultobj = 0;
15373 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15374 double arg2 ;
15375 void *argp1 = 0 ;
15376 int res1 = 0 ;
15377 double val2 ;
15378 int ecode2 = 0 ;
15379 PyObject *swig_obj[2] ;
15380
15381 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
15382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15383 if (!SWIG_IsOK(res1)) {
15384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15385 }
15386 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15387 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15388 if (!SWIG_IsOK(ecode2)) {
15389 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
15390 }
15391 arg2 = static_cast< double >(val2);
15392 if (arg1) (arg1)->hue = arg2;
15393
15394 resultobj = SWIG_Py_Void();
15395 return resultobj;
15396 fail:
15397 return NULL;
15398 }
15399
15400
15401 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15402 PyObject *resultobj = 0;
15403 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15404 double result;
15405 void *argp1 = 0 ;
15406 int res1 = 0 ;
15407 PyObject *swig_obj[1] ;
15408
15409 if (!args) SWIG_fail;
15410 swig_obj[0] = args;
15411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15412 if (!SWIG_IsOK(res1)) {
15413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15414 }
15415 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15416 result = (double) ((arg1)->hue);
15417 resultobj = SWIG_From_double(static_cast< double >(result));
15418 return resultobj;
15419 fail:
15420 return NULL;
15421 }
15422
15423
15424 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15425 PyObject *resultobj = 0;
15426 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15427 double arg2 ;
15428 void *argp1 = 0 ;
15429 int res1 = 0 ;
15430 double val2 ;
15431 int ecode2 = 0 ;
15432 PyObject *swig_obj[2] ;
15433
15434 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
15435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15436 if (!SWIG_IsOK(res1)) {
15437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15438 }
15439 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15440 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15441 if (!SWIG_IsOK(ecode2)) {
15442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
15443 }
15444 arg2 = static_cast< double >(val2);
15445 if (arg1) (arg1)->saturation = arg2;
15446
15447 resultobj = SWIG_Py_Void();
15448 return resultobj;
15449 fail:
15450 return NULL;
15451 }
15452
15453
15454 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15455 PyObject *resultobj = 0;
15456 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15457 double result;
15458 void *argp1 = 0 ;
15459 int res1 = 0 ;
15460 PyObject *swig_obj[1] ;
15461
15462 if (!args) SWIG_fail;
15463 swig_obj[0] = args;
15464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15465 if (!SWIG_IsOK(res1)) {
15466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15467 }
15468 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15469 result = (double) ((arg1)->saturation);
15470 resultobj = SWIG_From_double(static_cast< double >(result));
15471 return resultobj;
15472 fail:
15473 return NULL;
15474 }
15475
15476
15477 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15478 PyObject *resultobj = 0;
15479 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15480 double arg2 ;
15481 void *argp1 = 0 ;
15482 int res1 = 0 ;
15483 double val2 ;
15484 int ecode2 = 0 ;
15485 PyObject *swig_obj[2] ;
15486
15487 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
15488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15489 if (!SWIG_IsOK(res1)) {
15490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15491 }
15492 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15493 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15494 if (!SWIG_IsOK(ecode2)) {
15495 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
15496 }
15497 arg2 = static_cast< double >(val2);
15498 if (arg1) (arg1)->value = arg2;
15499
15500 resultobj = SWIG_Py_Void();
15501 return resultobj;
15502 fail:
15503 return NULL;
15504 }
15505
15506
15507 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15508 PyObject *resultobj = 0;
15509 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15510 double result;
15511 void *argp1 = 0 ;
15512 int res1 = 0 ;
15513 PyObject *swig_obj[1] ;
15514
15515 if (!args) SWIG_fail;
15516 swig_obj[0] = args;
15517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15518 if (!SWIG_IsOK(res1)) {
15519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15520 }
15521 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15522 result = (double) ((arg1)->value);
15523 resultobj = SWIG_From_double(static_cast< double >(result));
15524 return resultobj;
15525 fail:
15526 return NULL;
15527 }
15528
15529
15530 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15531 PyObject *obj;
15532 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15533 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
15534 return SWIG_Py_Void();
15535 }
15536
15537 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15538 return SWIG_Python_InitShadowInstance(args);
15539 }
15540
15541 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15542 PyObject *resultobj = 0;
15543 wxString *arg1 = 0 ;
15544 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15545 int arg3 = (int) -1 ;
15546 wxImage *result = 0 ;
15547 bool temp1 = false ;
15548 long val2 ;
15549 int ecode2 = 0 ;
15550 int val3 ;
15551 int ecode3 = 0 ;
15552 PyObject * obj0 = 0 ;
15553 PyObject * obj1 = 0 ;
15554 PyObject * obj2 = 0 ;
15555 char * kwnames[] = {
15556 (char *) "name",(char *) "type",(char *) "index", NULL
15557 };
15558
15559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15560 {
15561 arg1 = wxString_in_helper(obj0);
15562 if (arg1 == NULL) SWIG_fail;
15563 temp1 = true;
15564 }
15565 if (obj1) {
15566 ecode2 = SWIG_AsVal_long(obj1, &val2);
15567 if (!SWIG_IsOK(ecode2)) {
15568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
15569 }
15570 arg2 = static_cast< long >(val2);
15571 }
15572 if (obj2) {
15573 ecode3 = SWIG_AsVal_int(obj2, &val3);
15574 if (!SWIG_IsOK(ecode3)) {
15575 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
15576 }
15577 arg3 = static_cast< int >(val3);
15578 }
15579 {
15580 PyThreadState* __tstate = wxPyBeginAllowThreads();
15581 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
15582 wxPyEndAllowThreads(__tstate);
15583 if (PyErr_Occurred()) SWIG_fail;
15584 }
15585 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
15586 {
15587 if (temp1)
15588 delete arg1;
15589 }
15590 return resultobj;
15591 fail:
15592 {
15593 if (temp1)
15594 delete arg1;
15595 }
15596 return NULL;
15597 }
15598
15599
15600 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15601 PyObject *resultobj = 0;
15602 wxImage *arg1 = (wxImage *) 0 ;
15603 void *argp1 = 0 ;
15604 int res1 = 0 ;
15605 PyObject *swig_obj[1] ;
15606
15607 if (!args) SWIG_fail;
15608 swig_obj[0] = args;
15609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
15610 if (!SWIG_IsOK(res1)) {
15611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
15612 }
15613 arg1 = reinterpret_cast< wxImage * >(argp1);
15614 {
15615 PyThreadState* __tstate = wxPyBeginAllowThreads();
15616 delete arg1;
15617
15618 wxPyEndAllowThreads(__tstate);
15619 if (PyErr_Occurred()) SWIG_fail;
15620 }
15621 resultobj = SWIG_Py_Void();
15622 return resultobj;
15623 fail:
15624 return NULL;
15625 }
15626
15627
15628 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15629 PyObject *resultobj = 0;
15630 wxString *arg1 = 0 ;
15631 wxString *arg2 = 0 ;
15632 int arg3 = (int) -1 ;
15633 wxImage *result = 0 ;
15634 bool temp1 = false ;
15635 bool temp2 = false ;
15636 int val3 ;
15637 int ecode3 = 0 ;
15638 PyObject * obj0 = 0 ;
15639 PyObject * obj1 = 0 ;
15640 PyObject * obj2 = 0 ;
15641 char * kwnames[] = {
15642 (char *) "name",(char *) "mimetype",(char *) "index", NULL
15643 };
15644
15645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15646 {
15647 arg1 = wxString_in_helper(obj0);
15648 if (arg1 == NULL) SWIG_fail;
15649 temp1 = true;
15650 }
15651 {
15652 arg2 = wxString_in_helper(obj1);
15653 if (arg2 == NULL) SWIG_fail;
15654 temp2 = true;
15655 }
15656 if (obj2) {
15657 ecode3 = SWIG_AsVal_int(obj2, &val3);
15658 if (!SWIG_IsOK(ecode3)) {
15659 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
15660 }
15661 arg3 = static_cast< int >(val3);
15662 }
15663 {
15664 PyThreadState* __tstate = wxPyBeginAllowThreads();
15665 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
15666 wxPyEndAllowThreads(__tstate);
15667 if (PyErr_Occurred()) SWIG_fail;
15668 }
15669 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15670 {
15671 if (temp1)
15672 delete arg1;
15673 }
15674 {
15675 if (temp2)
15676 delete arg2;
15677 }
15678 return resultobj;
15679 fail:
15680 {
15681 if (temp1)
15682 delete arg1;
15683 }
15684 {
15685 if (temp2)
15686 delete arg2;
15687 }
15688 return NULL;
15689 }
15690
15691
15692 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15693 PyObject *resultobj = 0;
15694 wxInputStream *arg1 = 0 ;
15695 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15696 int arg3 = (int) -1 ;
15697 wxImage *result = 0 ;
15698 wxPyInputStream *temp1 ;
15699 bool created1 ;
15700 long val2 ;
15701 int ecode2 = 0 ;
15702 int val3 ;
15703 int ecode3 = 0 ;
15704 PyObject * obj0 = 0 ;
15705 PyObject * obj1 = 0 ;
15706 PyObject * obj2 = 0 ;
15707 char * kwnames[] = {
15708 (char *) "stream",(char *) "type",(char *) "index", NULL
15709 };
15710
15711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15712 {
15713 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15714 arg1 = temp1->m_wxis;
15715 created1 = false;
15716 } else {
15717 PyErr_Clear(); // clear the failure of the wxPyConvert above
15718 arg1 = wxPyCBInputStream_create(obj0, false);
15719 if (arg1 == NULL) {
15720 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15721 SWIG_fail;
15722 }
15723 created1 = true;
15724 }
15725 }
15726 if (obj1) {
15727 ecode2 = SWIG_AsVal_long(obj1, &val2);
15728 if (!SWIG_IsOK(ecode2)) {
15729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
15730 }
15731 arg2 = static_cast< long >(val2);
15732 }
15733 if (obj2) {
15734 ecode3 = SWIG_AsVal_int(obj2, &val3);
15735 if (!SWIG_IsOK(ecode3)) {
15736 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
15737 }
15738 arg3 = static_cast< int >(val3);
15739 }
15740 {
15741 PyThreadState* __tstate = wxPyBeginAllowThreads();
15742 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
15743 wxPyEndAllowThreads(__tstate);
15744 if (PyErr_Occurred()) SWIG_fail;
15745 }
15746 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15747 {
15748 if (created1) delete arg1;
15749 }
15750 return resultobj;
15751 fail:
15752 {
15753 if (created1) delete arg1;
15754 }
15755 return NULL;
15756 }
15757
15758
15759 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15760 PyObject *resultobj = 0;
15761 wxInputStream *arg1 = 0 ;
15762 wxString *arg2 = 0 ;
15763 int arg3 = (int) -1 ;
15764 wxImage *result = 0 ;
15765 wxPyInputStream *temp1 ;
15766 bool created1 ;
15767 bool temp2 = false ;
15768 int val3 ;
15769 int ecode3 = 0 ;
15770 PyObject * obj0 = 0 ;
15771 PyObject * obj1 = 0 ;
15772 PyObject * obj2 = 0 ;
15773 char * kwnames[] = {
15774 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
15775 };
15776
15777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15778 {
15779 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15780 arg1 = temp1->m_wxis;
15781 created1 = false;
15782 } else {
15783 PyErr_Clear(); // clear the failure of the wxPyConvert above
15784 arg1 = wxPyCBInputStream_create(obj0, false);
15785 if (arg1 == NULL) {
15786 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15787 SWIG_fail;
15788 }
15789 created1 = true;
15790 }
15791 }
15792 {
15793 arg2 = wxString_in_helper(obj1);
15794 if (arg2 == NULL) SWIG_fail;
15795 temp2 = true;
15796 }
15797 if (obj2) {
15798 ecode3 = SWIG_AsVal_int(obj2, &val3);
15799 if (!SWIG_IsOK(ecode3)) {
15800 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
15801 }
15802 arg3 = static_cast< int >(val3);
15803 }
15804 {
15805 PyThreadState* __tstate = wxPyBeginAllowThreads();
15806 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
15807 wxPyEndAllowThreads(__tstate);
15808 if (PyErr_Occurred()) SWIG_fail;
15809 }
15810 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15811 {
15812 if (created1) delete arg1;
15813 }
15814 {
15815 if (temp2)
15816 delete arg2;
15817 }
15818 return resultobj;
15819 fail:
15820 {
15821 if (created1) delete arg1;
15822 }
15823 {
15824 if (temp2)
15825 delete arg2;
15826 }
15827 return NULL;
15828 }
15829
15830
15831 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15832 PyObject *resultobj = 0;
15833 int arg1 = (int) 0 ;
15834 int arg2 = (int) 0 ;
15835 bool arg3 = (bool) true ;
15836 wxImage *result = 0 ;
15837 int val1 ;
15838 int ecode1 = 0 ;
15839 int val2 ;
15840 int ecode2 = 0 ;
15841 bool val3 ;
15842 int ecode3 = 0 ;
15843 PyObject * obj0 = 0 ;
15844 PyObject * obj1 = 0 ;
15845 PyObject * obj2 = 0 ;
15846 char * kwnames[] = {
15847 (char *) "width",(char *) "height",(char *) "clear", NULL
15848 };
15849
15850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15851 if (obj0) {
15852 ecode1 = SWIG_AsVal_int(obj0, &val1);
15853 if (!SWIG_IsOK(ecode1)) {
15854 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
15855 }
15856 arg1 = static_cast< int >(val1);
15857 }
15858 if (obj1) {
15859 ecode2 = SWIG_AsVal_int(obj1, &val2);
15860 if (!SWIG_IsOK(ecode2)) {
15861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
15862 }
15863 arg2 = static_cast< int >(val2);
15864 }
15865 if (obj2) {
15866 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15867 if (!SWIG_IsOK(ecode3)) {
15868 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
15869 }
15870 arg3 = static_cast< bool >(val3);
15871 }
15872 {
15873 PyThreadState* __tstate = wxPyBeginAllowThreads();
15874 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
15875 wxPyEndAllowThreads(__tstate);
15876 if (PyErr_Occurred()) SWIG_fail;
15877 }
15878 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15879 return resultobj;
15880 fail:
15881 return NULL;
15882 }
15883
15884
15885 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15886 PyObject *resultobj = 0;
15887 wxBitmap *arg1 = 0 ;
15888 wxImage *result = 0 ;
15889 void *argp1 = 0 ;
15890 int res1 = 0 ;
15891 PyObject * obj0 = 0 ;
15892 char * kwnames[] = {
15893 (char *) "bitmap", NULL
15894 };
15895
15896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
15897 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
15898 if (!SWIG_IsOK(res1)) {
15899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15900 }
15901 if (!argp1) {
15902 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15903 }
15904 arg1 = reinterpret_cast< wxBitmap * >(argp1);
15905 {
15906 if (!wxPyCheckForApp()) SWIG_fail;
15907 PyThreadState* __tstate = wxPyBeginAllowThreads();
15908 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
15909 wxPyEndAllowThreads(__tstate);
15910 if (PyErr_Occurred()) SWIG_fail;
15911 }
15912 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15913 return resultobj;
15914 fail:
15915 return NULL;
15916 }
15917
15918
15919 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15920 PyObject *resultobj = 0;
15921 int arg1 ;
15922 int arg2 ;
15923 buffer arg3 ;
15924 int arg4 ;
15925 wxImage *result = 0 ;
15926 int val1 ;
15927 int ecode1 = 0 ;
15928 int val2 ;
15929 int ecode2 = 0 ;
15930 Py_ssize_t temp3 ;
15931 PyObject * obj0 = 0 ;
15932 PyObject * obj1 = 0 ;
15933 PyObject * obj2 = 0 ;
15934 char * kwnames[] = {
15935 (char *) "width",(char *) "height",(char *) "data", NULL
15936 };
15937
15938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15939 ecode1 = SWIG_AsVal_int(obj0, &val1);
15940 if (!SWIG_IsOK(ecode1)) {
15941 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
15942 }
15943 arg1 = static_cast< int >(val1);
15944 ecode2 = SWIG_AsVal_int(obj1, &val2);
15945 if (!SWIG_IsOK(ecode2)) {
15946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
15947 }
15948 arg2 = static_cast< int >(val2);
15949 {
15950 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
15951 arg4 = (int)temp3;
15952 }
15953 {
15954 PyThreadState* __tstate = wxPyBeginAllowThreads();
15955 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
15956 wxPyEndAllowThreads(__tstate);
15957 if (PyErr_Occurred()) SWIG_fail;
15958 }
15959 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15960 return resultobj;
15961 fail:
15962 return NULL;
15963 }
15964
15965
15966 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15967 PyObject *resultobj = 0;
15968 int arg1 ;
15969 int arg2 ;
15970 buffer arg3 ;
15971 int arg4 ;
15972 buffer arg5 ;
15973 int arg6 ;
15974 wxImage *result = 0 ;
15975 int val1 ;
15976 int ecode1 = 0 ;
15977 int val2 ;
15978 int ecode2 = 0 ;
15979 Py_ssize_t temp3 ;
15980 Py_ssize_t temp5 ;
15981 PyObject * obj0 = 0 ;
15982 PyObject * obj1 = 0 ;
15983 PyObject * obj2 = 0 ;
15984 PyObject * obj3 = 0 ;
15985 char * kwnames[] = {
15986 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
15987 };
15988
15989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15990 ecode1 = SWIG_AsVal_int(obj0, &val1);
15991 if (!SWIG_IsOK(ecode1)) {
15992 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
15993 }
15994 arg1 = static_cast< int >(val1);
15995 ecode2 = SWIG_AsVal_int(obj1, &val2);
15996 if (!SWIG_IsOK(ecode2)) {
15997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
15998 }
15999 arg2 = static_cast< int >(val2);
16000 {
16001 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
16002 arg4 = (int)temp3;
16003 }
16004 {
16005 if (obj3 != Py_None) {
16006 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
16007 arg6 = (int)temp5;
16008 }
16009 }
16010 {
16011 PyThreadState* __tstate = wxPyBeginAllowThreads();
16012 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
16013 wxPyEndAllowThreads(__tstate);
16014 if (PyErr_Occurred()) SWIG_fail;
16015 }
16016 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16017 return resultobj;
16018 fail:
16019 return NULL;
16020 }
16021
16022
16023 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16024 PyObject *resultobj = 0;
16025 wxImage *arg1 = (wxImage *) 0 ;
16026 int arg2 ;
16027 int arg3 ;
16028 bool arg4 = (bool) true ;
16029 void *argp1 = 0 ;
16030 int res1 = 0 ;
16031 int val2 ;
16032 int ecode2 = 0 ;
16033 int val3 ;
16034 int ecode3 = 0 ;
16035 bool val4 ;
16036 int ecode4 = 0 ;
16037 PyObject * obj0 = 0 ;
16038 PyObject * obj1 = 0 ;
16039 PyObject * obj2 = 0 ;
16040 PyObject * obj3 = 0 ;
16041 char * kwnames[] = {
16042 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
16043 };
16044
16045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16047 if (!SWIG_IsOK(res1)) {
16048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
16049 }
16050 arg1 = reinterpret_cast< wxImage * >(argp1);
16051 ecode2 = SWIG_AsVal_int(obj1, &val2);
16052 if (!SWIG_IsOK(ecode2)) {
16053 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
16054 }
16055 arg2 = static_cast< int >(val2);
16056 ecode3 = SWIG_AsVal_int(obj2, &val3);
16057 if (!SWIG_IsOK(ecode3)) {
16058 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
16059 }
16060 arg3 = static_cast< int >(val3);
16061 if (obj3) {
16062 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16063 if (!SWIG_IsOK(ecode4)) {
16064 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
16065 }
16066 arg4 = static_cast< bool >(val4);
16067 }
16068 {
16069 PyThreadState* __tstate = wxPyBeginAllowThreads();
16070 (arg1)->Create(arg2,arg3,arg4);
16071 wxPyEndAllowThreads(__tstate);
16072 if (PyErr_Occurred()) SWIG_fail;
16073 }
16074 resultobj = SWIG_Py_Void();
16075 return resultobj;
16076 fail:
16077 return NULL;
16078 }
16079
16080
16081 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16082 PyObject *resultobj = 0;
16083 wxImage *arg1 = (wxImage *) 0 ;
16084 void *argp1 = 0 ;
16085 int res1 = 0 ;
16086 PyObject *swig_obj[1] ;
16087
16088 if (!args) SWIG_fail;
16089 swig_obj[0] = args;
16090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16091 if (!SWIG_IsOK(res1)) {
16092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
16093 }
16094 arg1 = reinterpret_cast< wxImage * >(argp1);
16095 {
16096 PyThreadState* __tstate = wxPyBeginAllowThreads();
16097 (arg1)->Destroy();
16098 wxPyEndAllowThreads(__tstate);
16099 if (PyErr_Occurred()) SWIG_fail;
16100 }
16101 resultobj = SWIG_Py_Void();
16102 return resultobj;
16103 fail:
16104 return NULL;
16105 }
16106
16107
16108 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16109 PyObject *resultobj = 0;
16110 wxImage *arg1 = (wxImage *) 0 ;
16111 int arg2 ;
16112 int arg3 ;
16113 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16114 SwigValueWrapper<wxImage > result;
16115 void *argp1 = 0 ;
16116 int res1 = 0 ;
16117 int val2 ;
16118 int ecode2 = 0 ;
16119 int val3 ;
16120 int ecode3 = 0 ;
16121 int val4 ;
16122 int ecode4 = 0 ;
16123 PyObject * obj0 = 0 ;
16124 PyObject * obj1 = 0 ;
16125 PyObject * obj2 = 0 ;
16126 PyObject * obj3 = 0 ;
16127 char * kwnames[] = {
16128 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16129 };
16130
16131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Scale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16133 if (!SWIG_IsOK(res1)) {
16134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
16135 }
16136 arg1 = reinterpret_cast< wxImage * >(argp1);
16137 ecode2 = SWIG_AsVal_int(obj1, &val2);
16138 if (!SWIG_IsOK(ecode2)) {
16139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
16140 }
16141 arg2 = static_cast< int >(val2);
16142 ecode3 = SWIG_AsVal_int(obj2, &val3);
16143 if (!SWIG_IsOK(ecode3)) {
16144 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
16145 }
16146 arg3 = static_cast< int >(val3);
16147 if (obj3) {
16148 ecode4 = SWIG_AsVal_int(obj3, &val4);
16149 if (!SWIG_IsOK(ecode4)) {
16150 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Scale" "', expected argument " "4"" of type '" "int""'");
16151 }
16152 arg4 = static_cast< int >(val4);
16153 }
16154 {
16155 PyThreadState* __tstate = wxPyBeginAllowThreads();
16156 result = (arg1)->Scale(arg2,arg3,arg4);
16157 wxPyEndAllowThreads(__tstate);
16158 if (PyErr_Occurred()) SWIG_fail;
16159 }
16160 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16161 return resultobj;
16162 fail:
16163 return NULL;
16164 }
16165
16166
16167 SWIGINTERN PyObject *_wrap_Image_ResampleBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16168 PyObject *resultobj = 0;
16169 wxImage *arg1 = (wxImage *) 0 ;
16170 int arg2 ;
16171 int arg3 ;
16172 SwigValueWrapper<wxImage > result;
16173 void *argp1 = 0 ;
16174 int res1 = 0 ;
16175 int val2 ;
16176 int ecode2 = 0 ;
16177 int val3 ;
16178 int ecode3 = 0 ;
16179 PyObject * obj0 = 0 ;
16180 PyObject * obj1 = 0 ;
16181 PyObject * obj2 = 0 ;
16182 char * kwnames[] = {
16183 (char *) "self",(char *) "width",(char *) "height", NULL
16184 };
16185
16186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16188 if (!SWIG_IsOK(res1)) {
16189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBox" "', expected argument " "1"" of type '" "wxImage const *""'");
16190 }
16191 arg1 = reinterpret_cast< wxImage * >(argp1);
16192 ecode2 = SWIG_AsVal_int(obj1, &val2);
16193 if (!SWIG_IsOK(ecode2)) {
16194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBox" "', expected argument " "2"" of type '" "int""'");
16195 }
16196 arg2 = static_cast< int >(val2);
16197 ecode3 = SWIG_AsVal_int(obj2, &val3);
16198 if (!SWIG_IsOK(ecode3)) {
16199 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBox" "', expected argument " "3"" of type '" "int""'");
16200 }
16201 arg3 = static_cast< int >(val3);
16202 {
16203 PyThreadState* __tstate = wxPyBeginAllowThreads();
16204 result = ((wxImage const *)arg1)->ResampleBox(arg2,arg3);
16205 wxPyEndAllowThreads(__tstate);
16206 if (PyErr_Occurred()) SWIG_fail;
16207 }
16208 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16209 return resultobj;
16210 fail:
16211 return NULL;
16212 }
16213
16214
16215 SWIGINTERN PyObject *_wrap_Image_ResampleBicubic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16216 PyObject *resultobj = 0;
16217 wxImage *arg1 = (wxImage *) 0 ;
16218 int arg2 ;
16219 int arg3 ;
16220 SwigValueWrapper<wxImage > result;
16221 void *argp1 = 0 ;
16222 int res1 = 0 ;
16223 int val2 ;
16224 int ecode2 = 0 ;
16225 int val3 ;
16226 int ecode3 = 0 ;
16227 PyObject * obj0 = 0 ;
16228 PyObject * obj1 = 0 ;
16229 PyObject * obj2 = 0 ;
16230 char * kwnames[] = {
16231 (char *) "self",(char *) "width",(char *) "height", NULL
16232 };
16233
16234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBicubic",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16236 if (!SWIG_IsOK(res1)) {
16237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBicubic" "', expected argument " "1"" of type '" "wxImage const *""'");
16238 }
16239 arg1 = reinterpret_cast< wxImage * >(argp1);
16240 ecode2 = SWIG_AsVal_int(obj1, &val2);
16241 if (!SWIG_IsOK(ecode2)) {
16242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBicubic" "', expected argument " "2"" of type '" "int""'");
16243 }
16244 arg2 = static_cast< int >(val2);
16245 ecode3 = SWIG_AsVal_int(obj2, &val3);
16246 if (!SWIG_IsOK(ecode3)) {
16247 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBicubic" "', expected argument " "3"" of type '" "int""'");
16248 }
16249 arg3 = static_cast< int >(val3);
16250 {
16251 PyThreadState* __tstate = wxPyBeginAllowThreads();
16252 result = ((wxImage const *)arg1)->ResampleBicubic(arg2,arg3);
16253 wxPyEndAllowThreads(__tstate);
16254 if (PyErr_Occurred()) SWIG_fail;
16255 }
16256 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16257 return resultobj;
16258 fail:
16259 return NULL;
16260 }
16261
16262
16263 SWIGINTERN PyObject *_wrap_Image_Blur(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16264 PyObject *resultobj = 0;
16265 wxImage *arg1 = (wxImage *) 0 ;
16266 int arg2 ;
16267 SwigValueWrapper<wxImage > result;
16268 void *argp1 = 0 ;
16269 int res1 = 0 ;
16270 int val2 ;
16271 int ecode2 = 0 ;
16272 PyObject * obj0 = 0 ;
16273 PyObject * obj1 = 0 ;
16274 char * kwnames[] = {
16275 (char *) "self",(char *) "radius", NULL
16276 };
16277
16278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_Blur",kwnames,&obj0,&obj1)) SWIG_fail;
16279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16280 if (!SWIG_IsOK(res1)) {
16281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Blur" "', expected argument " "1"" of type '" "wxImage *""'");
16282 }
16283 arg1 = reinterpret_cast< wxImage * >(argp1);
16284 ecode2 = SWIG_AsVal_int(obj1, &val2);
16285 if (!SWIG_IsOK(ecode2)) {
16286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Blur" "', expected argument " "2"" of type '" "int""'");
16287 }
16288 arg2 = static_cast< int >(val2);
16289 {
16290 PyThreadState* __tstate = wxPyBeginAllowThreads();
16291 result = (arg1)->Blur(arg2);
16292 wxPyEndAllowThreads(__tstate);
16293 if (PyErr_Occurred()) SWIG_fail;
16294 }
16295 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16296 return resultobj;
16297 fail:
16298 return NULL;
16299 }
16300
16301
16302 SWIGINTERN PyObject *_wrap_Image_BlurHorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16303 PyObject *resultobj = 0;
16304 wxImage *arg1 = (wxImage *) 0 ;
16305 int arg2 ;
16306 SwigValueWrapper<wxImage > result;
16307 void *argp1 = 0 ;
16308 int res1 = 0 ;
16309 int val2 ;
16310 int ecode2 = 0 ;
16311 PyObject * obj0 = 0 ;
16312 PyObject * obj1 = 0 ;
16313 char * kwnames[] = {
16314 (char *) "self",(char *) "radius", NULL
16315 };
16316
16317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurHorizontal",kwnames,&obj0,&obj1)) SWIG_fail;
16318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16319 if (!SWIG_IsOK(res1)) {
16320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurHorizontal" "', expected argument " "1"" of type '" "wxImage *""'");
16321 }
16322 arg1 = reinterpret_cast< wxImage * >(argp1);
16323 ecode2 = SWIG_AsVal_int(obj1, &val2);
16324 if (!SWIG_IsOK(ecode2)) {
16325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurHorizontal" "', expected argument " "2"" of type '" "int""'");
16326 }
16327 arg2 = static_cast< int >(val2);
16328 {
16329 PyThreadState* __tstate = wxPyBeginAllowThreads();
16330 result = (arg1)->BlurHorizontal(arg2);
16331 wxPyEndAllowThreads(__tstate);
16332 if (PyErr_Occurred()) SWIG_fail;
16333 }
16334 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16335 return resultobj;
16336 fail:
16337 return NULL;
16338 }
16339
16340
16341 SWIGINTERN PyObject *_wrap_Image_BlurVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16342 PyObject *resultobj = 0;
16343 wxImage *arg1 = (wxImage *) 0 ;
16344 int arg2 ;
16345 SwigValueWrapper<wxImage > result;
16346 void *argp1 = 0 ;
16347 int res1 = 0 ;
16348 int val2 ;
16349 int ecode2 = 0 ;
16350 PyObject * obj0 = 0 ;
16351 PyObject * obj1 = 0 ;
16352 char * kwnames[] = {
16353 (char *) "self",(char *) "radius", NULL
16354 };
16355
16356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurVertical",kwnames,&obj0,&obj1)) SWIG_fail;
16357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16358 if (!SWIG_IsOK(res1)) {
16359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurVertical" "', expected argument " "1"" of type '" "wxImage *""'");
16360 }
16361 arg1 = reinterpret_cast< wxImage * >(argp1);
16362 ecode2 = SWIG_AsVal_int(obj1, &val2);
16363 if (!SWIG_IsOK(ecode2)) {
16364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurVertical" "', expected argument " "2"" of type '" "int""'");
16365 }
16366 arg2 = static_cast< int >(val2);
16367 {
16368 PyThreadState* __tstate = wxPyBeginAllowThreads();
16369 result = (arg1)->BlurVertical(arg2);
16370 wxPyEndAllowThreads(__tstate);
16371 if (PyErr_Occurred()) SWIG_fail;
16372 }
16373 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16374 return resultobj;
16375 fail:
16376 return NULL;
16377 }
16378
16379
16380 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16381 PyObject *resultobj = 0;
16382 wxImage *arg1 = (wxImage *) 0 ;
16383 int arg2 ;
16384 int arg3 ;
16385 SwigValueWrapper<wxImage > result;
16386 void *argp1 = 0 ;
16387 int res1 = 0 ;
16388 int val2 ;
16389 int ecode2 = 0 ;
16390 int val3 ;
16391 int ecode3 = 0 ;
16392 PyObject * obj0 = 0 ;
16393 PyObject * obj1 = 0 ;
16394 PyObject * obj2 = 0 ;
16395 char * kwnames[] = {
16396 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
16397 };
16398
16399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16401 if (!SWIG_IsOK(res1)) {
16402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
16403 }
16404 arg1 = reinterpret_cast< wxImage * >(argp1);
16405 ecode2 = SWIG_AsVal_int(obj1, &val2);
16406 if (!SWIG_IsOK(ecode2)) {
16407 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
16408 }
16409 arg2 = static_cast< int >(val2);
16410 ecode3 = SWIG_AsVal_int(obj2, &val3);
16411 if (!SWIG_IsOK(ecode3)) {
16412 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
16413 }
16414 arg3 = static_cast< int >(val3);
16415 {
16416 PyThreadState* __tstate = wxPyBeginAllowThreads();
16417 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
16418 wxPyEndAllowThreads(__tstate);
16419 if (PyErr_Occurred()) SWIG_fail;
16420 }
16421 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16422 return resultobj;
16423 fail:
16424 return NULL;
16425 }
16426
16427
16428 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16429 PyObject *resultobj = 0;
16430 wxImage *arg1 = (wxImage *) 0 ;
16431 int arg2 ;
16432 int arg3 ;
16433 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16434 wxImage *result = 0 ;
16435 void *argp1 = 0 ;
16436 int res1 = 0 ;
16437 int val2 ;
16438 int ecode2 = 0 ;
16439 int val3 ;
16440 int ecode3 = 0 ;
16441 int val4 ;
16442 int ecode4 = 0 ;
16443 PyObject * obj0 = 0 ;
16444 PyObject * obj1 = 0 ;
16445 PyObject * obj2 = 0 ;
16446 PyObject * obj3 = 0 ;
16447 char * kwnames[] = {
16448 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16449 };
16450
16451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Rescale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16453 if (!SWIG_IsOK(res1)) {
16454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
16455 }
16456 arg1 = reinterpret_cast< wxImage * >(argp1);
16457 ecode2 = SWIG_AsVal_int(obj1, &val2);
16458 if (!SWIG_IsOK(ecode2)) {
16459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
16460 }
16461 arg2 = static_cast< int >(val2);
16462 ecode3 = SWIG_AsVal_int(obj2, &val3);
16463 if (!SWIG_IsOK(ecode3)) {
16464 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
16465 }
16466 arg3 = static_cast< int >(val3);
16467 if (obj3) {
16468 ecode4 = SWIG_AsVal_int(obj3, &val4);
16469 if (!SWIG_IsOK(ecode4)) {
16470 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rescale" "', expected argument " "4"" of type '" "int""'");
16471 }
16472 arg4 = static_cast< int >(val4);
16473 }
16474 {
16475 PyThreadState* __tstate = wxPyBeginAllowThreads();
16476 {
16477 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3,arg4);
16478 result = (wxImage *) &_result_ref;
16479 }
16480 wxPyEndAllowThreads(__tstate);
16481 if (PyErr_Occurred()) SWIG_fail;
16482 }
16483 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16484 return resultobj;
16485 fail:
16486 return NULL;
16487 }
16488
16489
16490 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16491 PyObject *resultobj = 0;
16492 wxImage *arg1 = (wxImage *) 0 ;
16493 wxSize *arg2 = 0 ;
16494 wxPoint *arg3 = 0 ;
16495 int arg4 = (int) -1 ;
16496 int arg5 = (int) -1 ;
16497 int arg6 = (int) -1 ;
16498 wxImage *result = 0 ;
16499 void *argp1 = 0 ;
16500 int res1 = 0 ;
16501 wxSize temp2 ;
16502 wxPoint temp3 ;
16503 int val4 ;
16504 int ecode4 = 0 ;
16505 int val5 ;
16506 int ecode5 = 0 ;
16507 int val6 ;
16508 int ecode6 = 0 ;
16509 PyObject * obj0 = 0 ;
16510 PyObject * obj1 = 0 ;
16511 PyObject * obj2 = 0 ;
16512 PyObject * obj3 = 0 ;
16513 PyObject * obj4 = 0 ;
16514 PyObject * obj5 = 0 ;
16515 char * kwnames[] = {
16516 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
16517 };
16518
16519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16521 if (!SWIG_IsOK(res1)) {
16522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
16523 }
16524 arg1 = reinterpret_cast< wxImage * >(argp1);
16525 {
16526 arg2 = &temp2;
16527 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
16528 }
16529 {
16530 arg3 = &temp3;
16531 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16532 }
16533 if (obj3) {
16534 ecode4 = SWIG_AsVal_int(obj3, &val4);
16535 if (!SWIG_IsOK(ecode4)) {
16536 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
16537 }
16538 arg4 = static_cast< int >(val4);
16539 }
16540 if (obj4) {
16541 ecode5 = SWIG_AsVal_int(obj4, &val5);
16542 if (!SWIG_IsOK(ecode5)) {
16543 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
16544 }
16545 arg5 = static_cast< int >(val5);
16546 }
16547 if (obj5) {
16548 ecode6 = SWIG_AsVal_int(obj5, &val6);
16549 if (!SWIG_IsOK(ecode6)) {
16550 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
16551 }
16552 arg6 = static_cast< int >(val6);
16553 }
16554 {
16555 PyThreadState* __tstate = wxPyBeginAllowThreads();
16556 {
16557 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
16558 result = (wxImage *) &_result_ref;
16559 }
16560 wxPyEndAllowThreads(__tstate);
16561 if (PyErr_Occurred()) SWIG_fail;
16562 }
16563 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16564 return resultobj;
16565 fail:
16566 return NULL;
16567 }
16568
16569
16570 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16571 PyObject *resultobj = 0;
16572 wxImage *arg1 = (wxImage *) 0 ;
16573 int arg2 ;
16574 int arg3 ;
16575 byte arg4 ;
16576 byte arg5 ;
16577 byte arg6 ;
16578 void *argp1 = 0 ;
16579 int res1 = 0 ;
16580 int val2 ;
16581 int ecode2 = 0 ;
16582 int val3 ;
16583 int ecode3 = 0 ;
16584 unsigned char val4 ;
16585 int ecode4 = 0 ;
16586 unsigned char val5 ;
16587 int ecode5 = 0 ;
16588 unsigned char val6 ;
16589 int ecode6 = 0 ;
16590 PyObject * obj0 = 0 ;
16591 PyObject * obj1 = 0 ;
16592 PyObject * obj2 = 0 ;
16593 PyObject * obj3 = 0 ;
16594 PyObject * obj4 = 0 ;
16595 PyObject * obj5 = 0 ;
16596 char * kwnames[] = {
16597 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
16598 };
16599
16600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16602 if (!SWIG_IsOK(res1)) {
16603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
16604 }
16605 arg1 = reinterpret_cast< wxImage * >(argp1);
16606 ecode2 = SWIG_AsVal_int(obj1, &val2);
16607 if (!SWIG_IsOK(ecode2)) {
16608 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
16609 }
16610 arg2 = static_cast< int >(val2);
16611 ecode3 = SWIG_AsVal_int(obj2, &val3);
16612 if (!SWIG_IsOK(ecode3)) {
16613 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
16614 }
16615 arg3 = static_cast< int >(val3);
16616 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16617 if (!SWIG_IsOK(ecode4)) {
16618 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
16619 }
16620 arg4 = static_cast< byte >(val4);
16621 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16622 if (!SWIG_IsOK(ecode5)) {
16623 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
16624 }
16625 arg5 = static_cast< byte >(val5);
16626 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16627 if (!SWIG_IsOK(ecode6)) {
16628 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
16629 }
16630 arg6 = static_cast< byte >(val6);
16631 {
16632 PyThreadState* __tstate = wxPyBeginAllowThreads();
16633 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
16634 wxPyEndAllowThreads(__tstate);
16635 if (PyErr_Occurred()) SWIG_fail;
16636 }
16637 resultobj = SWIG_Py_Void();
16638 return resultobj;
16639 fail:
16640 return NULL;
16641 }
16642
16643
16644 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16645 PyObject *resultobj = 0;
16646 wxImage *arg1 = (wxImage *) 0 ;
16647 wxRect *arg2 = 0 ;
16648 byte arg3 ;
16649 byte arg4 ;
16650 byte arg5 ;
16651 void *argp1 = 0 ;
16652 int res1 = 0 ;
16653 wxRect temp2 ;
16654 unsigned char val3 ;
16655 int ecode3 = 0 ;
16656 unsigned char val4 ;
16657 int ecode4 = 0 ;
16658 unsigned char val5 ;
16659 int ecode5 = 0 ;
16660 PyObject * obj0 = 0 ;
16661 PyObject * obj1 = 0 ;
16662 PyObject * obj2 = 0 ;
16663 PyObject * obj3 = 0 ;
16664 PyObject * obj4 = 0 ;
16665 char * kwnames[] = {
16666 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
16667 };
16668
16669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16671 if (!SWIG_IsOK(res1)) {
16672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
16673 }
16674 arg1 = reinterpret_cast< wxImage * >(argp1);
16675 {
16676 arg2 = &temp2;
16677 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
16678 }
16679 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16680 if (!SWIG_IsOK(ecode3)) {
16681 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
16682 }
16683 arg3 = static_cast< byte >(val3);
16684 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16685 if (!SWIG_IsOK(ecode4)) {
16686 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
16687 }
16688 arg4 = static_cast< byte >(val4);
16689 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16690 if (!SWIG_IsOK(ecode5)) {
16691 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
16692 }
16693 arg5 = static_cast< byte >(val5);
16694 {
16695 PyThreadState* __tstate = wxPyBeginAllowThreads();
16696 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
16697 wxPyEndAllowThreads(__tstate);
16698 if (PyErr_Occurred()) SWIG_fail;
16699 }
16700 resultobj = SWIG_Py_Void();
16701 return resultobj;
16702 fail:
16703 return NULL;
16704 }
16705
16706
16707 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16708 PyObject *resultobj = 0;
16709 wxImage *arg1 = (wxImage *) 0 ;
16710 int arg2 ;
16711 int arg3 ;
16712 byte result;
16713 void *argp1 = 0 ;
16714 int res1 = 0 ;
16715 int val2 ;
16716 int ecode2 = 0 ;
16717 int val3 ;
16718 int ecode3 = 0 ;
16719 PyObject * obj0 = 0 ;
16720 PyObject * obj1 = 0 ;
16721 PyObject * obj2 = 0 ;
16722 char * kwnames[] = {
16723 (char *) "self",(char *) "x",(char *) "y", NULL
16724 };
16725
16726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16728 if (!SWIG_IsOK(res1)) {
16729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
16730 }
16731 arg1 = reinterpret_cast< wxImage * >(argp1);
16732 ecode2 = SWIG_AsVal_int(obj1, &val2);
16733 if (!SWIG_IsOK(ecode2)) {
16734 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
16735 }
16736 arg2 = static_cast< int >(val2);
16737 ecode3 = SWIG_AsVal_int(obj2, &val3);
16738 if (!SWIG_IsOK(ecode3)) {
16739 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
16740 }
16741 arg3 = static_cast< int >(val3);
16742 {
16743 PyThreadState* __tstate = wxPyBeginAllowThreads();
16744 result = (byte)(arg1)->GetRed(arg2,arg3);
16745 wxPyEndAllowThreads(__tstate);
16746 if (PyErr_Occurred()) SWIG_fail;
16747 }
16748 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16749 return resultobj;
16750 fail:
16751 return NULL;
16752 }
16753
16754
16755 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16756 PyObject *resultobj = 0;
16757 wxImage *arg1 = (wxImage *) 0 ;
16758 int arg2 ;
16759 int arg3 ;
16760 byte result;
16761 void *argp1 = 0 ;
16762 int res1 = 0 ;
16763 int val2 ;
16764 int ecode2 = 0 ;
16765 int val3 ;
16766 int ecode3 = 0 ;
16767 PyObject * obj0 = 0 ;
16768 PyObject * obj1 = 0 ;
16769 PyObject * obj2 = 0 ;
16770 char * kwnames[] = {
16771 (char *) "self",(char *) "x",(char *) "y", NULL
16772 };
16773
16774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16776 if (!SWIG_IsOK(res1)) {
16777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
16778 }
16779 arg1 = reinterpret_cast< wxImage * >(argp1);
16780 ecode2 = SWIG_AsVal_int(obj1, &val2);
16781 if (!SWIG_IsOK(ecode2)) {
16782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
16783 }
16784 arg2 = static_cast< int >(val2);
16785 ecode3 = SWIG_AsVal_int(obj2, &val3);
16786 if (!SWIG_IsOK(ecode3)) {
16787 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
16788 }
16789 arg3 = static_cast< int >(val3);
16790 {
16791 PyThreadState* __tstate = wxPyBeginAllowThreads();
16792 result = (byte)(arg1)->GetGreen(arg2,arg3);
16793 wxPyEndAllowThreads(__tstate);
16794 if (PyErr_Occurred()) SWIG_fail;
16795 }
16796 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16797 return resultobj;
16798 fail:
16799 return NULL;
16800 }
16801
16802
16803 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16804 PyObject *resultobj = 0;
16805 wxImage *arg1 = (wxImage *) 0 ;
16806 int arg2 ;
16807 int arg3 ;
16808 byte result;
16809 void *argp1 = 0 ;
16810 int res1 = 0 ;
16811 int val2 ;
16812 int ecode2 = 0 ;
16813 int val3 ;
16814 int ecode3 = 0 ;
16815 PyObject * obj0 = 0 ;
16816 PyObject * obj1 = 0 ;
16817 PyObject * obj2 = 0 ;
16818 char * kwnames[] = {
16819 (char *) "self",(char *) "x",(char *) "y", NULL
16820 };
16821
16822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16824 if (!SWIG_IsOK(res1)) {
16825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
16826 }
16827 arg1 = reinterpret_cast< wxImage * >(argp1);
16828 ecode2 = SWIG_AsVal_int(obj1, &val2);
16829 if (!SWIG_IsOK(ecode2)) {
16830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
16831 }
16832 arg2 = static_cast< int >(val2);
16833 ecode3 = SWIG_AsVal_int(obj2, &val3);
16834 if (!SWIG_IsOK(ecode3)) {
16835 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
16836 }
16837 arg3 = static_cast< int >(val3);
16838 {
16839 PyThreadState* __tstate = wxPyBeginAllowThreads();
16840 result = (byte)(arg1)->GetBlue(arg2,arg3);
16841 wxPyEndAllowThreads(__tstate);
16842 if (PyErr_Occurred()) SWIG_fail;
16843 }
16844 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16845 return resultobj;
16846 fail:
16847 return NULL;
16848 }
16849
16850
16851 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16852 PyObject *resultobj = 0;
16853 wxImage *arg1 = (wxImage *) 0 ;
16854 int arg2 ;
16855 int arg3 ;
16856 byte arg4 ;
16857 void *argp1 = 0 ;
16858 int res1 = 0 ;
16859 int val2 ;
16860 int ecode2 = 0 ;
16861 int val3 ;
16862 int ecode3 = 0 ;
16863 unsigned char val4 ;
16864 int ecode4 = 0 ;
16865 PyObject * obj0 = 0 ;
16866 PyObject * obj1 = 0 ;
16867 PyObject * obj2 = 0 ;
16868 PyObject * obj3 = 0 ;
16869 char * kwnames[] = {
16870 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
16871 };
16872
16873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16875 if (!SWIG_IsOK(res1)) {
16876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16877 }
16878 arg1 = reinterpret_cast< wxImage * >(argp1);
16879 ecode2 = SWIG_AsVal_int(obj1, &val2);
16880 if (!SWIG_IsOK(ecode2)) {
16881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
16882 }
16883 arg2 = static_cast< int >(val2);
16884 ecode3 = SWIG_AsVal_int(obj2, &val3);
16885 if (!SWIG_IsOK(ecode3)) {
16886 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
16887 }
16888 arg3 = static_cast< int >(val3);
16889 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16890 if (!SWIG_IsOK(ecode4)) {
16891 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
16892 }
16893 arg4 = static_cast< byte >(val4);
16894 {
16895 PyThreadState* __tstate = wxPyBeginAllowThreads();
16896 (arg1)->SetAlpha(arg2,arg3,arg4);
16897 wxPyEndAllowThreads(__tstate);
16898 if (PyErr_Occurred()) SWIG_fail;
16899 }
16900 resultobj = SWIG_Py_Void();
16901 return resultobj;
16902 fail:
16903 return NULL;
16904 }
16905
16906
16907 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16908 PyObject *resultobj = 0;
16909 wxImage *arg1 = (wxImage *) 0 ;
16910 int arg2 ;
16911 int arg3 ;
16912 byte result;
16913 void *argp1 = 0 ;
16914 int res1 = 0 ;
16915 int val2 ;
16916 int ecode2 = 0 ;
16917 int val3 ;
16918 int ecode3 = 0 ;
16919 PyObject * obj0 = 0 ;
16920 PyObject * obj1 = 0 ;
16921 PyObject * obj2 = 0 ;
16922 char * kwnames[] = {
16923 (char *) "self",(char *) "x",(char *) "y", NULL
16924 };
16925
16926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16928 if (!SWIG_IsOK(res1)) {
16929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16930 }
16931 arg1 = reinterpret_cast< wxImage * >(argp1);
16932 ecode2 = SWIG_AsVal_int(obj1, &val2);
16933 if (!SWIG_IsOK(ecode2)) {
16934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
16935 }
16936 arg2 = static_cast< int >(val2);
16937 ecode3 = SWIG_AsVal_int(obj2, &val3);
16938 if (!SWIG_IsOK(ecode3)) {
16939 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
16940 }
16941 arg3 = static_cast< int >(val3);
16942 {
16943 PyThreadState* __tstate = wxPyBeginAllowThreads();
16944 result = (byte)(arg1)->GetAlpha(arg2,arg3);
16945 wxPyEndAllowThreads(__tstate);
16946 if (PyErr_Occurred()) SWIG_fail;
16947 }
16948 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16949 return resultobj;
16950 fail:
16951 return NULL;
16952 }
16953
16954
16955 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16956 PyObject *resultobj = 0;
16957 wxImage *arg1 = (wxImage *) 0 ;
16958 bool result;
16959 void *argp1 = 0 ;
16960 int res1 = 0 ;
16961 PyObject *swig_obj[1] ;
16962
16963 if (!args) SWIG_fail;
16964 swig_obj[0] = args;
16965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16966 if (!SWIG_IsOK(res1)) {
16967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16968 }
16969 arg1 = reinterpret_cast< wxImage * >(argp1);
16970 {
16971 PyThreadState* __tstate = wxPyBeginAllowThreads();
16972 result = (bool)(arg1)->HasAlpha();
16973 wxPyEndAllowThreads(__tstate);
16974 if (PyErr_Occurred()) SWIG_fail;
16975 }
16976 {
16977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16978 }
16979 return resultobj;
16980 fail:
16981 return NULL;
16982 }
16983
16984
16985 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16986 PyObject *resultobj = 0;
16987 wxImage *arg1 = (wxImage *) 0 ;
16988 void *argp1 = 0 ;
16989 int res1 = 0 ;
16990 PyObject *swig_obj[1] ;
16991
16992 if (!args) SWIG_fail;
16993 swig_obj[0] = args;
16994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16995 if (!SWIG_IsOK(res1)) {
16996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16997 }
16998 arg1 = reinterpret_cast< wxImage * >(argp1);
16999 {
17000 PyThreadState* __tstate = wxPyBeginAllowThreads();
17001 (arg1)->InitAlpha();
17002 wxPyEndAllowThreads(__tstate);
17003 if (PyErr_Occurred()) SWIG_fail;
17004 }
17005 resultobj = SWIG_Py_Void();
17006 return resultobj;
17007 fail:
17008 return NULL;
17009 }
17010
17011
17012 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17013 PyObject *resultobj = 0;
17014 wxImage *arg1 = (wxImage *) 0 ;
17015 int arg2 ;
17016 int arg3 ;
17017 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
17018 bool result;
17019 void *argp1 = 0 ;
17020 int res1 = 0 ;
17021 int val2 ;
17022 int ecode2 = 0 ;
17023 int val3 ;
17024 int ecode3 = 0 ;
17025 unsigned char val4 ;
17026 int ecode4 = 0 ;
17027 PyObject * obj0 = 0 ;
17028 PyObject * obj1 = 0 ;
17029 PyObject * obj2 = 0 ;
17030 PyObject * obj3 = 0 ;
17031 char * kwnames[] = {
17032 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
17033 };
17034
17035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17037 if (!SWIG_IsOK(res1)) {
17038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
17039 }
17040 arg1 = reinterpret_cast< wxImage * >(argp1);
17041 ecode2 = SWIG_AsVal_int(obj1, &val2);
17042 if (!SWIG_IsOK(ecode2)) {
17043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
17044 }
17045 arg2 = static_cast< int >(val2);
17046 ecode3 = SWIG_AsVal_int(obj2, &val3);
17047 if (!SWIG_IsOK(ecode3)) {
17048 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
17049 }
17050 arg3 = static_cast< int >(val3);
17051 if (obj3) {
17052 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17053 if (!SWIG_IsOK(ecode4)) {
17054 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
17055 }
17056 arg4 = static_cast< byte >(val4);
17057 }
17058 {
17059 PyThreadState* __tstate = wxPyBeginAllowThreads();
17060 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
17061 wxPyEndAllowThreads(__tstate);
17062 if (PyErr_Occurred()) SWIG_fail;
17063 }
17064 {
17065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17066 }
17067 return resultobj;
17068 fail:
17069 return NULL;
17070 }
17071
17072
17073 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17074 PyObject *resultobj = 0;
17075 wxImage *arg1 = (wxImage *) 0 ;
17076 byte *arg2 = (byte *) 0 ;
17077 byte *arg3 = (byte *) 0 ;
17078 byte *arg4 = (byte *) 0 ;
17079 byte arg5 = (byte) 0 ;
17080 byte arg6 = (byte) 0 ;
17081 byte arg7 = (byte) 0 ;
17082 bool result;
17083 void *argp1 = 0 ;
17084 int res1 = 0 ;
17085 byte temp2 ;
17086 int res2 = SWIG_TMPOBJ ;
17087 byte temp3 ;
17088 int res3 = SWIG_TMPOBJ ;
17089 byte temp4 ;
17090 int res4 = SWIG_TMPOBJ ;
17091 unsigned char val5 ;
17092 int ecode5 = 0 ;
17093 unsigned char val6 ;
17094 int ecode6 = 0 ;
17095 unsigned char val7 ;
17096 int ecode7 = 0 ;
17097 PyObject * obj0 = 0 ;
17098 PyObject * obj1 = 0 ;
17099 PyObject * obj2 = 0 ;
17100 PyObject * obj3 = 0 ;
17101 char * kwnames[] = {
17102 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
17103 };
17104
17105 arg2 = &temp2;
17106 arg3 = &temp3;
17107 arg4 = &temp4;
17108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17110 if (!SWIG_IsOK(res1)) {
17111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
17112 }
17113 arg1 = reinterpret_cast< wxImage * >(argp1);
17114 if (obj1) {
17115 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
17116 if (!SWIG_IsOK(ecode5)) {
17117 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
17118 }
17119 arg5 = static_cast< byte >(val5);
17120 }
17121 if (obj2) {
17122 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
17123 if (!SWIG_IsOK(ecode6)) {
17124 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
17125 }
17126 arg6 = static_cast< byte >(val6);
17127 }
17128 if (obj3) {
17129 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
17130 if (!SWIG_IsOK(ecode7)) {
17131 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
17132 }
17133 arg7 = static_cast< byte >(val7);
17134 }
17135 {
17136 PyThreadState* __tstate = wxPyBeginAllowThreads();
17137 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
17138 wxPyEndAllowThreads(__tstate);
17139 if (PyErr_Occurred()) SWIG_fail;
17140 }
17141 {
17142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17143 }
17144 if (SWIG_IsTmpObj(res2)) {
17145 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
17146 } else {
17147 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17148 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
17149 }
17150 if (SWIG_IsTmpObj(res3)) {
17151 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
17152 } else {
17153 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17154 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
17155 }
17156 if (SWIG_IsTmpObj(res4)) {
17157 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
17158 } else {
17159 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17160 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
17161 }
17162 return resultobj;
17163 fail:
17164 return NULL;
17165 }
17166
17167
17168 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17169 PyObject *resultobj = 0;
17170 wxImage *arg1 = (wxImage *) 0 ;
17171 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
17172 bool result;
17173 void *argp1 = 0 ;
17174 int res1 = 0 ;
17175 unsigned char val2 ;
17176 int ecode2 = 0 ;
17177 PyObject * obj0 = 0 ;
17178 PyObject * obj1 = 0 ;
17179 char * kwnames[] = {
17180 (char *) "self",(char *) "threshold", NULL
17181 };
17182
17183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
17184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17185 if (!SWIG_IsOK(res1)) {
17186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
17187 }
17188 arg1 = reinterpret_cast< wxImage * >(argp1);
17189 if (obj1) {
17190 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17191 if (!SWIG_IsOK(ecode2)) {
17192 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
17193 }
17194 arg2 = static_cast< byte >(val2);
17195 }
17196 {
17197 PyThreadState* __tstate = wxPyBeginAllowThreads();
17198 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
17199 wxPyEndAllowThreads(__tstate);
17200 if (PyErr_Occurred()) SWIG_fail;
17201 }
17202 {
17203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17204 }
17205 return resultobj;
17206 fail:
17207 return NULL;
17208 }
17209
17210
17211 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17212 PyObject *resultobj = 0;
17213 wxImage *arg1 = (wxImage *) 0 ;
17214 byte arg2 ;
17215 byte arg3 ;
17216 byte arg4 ;
17217 bool result;
17218 void *argp1 = 0 ;
17219 int res1 = 0 ;
17220 unsigned char val2 ;
17221 int ecode2 = 0 ;
17222 unsigned char val3 ;
17223 int ecode3 = 0 ;
17224 unsigned char val4 ;
17225 int ecode4 = 0 ;
17226 PyObject * obj0 = 0 ;
17227 PyObject * obj1 = 0 ;
17228 PyObject * obj2 = 0 ;
17229 PyObject * obj3 = 0 ;
17230 char * kwnames[] = {
17231 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
17232 };
17233
17234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17236 if (!SWIG_IsOK(res1)) {
17237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17238 }
17239 arg1 = reinterpret_cast< wxImage * >(argp1);
17240 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17241 if (!SWIG_IsOK(ecode2)) {
17242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
17243 }
17244 arg2 = static_cast< byte >(val2);
17245 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17246 if (!SWIG_IsOK(ecode3)) {
17247 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
17248 }
17249 arg3 = static_cast< byte >(val3);
17250 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17251 if (!SWIG_IsOK(ecode4)) {
17252 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
17253 }
17254 arg4 = static_cast< byte >(val4);
17255 {
17256 PyThreadState* __tstate = wxPyBeginAllowThreads();
17257 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
17258 wxPyEndAllowThreads(__tstate);
17259 if (PyErr_Occurred()) SWIG_fail;
17260 }
17261 {
17262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17263 }
17264 return resultobj;
17265 fail:
17266 return NULL;
17267 }
17268
17269
17270 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17271 PyObject *resultobj = 0;
17272 wxImage *arg1 = (wxImage *) 0 ;
17273 wxImage *arg2 = 0 ;
17274 byte arg3 ;
17275 byte arg4 ;
17276 byte arg5 ;
17277 bool result;
17278 void *argp1 = 0 ;
17279 int res1 = 0 ;
17280 void *argp2 = 0 ;
17281 int res2 = 0 ;
17282 unsigned char val3 ;
17283 int ecode3 = 0 ;
17284 unsigned char val4 ;
17285 int ecode4 = 0 ;
17286 unsigned char val5 ;
17287 int ecode5 = 0 ;
17288 PyObject * obj0 = 0 ;
17289 PyObject * obj1 = 0 ;
17290 PyObject * obj2 = 0 ;
17291 PyObject * obj3 = 0 ;
17292 PyObject * obj4 = 0 ;
17293 char * kwnames[] = {
17294 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
17295 };
17296
17297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17299 if (!SWIG_IsOK(res1)) {
17300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
17301 }
17302 arg1 = reinterpret_cast< wxImage * >(argp1);
17303 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
17304 if (!SWIG_IsOK(res2)) {
17305 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17306 }
17307 if (!argp2) {
17308 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17309 }
17310 arg2 = reinterpret_cast< wxImage * >(argp2);
17311 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17312 if (!SWIG_IsOK(ecode3)) {
17313 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
17314 }
17315 arg3 = static_cast< byte >(val3);
17316 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17317 if (!SWIG_IsOK(ecode4)) {
17318 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
17319 }
17320 arg4 = static_cast< byte >(val4);
17321 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
17322 if (!SWIG_IsOK(ecode5)) {
17323 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
17324 }
17325 arg5 = static_cast< byte >(val5);
17326 {
17327 PyThreadState* __tstate = wxPyBeginAllowThreads();
17328 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
17329 wxPyEndAllowThreads(__tstate);
17330 if (PyErr_Occurred()) SWIG_fail;
17331 }
17332 {
17333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17334 }
17335 return resultobj;
17336 fail:
17337 return NULL;
17338 }
17339
17340
17341 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17342 PyObject *resultobj = 0;
17343 wxString *arg1 = 0 ;
17344 bool result;
17345 bool temp1 = false ;
17346 PyObject * obj0 = 0 ;
17347 char * kwnames[] = {
17348 (char *) "filename", NULL
17349 };
17350
17351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
17352 {
17353 arg1 = wxString_in_helper(obj0);
17354 if (arg1 == NULL) SWIG_fail;
17355 temp1 = true;
17356 }
17357 {
17358 PyThreadState* __tstate = wxPyBeginAllowThreads();
17359 result = (bool)wxImage::CanRead((wxString const &)*arg1);
17360 wxPyEndAllowThreads(__tstate);
17361 if (PyErr_Occurred()) SWIG_fail;
17362 }
17363 {
17364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17365 }
17366 {
17367 if (temp1)
17368 delete arg1;
17369 }
17370 return resultobj;
17371 fail:
17372 {
17373 if (temp1)
17374 delete arg1;
17375 }
17376 return NULL;
17377 }
17378
17379
17380 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17381 PyObject *resultobj = 0;
17382 wxString *arg1 = 0 ;
17383 long arg2 = (long) wxBITMAP_TYPE_ANY ;
17384 int result;
17385 bool temp1 = false ;
17386 long val2 ;
17387 int ecode2 = 0 ;
17388 PyObject * obj0 = 0 ;
17389 PyObject * obj1 = 0 ;
17390 char * kwnames[] = {
17391 (char *) "filename",(char *) "type", NULL
17392 };
17393
17394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
17395 {
17396 arg1 = wxString_in_helper(obj0);
17397 if (arg1 == NULL) SWIG_fail;
17398 temp1 = true;
17399 }
17400 if (obj1) {
17401 ecode2 = SWIG_AsVal_long(obj1, &val2);
17402 if (!SWIG_IsOK(ecode2)) {
17403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
17404 }
17405 arg2 = static_cast< long >(val2);
17406 }
17407 {
17408 PyThreadState* __tstate = wxPyBeginAllowThreads();
17409 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
17410 wxPyEndAllowThreads(__tstate);
17411 if (PyErr_Occurred()) SWIG_fail;
17412 }
17413 resultobj = SWIG_From_int(static_cast< int >(result));
17414 {
17415 if (temp1)
17416 delete arg1;
17417 }
17418 return resultobj;
17419 fail:
17420 {
17421 if (temp1)
17422 delete arg1;
17423 }
17424 return NULL;
17425 }
17426
17427
17428 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17429 PyObject *resultobj = 0;
17430 wxImage *arg1 = (wxImage *) 0 ;
17431 wxString *arg2 = 0 ;
17432 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17433 int arg4 = (int) -1 ;
17434 bool result;
17435 void *argp1 = 0 ;
17436 int res1 = 0 ;
17437 bool temp2 = false ;
17438 long val3 ;
17439 int ecode3 = 0 ;
17440 int val4 ;
17441 int ecode4 = 0 ;
17442 PyObject * obj0 = 0 ;
17443 PyObject * obj1 = 0 ;
17444 PyObject * obj2 = 0 ;
17445 PyObject * obj3 = 0 ;
17446 char * kwnames[] = {
17447 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
17448 };
17449
17450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17452 if (!SWIG_IsOK(res1)) {
17453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
17454 }
17455 arg1 = reinterpret_cast< wxImage * >(argp1);
17456 {
17457 arg2 = wxString_in_helper(obj1);
17458 if (arg2 == NULL) SWIG_fail;
17459 temp2 = true;
17460 }
17461 if (obj2) {
17462 ecode3 = SWIG_AsVal_long(obj2, &val3);
17463 if (!SWIG_IsOK(ecode3)) {
17464 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
17465 }
17466 arg3 = static_cast< long >(val3);
17467 }
17468 if (obj3) {
17469 ecode4 = SWIG_AsVal_int(obj3, &val4);
17470 if (!SWIG_IsOK(ecode4)) {
17471 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
17472 }
17473 arg4 = static_cast< int >(val4);
17474 }
17475 {
17476 PyThreadState* __tstate = wxPyBeginAllowThreads();
17477 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
17478 wxPyEndAllowThreads(__tstate);
17479 if (PyErr_Occurred()) SWIG_fail;
17480 }
17481 {
17482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17483 }
17484 {
17485 if (temp2)
17486 delete arg2;
17487 }
17488 return resultobj;
17489 fail:
17490 {
17491 if (temp2)
17492 delete arg2;
17493 }
17494 return NULL;
17495 }
17496
17497
17498 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17499 PyObject *resultobj = 0;
17500 wxImage *arg1 = (wxImage *) 0 ;
17501 wxString *arg2 = 0 ;
17502 wxString *arg3 = 0 ;
17503 int arg4 = (int) -1 ;
17504 bool result;
17505 void *argp1 = 0 ;
17506 int res1 = 0 ;
17507 bool temp2 = false ;
17508 bool temp3 = false ;
17509 int val4 ;
17510 int ecode4 = 0 ;
17511 PyObject * obj0 = 0 ;
17512 PyObject * obj1 = 0 ;
17513 PyObject * obj2 = 0 ;
17514 PyObject * obj3 = 0 ;
17515 char * kwnames[] = {
17516 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
17517 };
17518
17519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17521 if (!SWIG_IsOK(res1)) {
17522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17523 }
17524 arg1 = reinterpret_cast< wxImage * >(argp1);
17525 {
17526 arg2 = wxString_in_helper(obj1);
17527 if (arg2 == NULL) SWIG_fail;
17528 temp2 = true;
17529 }
17530 {
17531 arg3 = wxString_in_helper(obj2);
17532 if (arg3 == NULL) SWIG_fail;
17533 temp3 = true;
17534 }
17535 if (obj3) {
17536 ecode4 = SWIG_AsVal_int(obj3, &val4);
17537 if (!SWIG_IsOK(ecode4)) {
17538 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
17539 }
17540 arg4 = static_cast< int >(val4);
17541 }
17542 {
17543 PyThreadState* __tstate = wxPyBeginAllowThreads();
17544 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17545 wxPyEndAllowThreads(__tstate);
17546 if (PyErr_Occurred()) SWIG_fail;
17547 }
17548 {
17549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17550 }
17551 {
17552 if (temp2)
17553 delete arg2;
17554 }
17555 {
17556 if (temp3)
17557 delete arg3;
17558 }
17559 return resultobj;
17560 fail:
17561 {
17562 if (temp2)
17563 delete arg2;
17564 }
17565 {
17566 if (temp3)
17567 delete arg3;
17568 }
17569 return NULL;
17570 }
17571
17572
17573 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17574 PyObject *resultobj = 0;
17575 wxImage *arg1 = (wxImage *) 0 ;
17576 wxString *arg2 = 0 ;
17577 int arg3 ;
17578 bool result;
17579 void *argp1 = 0 ;
17580 int res1 = 0 ;
17581 bool temp2 = false ;
17582 int val3 ;
17583 int ecode3 = 0 ;
17584 PyObject * obj0 = 0 ;
17585 PyObject * obj1 = 0 ;
17586 PyObject * obj2 = 0 ;
17587 char * kwnames[] = {
17588 (char *) "self",(char *) "name",(char *) "type", NULL
17589 };
17590
17591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17593 if (!SWIG_IsOK(res1)) {
17594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
17595 }
17596 arg1 = reinterpret_cast< wxImage * >(argp1);
17597 {
17598 arg2 = wxString_in_helper(obj1);
17599 if (arg2 == NULL) SWIG_fail;
17600 temp2 = true;
17601 }
17602 ecode3 = SWIG_AsVal_int(obj2, &val3);
17603 if (!SWIG_IsOK(ecode3)) {
17604 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
17605 }
17606 arg3 = static_cast< int >(val3);
17607 {
17608 PyThreadState* __tstate = wxPyBeginAllowThreads();
17609 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
17610 wxPyEndAllowThreads(__tstate);
17611 if (PyErr_Occurred()) SWIG_fail;
17612 }
17613 {
17614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17615 }
17616 {
17617 if (temp2)
17618 delete arg2;
17619 }
17620 return resultobj;
17621 fail:
17622 {
17623 if (temp2)
17624 delete arg2;
17625 }
17626 return NULL;
17627 }
17628
17629
17630 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17631 PyObject *resultobj = 0;
17632 wxImage *arg1 = (wxImage *) 0 ;
17633 wxString *arg2 = 0 ;
17634 wxString *arg3 = 0 ;
17635 bool result;
17636 void *argp1 = 0 ;
17637 int res1 = 0 ;
17638 bool temp2 = false ;
17639 bool temp3 = false ;
17640 PyObject * obj0 = 0 ;
17641 PyObject * obj1 = 0 ;
17642 PyObject * obj2 = 0 ;
17643 char * kwnames[] = {
17644 (char *) "self",(char *) "name",(char *) "mimetype", NULL
17645 };
17646
17647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17649 if (!SWIG_IsOK(res1)) {
17650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17651 }
17652 arg1 = reinterpret_cast< wxImage * >(argp1);
17653 {
17654 arg2 = wxString_in_helper(obj1);
17655 if (arg2 == NULL) SWIG_fail;
17656 temp2 = true;
17657 }
17658 {
17659 arg3 = wxString_in_helper(obj2);
17660 if (arg3 == NULL) SWIG_fail;
17661 temp3 = true;
17662 }
17663 {
17664 PyThreadState* __tstate = wxPyBeginAllowThreads();
17665 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
17666 wxPyEndAllowThreads(__tstate);
17667 if (PyErr_Occurred()) SWIG_fail;
17668 }
17669 {
17670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17671 }
17672 {
17673 if (temp2)
17674 delete arg2;
17675 }
17676 {
17677 if (temp3)
17678 delete arg3;
17679 }
17680 return resultobj;
17681 fail:
17682 {
17683 if (temp2)
17684 delete arg2;
17685 }
17686 {
17687 if (temp3)
17688 delete arg3;
17689 }
17690 return NULL;
17691 }
17692
17693
17694 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17695 PyObject *resultobj = 0;
17696 wxInputStream *arg1 = 0 ;
17697 bool result;
17698 wxPyInputStream *temp1 ;
17699 bool created1 ;
17700 PyObject * obj0 = 0 ;
17701 char * kwnames[] = {
17702 (char *) "stream", NULL
17703 };
17704
17705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
17706 {
17707 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
17708 arg1 = temp1->m_wxis;
17709 created1 = false;
17710 } else {
17711 PyErr_Clear(); // clear the failure of the wxPyConvert above
17712 arg1 = wxPyCBInputStream_create(obj0, false);
17713 if (arg1 == NULL) {
17714 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17715 SWIG_fail;
17716 }
17717 created1 = true;
17718 }
17719 }
17720 {
17721 PyThreadState* __tstate = wxPyBeginAllowThreads();
17722 result = (bool)wxImage::CanRead(*arg1);
17723 wxPyEndAllowThreads(__tstate);
17724 if (PyErr_Occurred()) SWIG_fail;
17725 }
17726 {
17727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17728 }
17729 {
17730 if (created1) delete arg1;
17731 }
17732 return resultobj;
17733 fail:
17734 {
17735 if (created1) delete arg1;
17736 }
17737 return NULL;
17738 }
17739
17740
17741 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17742 PyObject *resultobj = 0;
17743 wxImage *arg1 = (wxImage *) 0 ;
17744 wxInputStream *arg2 = 0 ;
17745 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17746 int arg4 = (int) -1 ;
17747 bool result;
17748 void *argp1 = 0 ;
17749 int res1 = 0 ;
17750 wxPyInputStream *temp2 ;
17751 bool created2 ;
17752 long val3 ;
17753 int ecode3 = 0 ;
17754 int val4 ;
17755 int ecode4 = 0 ;
17756 PyObject * obj0 = 0 ;
17757 PyObject * obj1 = 0 ;
17758 PyObject * obj2 = 0 ;
17759 PyObject * obj3 = 0 ;
17760 char * kwnames[] = {
17761 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
17762 };
17763
17764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17766 if (!SWIG_IsOK(res1)) {
17767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
17768 }
17769 arg1 = reinterpret_cast< wxImage * >(argp1);
17770 {
17771 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17772 arg2 = temp2->m_wxis;
17773 created2 = false;
17774 } else {
17775 PyErr_Clear(); // clear the failure of the wxPyConvert above
17776 arg2 = wxPyCBInputStream_create(obj1, false);
17777 if (arg2 == NULL) {
17778 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17779 SWIG_fail;
17780 }
17781 created2 = true;
17782 }
17783 }
17784 if (obj2) {
17785 ecode3 = SWIG_AsVal_long(obj2, &val3);
17786 if (!SWIG_IsOK(ecode3)) {
17787 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
17788 }
17789 arg3 = static_cast< long >(val3);
17790 }
17791 if (obj3) {
17792 ecode4 = SWIG_AsVal_int(obj3, &val4);
17793 if (!SWIG_IsOK(ecode4)) {
17794 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
17795 }
17796 arg4 = static_cast< int >(val4);
17797 }
17798 {
17799 PyThreadState* __tstate = wxPyBeginAllowThreads();
17800 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
17801 wxPyEndAllowThreads(__tstate);
17802 if (PyErr_Occurred()) SWIG_fail;
17803 }
17804 {
17805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17806 }
17807 {
17808 if (created2) delete arg2;
17809 }
17810 return resultobj;
17811 fail:
17812 {
17813 if (created2) delete arg2;
17814 }
17815 return NULL;
17816 }
17817
17818
17819 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17820 PyObject *resultobj = 0;
17821 wxImage *arg1 = (wxImage *) 0 ;
17822 wxInputStream *arg2 = 0 ;
17823 wxString *arg3 = 0 ;
17824 int arg4 = (int) -1 ;
17825 bool result;
17826 void *argp1 = 0 ;
17827 int res1 = 0 ;
17828 wxPyInputStream *temp2 ;
17829 bool created2 ;
17830 bool temp3 = false ;
17831 int val4 ;
17832 int ecode4 = 0 ;
17833 PyObject * obj0 = 0 ;
17834 PyObject * obj1 = 0 ;
17835 PyObject * obj2 = 0 ;
17836 PyObject * obj3 = 0 ;
17837 char * kwnames[] = {
17838 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
17839 };
17840
17841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17843 if (!SWIG_IsOK(res1)) {
17844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
17845 }
17846 arg1 = reinterpret_cast< wxImage * >(argp1);
17847 {
17848 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17849 arg2 = temp2->m_wxis;
17850 created2 = false;
17851 } else {
17852 PyErr_Clear(); // clear the failure of the wxPyConvert above
17853 arg2 = wxPyCBInputStream_create(obj1, false);
17854 if (arg2 == NULL) {
17855 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17856 SWIG_fail;
17857 }
17858 created2 = true;
17859 }
17860 }
17861 {
17862 arg3 = wxString_in_helper(obj2);
17863 if (arg3 == NULL) SWIG_fail;
17864 temp3 = true;
17865 }
17866 if (obj3) {
17867 ecode4 = SWIG_AsVal_int(obj3, &val4);
17868 if (!SWIG_IsOK(ecode4)) {
17869 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
17870 }
17871 arg4 = static_cast< int >(val4);
17872 }
17873 {
17874 PyThreadState* __tstate = wxPyBeginAllowThreads();
17875 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
17876 wxPyEndAllowThreads(__tstate);
17877 if (PyErr_Occurred()) SWIG_fail;
17878 }
17879 {
17880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17881 }
17882 {
17883 if (created2) delete arg2;
17884 }
17885 {
17886 if (temp3)
17887 delete arg3;
17888 }
17889 return resultobj;
17890 fail:
17891 {
17892 if (created2) delete arg2;
17893 }
17894 {
17895 if (temp3)
17896 delete arg3;
17897 }
17898 return NULL;
17899 }
17900
17901
17902 SWIGINTERN PyObject *_wrap_Image_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17903 PyObject *resultobj = 0;
17904 wxImage *arg1 = (wxImage *) 0 ;
17905 bool result;
17906 void *argp1 = 0 ;
17907 int res1 = 0 ;
17908 PyObject *swig_obj[1] ;
17909
17910 if (!args) SWIG_fail;
17911 swig_obj[0] = args;
17912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17913 if (!SWIG_IsOK(res1)) {
17914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsOk" "', expected argument " "1"" of type '" "wxImage *""'");
17915 }
17916 arg1 = reinterpret_cast< wxImage * >(argp1);
17917 {
17918 PyThreadState* __tstate = wxPyBeginAllowThreads();
17919 result = (bool)(arg1)->IsOk();
17920 wxPyEndAllowThreads(__tstate);
17921 if (PyErr_Occurred()) SWIG_fail;
17922 }
17923 {
17924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17925 }
17926 return resultobj;
17927 fail:
17928 return NULL;
17929 }
17930
17931
17932 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17933 PyObject *resultobj = 0;
17934 wxImage *arg1 = (wxImage *) 0 ;
17935 int result;
17936 void *argp1 = 0 ;
17937 int res1 = 0 ;
17938 PyObject *swig_obj[1] ;
17939
17940 if (!args) SWIG_fail;
17941 swig_obj[0] = args;
17942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17943 if (!SWIG_IsOK(res1)) {
17944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
17945 }
17946 arg1 = reinterpret_cast< wxImage * >(argp1);
17947 {
17948 PyThreadState* __tstate = wxPyBeginAllowThreads();
17949 result = (int)(arg1)->GetWidth();
17950 wxPyEndAllowThreads(__tstate);
17951 if (PyErr_Occurred()) SWIG_fail;
17952 }
17953 resultobj = SWIG_From_int(static_cast< int >(result));
17954 return resultobj;
17955 fail:
17956 return NULL;
17957 }
17958
17959
17960 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17961 PyObject *resultobj = 0;
17962 wxImage *arg1 = (wxImage *) 0 ;
17963 int result;
17964 void *argp1 = 0 ;
17965 int res1 = 0 ;
17966 PyObject *swig_obj[1] ;
17967
17968 if (!args) SWIG_fail;
17969 swig_obj[0] = args;
17970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17971 if (!SWIG_IsOK(res1)) {
17972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
17973 }
17974 arg1 = reinterpret_cast< wxImage * >(argp1);
17975 {
17976 PyThreadState* __tstate = wxPyBeginAllowThreads();
17977 result = (int)(arg1)->GetHeight();
17978 wxPyEndAllowThreads(__tstate);
17979 if (PyErr_Occurred()) SWIG_fail;
17980 }
17981 resultobj = SWIG_From_int(static_cast< int >(result));
17982 return resultobj;
17983 fail:
17984 return NULL;
17985 }
17986
17987
17988 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17989 PyObject *resultobj = 0;
17990 wxImage *arg1 = (wxImage *) 0 ;
17991 wxSize result;
17992 void *argp1 = 0 ;
17993 int res1 = 0 ;
17994 PyObject *swig_obj[1] ;
17995
17996 if (!args) SWIG_fail;
17997 swig_obj[0] = args;
17998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17999 if (!SWIG_IsOK(res1)) {
18000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
18001 }
18002 arg1 = reinterpret_cast< wxImage * >(argp1);
18003 {
18004 PyThreadState* __tstate = wxPyBeginAllowThreads();
18005 result = wxImage_GetSize(arg1);
18006 wxPyEndAllowThreads(__tstate);
18007 if (PyErr_Occurred()) SWIG_fail;
18008 }
18009 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
18010 return resultobj;
18011 fail:
18012 return NULL;
18013 }
18014
18015
18016 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18017 PyObject *resultobj = 0;
18018 wxImage *arg1 = (wxImage *) 0 ;
18019 wxRect *arg2 = 0 ;
18020 SwigValueWrapper<wxImage > result;
18021 void *argp1 = 0 ;
18022 int res1 = 0 ;
18023 wxRect temp2 ;
18024 PyObject * obj0 = 0 ;
18025 PyObject * obj1 = 0 ;
18026 char * kwnames[] = {
18027 (char *) "self",(char *) "rect", NULL
18028 };
18029
18030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
18031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18032 if (!SWIG_IsOK(res1)) {
18033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
18034 }
18035 arg1 = reinterpret_cast< wxImage * >(argp1);
18036 {
18037 arg2 = &temp2;
18038 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
18039 }
18040 {
18041 PyThreadState* __tstate = wxPyBeginAllowThreads();
18042 result = (arg1)->GetSubImage((wxRect const &)*arg2);
18043 wxPyEndAllowThreads(__tstate);
18044 if (PyErr_Occurred()) SWIG_fail;
18045 }
18046 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18047 return resultobj;
18048 fail:
18049 return NULL;
18050 }
18051
18052
18053 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18054 PyObject *resultobj = 0;
18055 wxImage *arg1 = (wxImage *) 0 ;
18056 wxSize *arg2 = 0 ;
18057 wxPoint *arg3 = 0 ;
18058 int arg4 = (int) -1 ;
18059 int arg5 = (int) -1 ;
18060 int arg6 = (int) -1 ;
18061 SwigValueWrapper<wxImage > result;
18062 void *argp1 = 0 ;
18063 int res1 = 0 ;
18064 wxSize temp2 ;
18065 wxPoint temp3 ;
18066 int val4 ;
18067 int ecode4 = 0 ;
18068 int val5 ;
18069 int ecode5 = 0 ;
18070 int val6 ;
18071 int ecode6 = 0 ;
18072 PyObject * obj0 = 0 ;
18073 PyObject * obj1 = 0 ;
18074 PyObject * obj2 = 0 ;
18075 PyObject * obj3 = 0 ;
18076 PyObject * obj4 = 0 ;
18077 PyObject * obj5 = 0 ;
18078 char * kwnames[] = {
18079 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
18080 };
18081
18082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
18083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18084 if (!SWIG_IsOK(res1)) {
18085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
18086 }
18087 arg1 = reinterpret_cast< wxImage * >(argp1);
18088 {
18089 arg2 = &temp2;
18090 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
18091 }
18092 {
18093 arg3 = &temp3;
18094 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18095 }
18096 if (obj3) {
18097 ecode4 = SWIG_AsVal_int(obj3, &val4);
18098 if (!SWIG_IsOK(ecode4)) {
18099 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
18100 }
18101 arg4 = static_cast< int >(val4);
18102 }
18103 if (obj4) {
18104 ecode5 = SWIG_AsVal_int(obj4, &val5);
18105 if (!SWIG_IsOK(ecode5)) {
18106 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
18107 }
18108 arg5 = static_cast< int >(val5);
18109 }
18110 if (obj5) {
18111 ecode6 = SWIG_AsVal_int(obj5, &val6);
18112 if (!SWIG_IsOK(ecode6)) {
18113 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
18114 }
18115 arg6 = static_cast< int >(val6);
18116 }
18117 {
18118 PyThreadState* __tstate = wxPyBeginAllowThreads();
18119 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
18120 wxPyEndAllowThreads(__tstate);
18121 if (PyErr_Occurred()) SWIG_fail;
18122 }
18123 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18124 return resultobj;
18125 fail:
18126 return NULL;
18127 }
18128
18129
18130 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18131 PyObject *resultobj = 0;
18132 wxImage *arg1 = (wxImage *) 0 ;
18133 SwigValueWrapper<wxImage > result;
18134 void *argp1 = 0 ;
18135 int res1 = 0 ;
18136 PyObject *swig_obj[1] ;
18137
18138 if (!args) SWIG_fail;
18139 swig_obj[0] = args;
18140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18141 if (!SWIG_IsOK(res1)) {
18142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
18143 }
18144 arg1 = reinterpret_cast< wxImage * >(argp1);
18145 {
18146 PyThreadState* __tstate = wxPyBeginAllowThreads();
18147 result = (arg1)->Copy();
18148 wxPyEndAllowThreads(__tstate);
18149 if (PyErr_Occurred()) SWIG_fail;
18150 }
18151 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18152 return resultobj;
18153 fail:
18154 return NULL;
18155 }
18156
18157
18158 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18159 PyObject *resultobj = 0;
18160 wxImage *arg1 = (wxImage *) 0 ;
18161 wxImage *arg2 = 0 ;
18162 int arg3 ;
18163 int arg4 ;
18164 void *argp1 = 0 ;
18165 int res1 = 0 ;
18166 void *argp2 = 0 ;
18167 int res2 = 0 ;
18168 int val3 ;
18169 int ecode3 = 0 ;
18170 int val4 ;
18171 int ecode4 = 0 ;
18172 PyObject * obj0 = 0 ;
18173 PyObject * obj1 = 0 ;
18174 PyObject * obj2 = 0 ;
18175 PyObject * obj3 = 0 ;
18176 char * kwnames[] = {
18177 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
18178 };
18179
18180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18182 if (!SWIG_IsOK(res1)) {
18183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
18184 }
18185 arg1 = reinterpret_cast< wxImage * >(argp1);
18186 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
18187 if (!SWIG_IsOK(res2)) {
18188 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18189 }
18190 if (!argp2) {
18191 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18192 }
18193 arg2 = reinterpret_cast< wxImage * >(argp2);
18194 ecode3 = SWIG_AsVal_int(obj2, &val3);
18195 if (!SWIG_IsOK(ecode3)) {
18196 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
18197 }
18198 arg3 = static_cast< int >(val3);
18199 ecode4 = SWIG_AsVal_int(obj3, &val4);
18200 if (!SWIG_IsOK(ecode4)) {
18201 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
18202 }
18203 arg4 = static_cast< int >(val4);
18204 {
18205 PyThreadState* __tstate = wxPyBeginAllowThreads();
18206 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
18207 wxPyEndAllowThreads(__tstate);
18208 if (PyErr_Occurred()) SWIG_fail;
18209 }
18210 resultobj = SWIG_Py_Void();
18211 return resultobj;
18212 fail:
18213 return NULL;
18214 }
18215
18216
18217 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18218 PyObject *resultobj = 0;
18219 wxImage *arg1 = (wxImage *) 0 ;
18220 PyObject *result = 0 ;
18221 void *argp1 = 0 ;
18222 int res1 = 0 ;
18223 PyObject *swig_obj[1] ;
18224
18225 if (!args) SWIG_fail;
18226 swig_obj[0] = args;
18227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18228 if (!SWIG_IsOK(res1)) {
18229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
18230 }
18231 arg1 = reinterpret_cast< wxImage * >(argp1);
18232 {
18233 PyThreadState* __tstate = wxPyBeginAllowThreads();
18234 result = (PyObject *)wxImage_GetData(arg1);
18235 wxPyEndAllowThreads(__tstate);
18236 if (PyErr_Occurred()) SWIG_fail;
18237 }
18238 resultobj = result;
18239 return resultobj;
18240 fail:
18241 return NULL;
18242 }
18243
18244
18245 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18246 PyObject *resultobj = 0;
18247 wxImage *arg1 = (wxImage *) 0 ;
18248 buffer arg2 ;
18249 int arg3 ;
18250 void *argp1 = 0 ;
18251 int res1 = 0 ;
18252 Py_ssize_t temp2 ;
18253 PyObject * obj0 = 0 ;
18254 PyObject * obj1 = 0 ;
18255 char * kwnames[] = {
18256 (char *) "self",(char *) "data", NULL
18257 };
18258
18259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
18260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18261 if (!SWIG_IsOK(res1)) {
18262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
18263 }
18264 arg1 = reinterpret_cast< wxImage * >(argp1);
18265 {
18266 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18267 arg3 = (int)temp2;
18268 }
18269 {
18270 PyThreadState* __tstate = wxPyBeginAllowThreads();
18271 wxImage_SetData(arg1,arg2,arg3);
18272 wxPyEndAllowThreads(__tstate);
18273 if (PyErr_Occurred()) SWIG_fail;
18274 }
18275 resultobj = SWIG_Py_Void();
18276 return resultobj;
18277 fail:
18278 return NULL;
18279 }
18280
18281
18282 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18283 PyObject *resultobj = 0;
18284 wxImage *arg1 = (wxImage *) 0 ;
18285 PyObject *result = 0 ;
18286 void *argp1 = 0 ;
18287 int res1 = 0 ;
18288 PyObject *swig_obj[1] ;
18289
18290 if (!args) SWIG_fail;
18291 swig_obj[0] = args;
18292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18293 if (!SWIG_IsOK(res1)) {
18294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18295 }
18296 arg1 = reinterpret_cast< wxImage * >(argp1);
18297 {
18298 PyThreadState* __tstate = wxPyBeginAllowThreads();
18299 result = (PyObject *)wxImage_GetDataBuffer(arg1);
18300 wxPyEndAllowThreads(__tstate);
18301 if (PyErr_Occurred()) SWIG_fail;
18302 }
18303 resultobj = result;
18304 return resultobj;
18305 fail:
18306 return NULL;
18307 }
18308
18309
18310 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18311 PyObject *resultobj = 0;
18312 wxImage *arg1 = (wxImage *) 0 ;
18313 buffer arg2 ;
18314 int arg3 ;
18315 void *argp1 = 0 ;
18316 int res1 = 0 ;
18317 Py_ssize_t temp2 ;
18318 PyObject * obj0 = 0 ;
18319 PyObject * obj1 = 0 ;
18320 char * kwnames[] = {
18321 (char *) "self",(char *) "data", NULL
18322 };
18323
18324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18326 if (!SWIG_IsOK(res1)) {
18327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18328 }
18329 arg1 = reinterpret_cast< wxImage * >(argp1);
18330 {
18331 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18332 arg3 = (int)temp2;
18333 }
18334 {
18335 PyThreadState* __tstate = wxPyBeginAllowThreads();
18336 wxImage_SetDataBuffer(arg1,arg2,arg3);
18337 wxPyEndAllowThreads(__tstate);
18338 if (PyErr_Occurred()) SWIG_fail;
18339 }
18340 resultobj = SWIG_Py_Void();
18341 return resultobj;
18342 fail:
18343 return NULL;
18344 }
18345
18346
18347 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18348 PyObject *resultobj = 0;
18349 wxImage *arg1 = (wxImage *) 0 ;
18350 PyObject *result = 0 ;
18351 void *argp1 = 0 ;
18352 int res1 = 0 ;
18353 PyObject *swig_obj[1] ;
18354
18355 if (!args) SWIG_fail;
18356 swig_obj[0] = args;
18357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18358 if (!SWIG_IsOK(res1)) {
18359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18360 }
18361 arg1 = reinterpret_cast< wxImage * >(argp1);
18362 {
18363 PyThreadState* __tstate = wxPyBeginAllowThreads();
18364 result = (PyObject *)wxImage_GetAlphaData(arg1);
18365 wxPyEndAllowThreads(__tstate);
18366 if (PyErr_Occurred()) SWIG_fail;
18367 }
18368 resultobj = result;
18369 return resultobj;
18370 fail:
18371 return NULL;
18372 }
18373
18374
18375 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18376 PyObject *resultobj = 0;
18377 wxImage *arg1 = (wxImage *) 0 ;
18378 buffer arg2 ;
18379 int arg3 ;
18380 void *argp1 = 0 ;
18381 int res1 = 0 ;
18382 Py_ssize_t temp2 ;
18383 PyObject * obj0 = 0 ;
18384 PyObject * obj1 = 0 ;
18385 char * kwnames[] = {
18386 (char *) "self",(char *) "alpha", NULL
18387 };
18388
18389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
18390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18391 if (!SWIG_IsOK(res1)) {
18392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18393 }
18394 arg1 = reinterpret_cast< wxImage * >(argp1);
18395 {
18396 if (obj1 != Py_None) {
18397 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18398 arg3 = (int)temp2;
18399 }
18400 }
18401 {
18402 PyThreadState* __tstate = wxPyBeginAllowThreads();
18403 wxImage_SetAlphaData(arg1,arg2,arg3);
18404 wxPyEndAllowThreads(__tstate);
18405 if (PyErr_Occurred()) SWIG_fail;
18406 }
18407 resultobj = SWIG_Py_Void();
18408 return resultobj;
18409 fail:
18410 return NULL;
18411 }
18412
18413
18414 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18415 PyObject *resultobj = 0;
18416 wxImage *arg1 = (wxImage *) 0 ;
18417 PyObject *result = 0 ;
18418 void *argp1 = 0 ;
18419 int res1 = 0 ;
18420 PyObject *swig_obj[1] ;
18421
18422 if (!args) SWIG_fail;
18423 swig_obj[0] = args;
18424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18425 if (!SWIG_IsOK(res1)) {
18426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18427 }
18428 arg1 = reinterpret_cast< wxImage * >(argp1);
18429 {
18430 PyThreadState* __tstate = wxPyBeginAllowThreads();
18431 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
18432 wxPyEndAllowThreads(__tstate);
18433 if (PyErr_Occurred()) SWIG_fail;
18434 }
18435 resultobj = result;
18436 return resultobj;
18437 fail:
18438 return NULL;
18439 }
18440
18441
18442 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18443 PyObject *resultobj = 0;
18444 wxImage *arg1 = (wxImage *) 0 ;
18445 buffer arg2 ;
18446 int arg3 ;
18447 void *argp1 = 0 ;
18448 int res1 = 0 ;
18449 Py_ssize_t temp2 ;
18450 PyObject * obj0 = 0 ;
18451 PyObject * obj1 = 0 ;
18452 char * kwnames[] = {
18453 (char *) "self",(char *) "alpha", NULL
18454 };
18455
18456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18458 if (!SWIG_IsOK(res1)) {
18459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18460 }
18461 arg1 = reinterpret_cast< wxImage * >(argp1);
18462 {
18463 if (obj1 != Py_None) {
18464 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18465 arg3 = (int)temp2;
18466 }
18467 }
18468 {
18469 PyThreadState* __tstate = wxPyBeginAllowThreads();
18470 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
18471 wxPyEndAllowThreads(__tstate);
18472 if (PyErr_Occurred()) SWIG_fail;
18473 }
18474 resultobj = SWIG_Py_Void();
18475 return resultobj;
18476 fail:
18477 return NULL;
18478 }
18479
18480
18481 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18482 PyObject *resultobj = 0;
18483 wxImage *arg1 = (wxImage *) 0 ;
18484 byte arg2 ;
18485 byte arg3 ;
18486 byte arg4 ;
18487 void *argp1 = 0 ;
18488 int res1 = 0 ;
18489 unsigned char val2 ;
18490 int ecode2 = 0 ;
18491 unsigned char val3 ;
18492 int ecode3 = 0 ;
18493 unsigned char val4 ;
18494 int ecode4 = 0 ;
18495 PyObject * obj0 = 0 ;
18496 PyObject * obj1 = 0 ;
18497 PyObject * obj2 = 0 ;
18498 PyObject * obj3 = 0 ;
18499 char * kwnames[] = {
18500 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
18501 };
18502
18503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18505 if (!SWIG_IsOK(res1)) {
18506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
18507 }
18508 arg1 = reinterpret_cast< wxImage * >(argp1);
18509 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18510 if (!SWIG_IsOK(ecode2)) {
18511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
18512 }
18513 arg2 = static_cast< byte >(val2);
18514 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18515 if (!SWIG_IsOK(ecode3)) {
18516 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
18517 }
18518 arg3 = static_cast< byte >(val3);
18519 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18520 if (!SWIG_IsOK(ecode4)) {
18521 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
18522 }
18523 arg4 = static_cast< byte >(val4);
18524 {
18525 PyThreadState* __tstate = wxPyBeginAllowThreads();
18526 (arg1)->SetMaskColour(arg2,arg3,arg4);
18527 wxPyEndAllowThreads(__tstate);
18528 if (PyErr_Occurred()) SWIG_fail;
18529 }
18530 resultobj = SWIG_Py_Void();
18531 return resultobj;
18532 fail:
18533 return NULL;
18534 }
18535
18536
18537 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18538 PyObject *resultobj = 0;
18539 wxImage *arg1 = (wxImage *) 0 ;
18540 byte *arg2 = (byte *) 0 ;
18541 byte *arg3 = (byte *) 0 ;
18542 byte *arg4 = (byte *) 0 ;
18543 void *argp1 = 0 ;
18544 int res1 = 0 ;
18545 byte temp2 ;
18546 int res2 = SWIG_TMPOBJ ;
18547 byte temp3 ;
18548 int res3 = SWIG_TMPOBJ ;
18549 byte temp4 ;
18550 int res4 = SWIG_TMPOBJ ;
18551 PyObject *swig_obj[1] ;
18552
18553 arg2 = &temp2;
18554 arg3 = &temp3;
18555 arg4 = &temp4;
18556 if (!args) SWIG_fail;
18557 swig_obj[0] = args;
18558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18559 if (!SWIG_IsOK(res1)) {
18560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
18561 }
18562 arg1 = reinterpret_cast< wxImage * >(argp1);
18563 {
18564 PyThreadState* __tstate = wxPyBeginAllowThreads();
18565 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
18566 wxPyEndAllowThreads(__tstate);
18567 if (PyErr_Occurred()) SWIG_fail;
18568 }
18569 resultobj = SWIG_Py_Void();
18570 if (SWIG_IsTmpObj(res2)) {
18571 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
18572 } else {
18573 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18574 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
18575 }
18576 if (SWIG_IsTmpObj(res3)) {
18577 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
18578 } else {
18579 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18580 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
18581 }
18582 if (SWIG_IsTmpObj(res4)) {
18583 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
18584 } else {
18585 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18586 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
18587 }
18588 return resultobj;
18589 fail:
18590 return NULL;
18591 }
18592
18593
18594 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18595 PyObject *resultobj = 0;
18596 wxImage *arg1 = (wxImage *) 0 ;
18597 byte result;
18598 void *argp1 = 0 ;
18599 int res1 = 0 ;
18600 PyObject *swig_obj[1] ;
18601
18602 if (!args) SWIG_fail;
18603 swig_obj[0] = args;
18604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18605 if (!SWIG_IsOK(res1)) {
18606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
18607 }
18608 arg1 = reinterpret_cast< wxImage * >(argp1);
18609 {
18610 PyThreadState* __tstate = wxPyBeginAllowThreads();
18611 result = (byte)(arg1)->GetMaskRed();
18612 wxPyEndAllowThreads(__tstate);
18613 if (PyErr_Occurred()) SWIG_fail;
18614 }
18615 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18616 return resultobj;
18617 fail:
18618 return NULL;
18619 }
18620
18621
18622 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18623 PyObject *resultobj = 0;
18624 wxImage *arg1 = (wxImage *) 0 ;
18625 byte result;
18626 void *argp1 = 0 ;
18627 int res1 = 0 ;
18628 PyObject *swig_obj[1] ;
18629
18630 if (!args) SWIG_fail;
18631 swig_obj[0] = args;
18632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18633 if (!SWIG_IsOK(res1)) {
18634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
18635 }
18636 arg1 = reinterpret_cast< wxImage * >(argp1);
18637 {
18638 PyThreadState* __tstate = wxPyBeginAllowThreads();
18639 result = (byte)(arg1)->GetMaskGreen();
18640 wxPyEndAllowThreads(__tstate);
18641 if (PyErr_Occurred()) SWIG_fail;
18642 }
18643 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18644 return resultobj;
18645 fail:
18646 return NULL;
18647 }
18648
18649
18650 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18651 PyObject *resultobj = 0;
18652 wxImage *arg1 = (wxImage *) 0 ;
18653 byte result;
18654 void *argp1 = 0 ;
18655 int res1 = 0 ;
18656 PyObject *swig_obj[1] ;
18657
18658 if (!args) SWIG_fail;
18659 swig_obj[0] = args;
18660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18661 if (!SWIG_IsOK(res1)) {
18662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
18663 }
18664 arg1 = reinterpret_cast< wxImage * >(argp1);
18665 {
18666 PyThreadState* __tstate = wxPyBeginAllowThreads();
18667 result = (byte)(arg1)->GetMaskBlue();
18668 wxPyEndAllowThreads(__tstate);
18669 if (PyErr_Occurred()) SWIG_fail;
18670 }
18671 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18672 return resultobj;
18673 fail:
18674 return NULL;
18675 }
18676
18677
18678 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18679 PyObject *resultobj = 0;
18680 wxImage *arg1 = (wxImage *) 0 ;
18681 bool arg2 = (bool) true ;
18682 void *argp1 = 0 ;
18683 int res1 = 0 ;
18684 bool val2 ;
18685 int ecode2 = 0 ;
18686 PyObject * obj0 = 0 ;
18687 PyObject * obj1 = 0 ;
18688 char * kwnames[] = {
18689 (char *) "self",(char *) "mask", NULL
18690 };
18691
18692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
18693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18694 if (!SWIG_IsOK(res1)) {
18695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
18696 }
18697 arg1 = reinterpret_cast< wxImage * >(argp1);
18698 if (obj1) {
18699 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18700 if (!SWIG_IsOK(ecode2)) {
18701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
18702 }
18703 arg2 = static_cast< bool >(val2);
18704 }
18705 {
18706 PyThreadState* __tstate = wxPyBeginAllowThreads();
18707 (arg1)->SetMask(arg2);
18708 wxPyEndAllowThreads(__tstate);
18709 if (PyErr_Occurred()) SWIG_fail;
18710 }
18711 resultobj = SWIG_Py_Void();
18712 return resultobj;
18713 fail:
18714 return NULL;
18715 }
18716
18717
18718 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18719 PyObject *resultobj = 0;
18720 wxImage *arg1 = (wxImage *) 0 ;
18721 bool result;
18722 void *argp1 = 0 ;
18723 int res1 = 0 ;
18724 PyObject *swig_obj[1] ;
18725
18726 if (!args) SWIG_fail;
18727 swig_obj[0] = args;
18728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18729 if (!SWIG_IsOK(res1)) {
18730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
18731 }
18732 arg1 = reinterpret_cast< wxImage * >(argp1);
18733 {
18734 PyThreadState* __tstate = wxPyBeginAllowThreads();
18735 result = (bool)(arg1)->HasMask();
18736 wxPyEndAllowThreads(__tstate);
18737 if (PyErr_Occurred()) SWIG_fail;
18738 }
18739 {
18740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18741 }
18742 return resultobj;
18743 fail:
18744 return NULL;
18745 }
18746
18747
18748 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18749 PyObject *resultobj = 0;
18750 wxImage *arg1 = (wxImage *) 0 ;
18751 double arg2 ;
18752 wxPoint *arg3 = 0 ;
18753 bool arg4 = (bool) true ;
18754 wxPoint *arg5 = (wxPoint *) NULL ;
18755 SwigValueWrapper<wxImage > result;
18756 void *argp1 = 0 ;
18757 int res1 = 0 ;
18758 double val2 ;
18759 int ecode2 = 0 ;
18760 wxPoint temp3 ;
18761 bool val4 ;
18762 int ecode4 = 0 ;
18763 void *argp5 = 0 ;
18764 int res5 = 0 ;
18765 PyObject * obj0 = 0 ;
18766 PyObject * obj1 = 0 ;
18767 PyObject * obj2 = 0 ;
18768 PyObject * obj3 = 0 ;
18769 PyObject * obj4 = 0 ;
18770 char * kwnames[] = {
18771 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
18772 };
18773
18774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18776 if (!SWIG_IsOK(res1)) {
18777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
18778 }
18779 arg1 = reinterpret_cast< wxImage * >(argp1);
18780 ecode2 = SWIG_AsVal_double(obj1, &val2);
18781 if (!SWIG_IsOK(ecode2)) {
18782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
18783 }
18784 arg2 = static_cast< double >(val2);
18785 {
18786 arg3 = &temp3;
18787 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18788 }
18789 if (obj3) {
18790 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18791 if (!SWIG_IsOK(ecode4)) {
18792 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
18793 }
18794 arg4 = static_cast< bool >(val4);
18795 }
18796 if (obj4) {
18797 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
18798 if (!SWIG_IsOK(res5)) {
18799 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
18800 }
18801 arg5 = reinterpret_cast< wxPoint * >(argp5);
18802 }
18803 {
18804 PyThreadState* __tstate = wxPyBeginAllowThreads();
18805 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
18806 wxPyEndAllowThreads(__tstate);
18807 if (PyErr_Occurred()) SWIG_fail;
18808 }
18809 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18810 return resultobj;
18811 fail:
18812 return NULL;
18813 }
18814
18815
18816 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18817 PyObject *resultobj = 0;
18818 wxImage *arg1 = (wxImage *) 0 ;
18819 bool arg2 = (bool) true ;
18820 SwigValueWrapper<wxImage > result;
18821 void *argp1 = 0 ;
18822 int res1 = 0 ;
18823 bool val2 ;
18824 int ecode2 = 0 ;
18825 PyObject * obj0 = 0 ;
18826 PyObject * obj1 = 0 ;
18827 char * kwnames[] = {
18828 (char *) "self",(char *) "clockwise", NULL
18829 };
18830
18831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
18832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18833 if (!SWIG_IsOK(res1)) {
18834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
18835 }
18836 arg1 = reinterpret_cast< wxImage * >(argp1);
18837 if (obj1) {
18838 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18839 if (!SWIG_IsOK(ecode2)) {
18840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
18841 }
18842 arg2 = static_cast< bool >(val2);
18843 }
18844 {
18845 PyThreadState* __tstate = wxPyBeginAllowThreads();
18846 result = (arg1)->Rotate90(arg2);
18847 wxPyEndAllowThreads(__tstate);
18848 if (PyErr_Occurred()) SWIG_fail;
18849 }
18850 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18851 return resultobj;
18852 fail:
18853 return NULL;
18854 }
18855
18856
18857 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18858 PyObject *resultobj = 0;
18859 wxImage *arg1 = (wxImage *) 0 ;
18860 bool arg2 = (bool) true ;
18861 SwigValueWrapper<wxImage > result;
18862 void *argp1 = 0 ;
18863 int res1 = 0 ;
18864 bool val2 ;
18865 int ecode2 = 0 ;
18866 PyObject * obj0 = 0 ;
18867 PyObject * obj1 = 0 ;
18868 char * kwnames[] = {
18869 (char *) "self",(char *) "horizontally", NULL
18870 };
18871
18872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
18873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18874 if (!SWIG_IsOK(res1)) {
18875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
18876 }
18877 arg1 = reinterpret_cast< wxImage * >(argp1);
18878 if (obj1) {
18879 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18880 if (!SWIG_IsOK(ecode2)) {
18881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
18882 }
18883 arg2 = static_cast< bool >(val2);
18884 }
18885 {
18886 PyThreadState* __tstate = wxPyBeginAllowThreads();
18887 result = (arg1)->Mirror(arg2);
18888 wxPyEndAllowThreads(__tstate);
18889 if (PyErr_Occurred()) SWIG_fail;
18890 }
18891 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18892 return resultobj;
18893 fail:
18894 return NULL;
18895 }
18896
18897
18898 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18899 PyObject *resultobj = 0;
18900 wxImage *arg1 = (wxImage *) 0 ;
18901 byte arg2 ;
18902 byte arg3 ;
18903 byte arg4 ;
18904 byte arg5 ;
18905 byte arg6 ;
18906 byte arg7 ;
18907 void *argp1 = 0 ;
18908 int res1 = 0 ;
18909 unsigned char val2 ;
18910 int ecode2 = 0 ;
18911 unsigned char val3 ;
18912 int ecode3 = 0 ;
18913 unsigned char val4 ;
18914 int ecode4 = 0 ;
18915 unsigned char val5 ;
18916 int ecode5 = 0 ;
18917 unsigned char val6 ;
18918 int ecode6 = 0 ;
18919 unsigned char val7 ;
18920 int ecode7 = 0 ;
18921 PyObject * obj0 = 0 ;
18922 PyObject * obj1 = 0 ;
18923 PyObject * obj2 = 0 ;
18924 PyObject * obj3 = 0 ;
18925 PyObject * obj4 = 0 ;
18926 PyObject * obj5 = 0 ;
18927 PyObject * obj6 = 0 ;
18928 char * kwnames[] = {
18929 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
18930 };
18931
18932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
18933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18934 if (!SWIG_IsOK(res1)) {
18935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
18936 }
18937 arg1 = reinterpret_cast< wxImage * >(argp1);
18938 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18939 if (!SWIG_IsOK(ecode2)) {
18940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
18941 }
18942 arg2 = static_cast< byte >(val2);
18943 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18944 if (!SWIG_IsOK(ecode3)) {
18945 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
18946 }
18947 arg3 = static_cast< byte >(val3);
18948 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18949 if (!SWIG_IsOK(ecode4)) {
18950 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
18951 }
18952 arg4 = static_cast< byte >(val4);
18953 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
18954 if (!SWIG_IsOK(ecode5)) {
18955 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
18956 }
18957 arg5 = static_cast< byte >(val5);
18958 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
18959 if (!SWIG_IsOK(ecode6)) {
18960 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
18961 }
18962 arg6 = static_cast< byte >(val6);
18963 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
18964 if (!SWIG_IsOK(ecode7)) {
18965 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
18966 }
18967 arg7 = static_cast< byte >(val7);
18968 {
18969 PyThreadState* __tstate = wxPyBeginAllowThreads();
18970 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
18971 wxPyEndAllowThreads(__tstate);
18972 if (PyErr_Occurred()) SWIG_fail;
18973 }
18974 resultobj = SWIG_Py_Void();
18975 return resultobj;
18976 fail:
18977 return NULL;
18978 }
18979
18980
18981 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18982 PyObject *resultobj = 0;
18983 wxImage *arg1 = (wxImage *) 0 ;
18984 double arg2 = (double) 0.299 ;
18985 double arg3 = (double) 0.587 ;
18986 double arg4 = (double) 0.114 ;
18987 SwigValueWrapper<wxImage > result;
18988 void *argp1 = 0 ;
18989 int res1 = 0 ;
18990 double val2 ;
18991 int ecode2 = 0 ;
18992 double val3 ;
18993 int ecode3 = 0 ;
18994 double val4 ;
18995 int ecode4 = 0 ;
18996 PyObject * obj0 = 0 ;
18997 PyObject * obj1 = 0 ;
18998 PyObject * obj2 = 0 ;
18999 PyObject * obj3 = 0 ;
19000 char * kwnames[] = {
19001 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
19002 };
19003
19004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19006 if (!SWIG_IsOK(res1)) {
19007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
19008 }
19009 arg1 = reinterpret_cast< wxImage * >(argp1);
19010 if (obj1) {
19011 ecode2 = SWIG_AsVal_double(obj1, &val2);
19012 if (!SWIG_IsOK(ecode2)) {
19013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
19014 }
19015 arg2 = static_cast< double >(val2);
19016 }
19017 if (obj2) {
19018 ecode3 = SWIG_AsVal_double(obj2, &val3);
19019 if (!SWIG_IsOK(ecode3)) {
19020 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
19021 }
19022 arg3 = static_cast< double >(val3);
19023 }
19024 if (obj3) {
19025 ecode4 = SWIG_AsVal_double(obj3, &val4);
19026 if (!SWIG_IsOK(ecode4)) {
19027 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
19028 }
19029 arg4 = static_cast< double >(val4);
19030 }
19031 {
19032 PyThreadState* __tstate = wxPyBeginAllowThreads();
19033 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
19034 wxPyEndAllowThreads(__tstate);
19035 if (PyErr_Occurred()) SWIG_fail;
19036 }
19037 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19038 return resultobj;
19039 fail:
19040 return NULL;
19041 }
19042
19043
19044 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19045 PyObject *resultobj = 0;
19046 wxImage *arg1 = (wxImage *) 0 ;
19047 byte arg2 ;
19048 byte arg3 ;
19049 byte arg4 ;
19050 SwigValueWrapper<wxImage > result;
19051 void *argp1 = 0 ;
19052 int res1 = 0 ;
19053 unsigned char val2 ;
19054 int ecode2 = 0 ;
19055 unsigned char val3 ;
19056 int ecode3 = 0 ;
19057 unsigned char val4 ;
19058 int ecode4 = 0 ;
19059 PyObject * obj0 = 0 ;
19060 PyObject * obj1 = 0 ;
19061 PyObject * obj2 = 0 ;
19062 PyObject * obj3 = 0 ;
19063 char * kwnames[] = {
19064 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
19065 };
19066
19067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19069 if (!SWIG_IsOK(res1)) {
19070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
19071 }
19072 arg1 = reinterpret_cast< wxImage * >(argp1);
19073 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19074 if (!SWIG_IsOK(ecode2)) {
19075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
19076 }
19077 arg2 = static_cast< byte >(val2);
19078 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19079 if (!SWIG_IsOK(ecode3)) {
19080 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
19081 }
19082 arg3 = static_cast< byte >(val3);
19083 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19084 if (!SWIG_IsOK(ecode4)) {
19085 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
19086 }
19087 arg4 = static_cast< byte >(val4);
19088 {
19089 PyThreadState* __tstate = wxPyBeginAllowThreads();
19090 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
19091 wxPyEndAllowThreads(__tstate);
19092 if (PyErr_Occurred()) SWIG_fail;
19093 }
19094 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19095 return resultobj;
19096 fail:
19097 return NULL;
19098 }
19099
19100
19101 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19102 PyObject *resultobj = 0;
19103 wxImage *arg1 = (wxImage *) 0 ;
19104 wxString *arg2 = 0 ;
19105 wxString *arg3 = 0 ;
19106 void *argp1 = 0 ;
19107 int res1 = 0 ;
19108 bool temp2 = false ;
19109 bool temp3 = false ;
19110 PyObject * obj0 = 0 ;
19111 PyObject * obj1 = 0 ;
19112 PyObject * obj2 = 0 ;
19113 char * kwnames[] = {
19114 (char *) "self",(char *) "name",(char *) "value", NULL
19115 };
19116
19117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19119 if (!SWIG_IsOK(res1)) {
19120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
19121 }
19122 arg1 = reinterpret_cast< wxImage * >(argp1);
19123 {
19124 arg2 = wxString_in_helper(obj1);
19125 if (arg2 == NULL) SWIG_fail;
19126 temp2 = true;
19127 }
19128 {
19129 arg3 = wxString_in_helper(obj2);
19130 if (arg3 == NULL) SWIG_fail;
19131 temp3 = true;
19132 }
19133 {
19134 PyThreadState* __tstate = wxPyBeginAllowThreads();
19135 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
19136 wxPyEndAllowThreads(__tstate);
19137 if (PyErr_Occurred()) SWIG_fail;
19138 }
19139 resultobj = SWIG_Py_Void();
19140 {
19141 if (temp2)
19142 delete arg2;
19143 }
19144 {
19145 if (temp3)
19146 delete arg3;
19147 }
19148 return resultobj;
19149 fail:
19150 {
19151 if (temp2)
19152 delete arg2;
19153 }
19154 {
19155 if (temp3)
19156 delete arg3;
19157 }
19158 return NULL;
19159 }
19160
19161
19162 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19163 PyObject *resultobj = 0;
19164 wxImage *arg1 = (wxImage *) 0 ;
19165 wxString *arg2 = 0 ;
19166 int arg3 ;
19167 void *argp1 = 0 ;
19168 int res1 = 0 ;
19169 bool temp2 = false ;
19170 int val3 ;
19171 int ecode3 = 0 ;
19172 PyObject * obj0 = 0 ;
19173 PyObject * obj1 = 0 ;
19174 PyObject * obj2 = 0 ;
19175 char * kwnames[] = {
19176 (char *) "self",(char *) "name",(char *) "value", NULL
19177 };
19178
19179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19181 if (!SWIG_IsOK(res1)) {
19182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
19183 }
19184 arg1 = reinterpret_cast< wxImage * >(argp1);
19185 {
19186 arg2 = wxString_in_helper(obj1);
19187 if (arg2 == NULL) SWIG_fail;
19188 temp2 = true;
19189 }
19190 ecode3 = SWIG_AsVal_int(obj2, &val3);
19191 if (!SWIG_IsOK(ecode3)) {
19192 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
19193 }
19194 arg3 = static_cast< int >(val3);
19195 {
19196 PyThreadState* __tstate = wxPyBeginAllowThreads();
19197 (arg1)->SetOption((wxString const &)*arg2,arg3);
19198 wxPyEndAllowThreads(__tstate);
19199 if (PyErr_Occurred()) SWIG_fail;
19200 }
19201 resultobj = SWIG_Py_Void();
19202 {
19203 if (temp2)
19204 delete arg2;
19205 }
19206 return resultobj;
19207 fail:
19208 {
19209 if (temp2)
19210 delete arg2;
19211 }
19212 return NULL;
19213 }
19214
19215
19216 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19217 PyObject *resultobj = 0;
19218 wxImage *arg1 = (wxImage *) 0 ;
19219 wxString *arg2 = 0 ;
19220 wxString result;
19221 void *argp1 = 0 ;
19222 int res1 = 0 ;
19223 bool temp2 = false ;
19224 PyObject * obj0 = 0 ;
19225 PyObject * obj1 = 0 ;
19226 char * kwnames[] = {
19227 (char *) "self",(char *) "name", NULL
19228 };
19229
19230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
19231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19232 if (!SWIG_IsOK(res1)) {
19233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19234 }
19235 arg1 = reinterpret_cast< wxImage * >(argp1);
19236 {
19237 arg2 = wxString_in_helper(obj1);
19238 if (arg2 == NULL) SWIG_fail;
19239 temp2 = true;
19240 }
19241 {
19242 PyThreadState* __tstate = wxPyBeginAllowThreads();
19243 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
19244 wxPyEndAllowThreads(__tstate);
19245 if (PyErr_Occurred()) SWIG_fail;
19246 }
19247 {
19248 #if wxUSE_UNICODE
19249 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19250 #else
19251 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19252 #endif
19253 }
19254 {
19255 if (temp2)
19256 delete arg2;
19257 }
19258 return resultobj;
19259 fail:
19260 {
19261 if (temp2)
19262 delete arg2;
19263 }
19264 return NULL;
19265 }
19266
19267
19268 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19269 PyObject *resultobj = 0;
19270 wxImage *arg1 = (wxImage *) 0 ;
19271 wxString *arg2 = 0 ;
19272 int result;
19273 void *argp1 = 0 ;
19274 int res1 = 0 ;
19275 bool temp2 = false ;
19276 PyObject * obj0 = 0 ;
19277 PyObject * obj1 = 0 ;
19278 char * kwnames[] = {
19279 (char *) "self",(char *) "name", NULL
19280 };
19281
19282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
19283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19284 if (!SWIG_IsOK(res1)) {
19285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
19286 }
19287 arg1 = reinterpret_cast< wxImage * >(argp1);
19288 {
19289 arg2 = wxString_in_helper(obj1);
19290 if (arg2 == NULL) SWIG_fail;
19291 temp2 = true;
19292 }
19293 {
19294 PyThreadState* __tstate = wxPyBeginAllowThreads();
19295 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
19296 wxPyEndAllowThreads(__tstate);
19297 if (PyErr_Occurred()) SWIG_fail;
19298 }
19299 resultobj = SWIG_From_int(static_cast< int >(result));
19300 {
19301 if (temp2)
19302 delete arg2;
19303 }
19304 return resultobj;
19305 fail:
19306 {
19307 if (temp2)
19308 delete arg2;
19309 }
19310 return NULL;
19311 }
19312
19313
19314 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19315 PyObject *resultobj = 0;
19316 wxImage *arg1 = (wxImage *) 0 ;
19317 wxString *arg2 = 0 ;
19318 bool result;
19319 void *argp1 = 0 ;
19320 int res1 = 0 ;
19321 bool temp2 = false ;
19322 PyObject * obj0 = 0 ;
19323 PyObject * obj1 = 0 ;
19324 char * kwnames[] = {
19325 (char *) "self",(char *) "name", NULL
19326 };
19327
19328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
19329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19330 if (!SWIG_IsOK(res1)) {
19331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19332 }
19333 arg1 = reinterpret_cast< wxImage * >(argp1);
19334 {
19335 arg2 = wxString_in_helper(obj1);
19336 if (arg2 == NULL) SWIG_fail;
19337 temp2 = true;
19338 }
19339 {
19340 PyThreadState* __tstate = wxPyBeginAllowThreads();
19341 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
19342 wxPyEndAllowThreads(__tstate);
19343 if (PyErr_Occurred()) SWIG_fail;
19344 }
19345 {
19346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19347 }
19348 {
19349 if (temp2)
19350 delete arg2;
19351 }
19352 return resultobj;
19353 fail:
19354 {
19355 if (temp2)
19356 delete arg2;
19357 }
19358 return NULL;
19359 }
19360
19361
19362 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19363 PyObject *resultobj = 0;
19364 wxImage *arg1 = (wxImage *) 0 ;
19365 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
19366 unsigned long result;
19367 void *argp1 = 0 ;
19368 int res1 = 0 ;
19369 unsigned long val2 ;
19370 int ecode2 = 0 ;
19371 PyObject * obj0 = 0 ;
19372 PyObject * obj1 = 0 ;
19373 char * kwnames[] = {
19374 (char *) "self",(char *) "stopafter", NULL
19375 };
19376
19377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
19378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19379 if (!SWIG_IsOK(res1)) {
19380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
19381 }
19382 arg1 = reinterpret_cast< wxImage * >(argp1);
19383 if (obj1) {
19384 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
19385 if (!SWIG_IsOK(ecode2)) {
19386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
19387 }
19388 arg2 = static_cast< unsigned long >(val2);
19389 }
19390 {
19391 PyThreadState* __tstate = wxPyBeginAllowThreads();
19392 result = (unsigned long)(arg1)->CountColours(arg2);
19393 wxPyEndAllowThreads(__tstate);
19394 if (PyErr_Occurred()) SWIG_fail;
19395 }
19396 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19397 return resultobj;
19398 fail:
19399 return NULL;
19400 }
19401
19402
19403 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19404 PyObject *resultobj = 0;
19405 wxImage *arg1 = (wxImage *) 0 ;
19406 wxImageHistogram *arg2 = 0 ;
19407 unsigned long result;
19408 void *argp1 = 0 ;
19409 int res1 = 0 ;
19410 void *argp2 = 0 ;
19411 int res2 = 0 ;
19412 PyObject * obj0 = 0 ;
19413 PyObject * obj1 = 0 ;
19414 char * kwnames[] = {
19415 (char *) "self",(char *) "h", NULL
19416 };
19417
19418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
19419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19420 if (!SWIG_IsOK(res1)) {
19421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
19422 }
19423 arg1 = reinterpret_cast< wxImage * >(argp1);
19424 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
19425 if (!SWIG_IsOK(res2)) {
19426 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19427 }
19428 if (!argp2) {
19429 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19430 }
19431 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
19432 {
19433 PyThreadState* __tstate = wxPyBeginAllowThreads();
19434 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
19435 wxPyEndAllowThreads(__tstate);
19436 if (PyErr_Occurred()) SWIG_fail;
19437 }
19438 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19439 return resultobj;
19440 fail:
19441 return NULL;
19442 }
19443
19444
19445 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19446 PyObject *resultobj = 0;
19447 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19448 void *argp1 = 0 ;
19449 int res1 = 0 ;
19450 PyObject * obj0 = 0 ;
19451 char * kwnames[] = {
19452 (char *) "handler", NULL
19453 };
19454
19455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
19456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19457 if (!SWIG_IsOK(res1)) {
19458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19459 }
19460 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19461 {
19462 PyThreadState* __tstate = wxPyBeginAllowThreads();
19463 wxImage::AddHandler(arg1);
19464 wxPyEndAllowThreads(__tstate);
19465 if (PyErr_Occurred()) SWIG_fail;
19466 }
19467 resultobj = SWIG_Py_Void();
19468 return resultobj;
19469 fail:
19470 return NULL;
19471 }
19472
19473
19474 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19475 PyObject *resultobj = 0;
19476 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19477 void *argp1 = 0 ;
19478 int res1 = 0 ;
19479 PyObject * obj0 = 0 ;
19480 char * kwnames[] = {
19481 (char *) "handler", NULL
19482 };
19483
19484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
19485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19486 if (!SWIG_IsOK(res1)) {
19487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19488 }
19489 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19490 {
19491 PyThreadState* __tstate = wxPyBeginAllowThreads();
19492 wxImage::InsertHandler(arg1);
19493 wxPyEndAllowThreads(__tstate);
19494 if (PyErr_Occurred()) SWIG_fail;
19495 }
19496 resultobj = SWIG_Py_Void();
19497 return resultobj;
19498 fail:
19499 return NULL;
19500 }
19501
19502
19503 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19504 PyObject *resultobj = 0;
19505 wxString *arg1 = 0 ;
19506 bool result;
19507 bool temp1 = false ;
19508 PyObject * obj0 = 0 ;
19509 char * kwnames[] = {
19510 (char *) "name", NULL
19511 };
19512
19513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
19514 {
19515 arg1 = wxString_in_helper(obj0);
19516 if (arg1 == NULL) SWIG_fail;
19517 temp1 = true;
19518 }
19519 {
19520 PyThreadState* __tstate = wxPyBeginAllowThreads();
19521 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
19522 wxPyEndAllowThreads(__tstate);
19523 if (PyErr_Occurred()) SWIG_fail;
19524 }
19525 {
19526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19527 }
19528 {
19529 if (temp1)
19530 delete arg1;
19531 }
19532 return resultobj;
19533 fail:
19534 {
19535 if (temp1)
19536 delete arg1;
19537 }
19538 return NULL;
19539 }
19540
19541
19542 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19543 PyObject *resultobj = 0;
19544 PyObject *result = 0 ;
19545
19546 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
19547 {
19548 PyThreadState* __tstate = wxPyBeginAllowThreads();
19549 result = (PyObject *)wxImage_GetHandlers();
19550 wxPyEndAllowThreads(__tstate);
19551 if (PyErr_Occurred()) SWIG_fail;
19552 }
19553 resultobj = result;
19554 return resultobj;
19555 fail:
19556 return NULL;
19557 }
19558
19559
19560 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19561 PyObject *resultobj = 0;
19562 wxString result;
19563
19564 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
19565 {
19566 PyThreadState* __tstate = wxPyBeginAllowThreads();
19567 result = wxImage::GetImageExtWildcard();
19568 wxPyEndAllowThreads(__tstate);
19569 if (PyErr_Occurred()) SWIG_fail;
19570 }
19571 {
19572 #if wxUSE_UNICODE
19573 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19574 #else
19575 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19576 #endif
19577 }
19578 return resultobj;
19579 fail:
19580 return NULL;
19581 }
19582
19583
19584 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19585 PyObject *resultobj = 0;
19586 wxImage *arg1 = (wxImage *) 0 ;
19587 int arg2 = (int) -1 ;
19588 wxBitmap result;
19589 void *argp1 = 0 ;
19590 int res1 = 0 ;
19591 int val2 ;
19592 int ecode2 = 0 ;
19593 PyObject * obj0 = 0 ;
19594 PyObject * obj1 = 0 ;
19595 char * kwnames[] = {
19596 (char *) "self",(char *) "depth", NULL
19597 };
19598
19599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
19600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19601 if (!SWIG_IsOK(res1)) {
19602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19603 }
19604 arg1 = reinterpret_cast< wxImage * >(argp1);
19605 if (obj1) {
19606 ecode2 = SWIG_AsVal_int(obj1, &val2);
19607 if (!SWIG_IsOK(ecode2)) {
19608 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
19609 }
19610 arg2 = static_cast< int >(val2);
19611 }
19612 {
19613 if (!wxPyCheckForApp()) SWIG_fail;
19614 PyThreadState* __tstate = wxPyBeginAllowThreads();
19615 result = wxImage_ConvertToBitmap(arg1,arg2);
19616 wxPyEndAllowThreads(__tstate);
19617 if (PyErr_Occurred()) SWIG_fail;
19618 }
19619 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19620 return resultobj;
19621 fail:
19622 return NULL;
19623 }
19624
19625
19626 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19627 PyObject *resultobj = 0;
19628 wxImage *arg1 = (wxImage *) 0 ;
19629 byte arg2 ;
19630 byte arg3 ;
19631 byte arg4 ;
19632 wxBitmap result;
19633 void *argp1 = 0 ;
19634 int res1 = 0 ;
19635 unsigned char val2 ;
19636 int ecode2 = 0 ;
19637 unsigned char val3 ;
19638 int ecode3 = 0 ;
19639 unsigned char val4 ;
19640 int ecode4 = 0 ;
19641 PyObject * obj0 = 0 ;
19642 PyObject * obj1 = 0 ;
19643 PyObject * obj2 = 0 ;
19644 PyObject * obj3 = 0 ;
19645 char * kwnames[] = {
19646 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
19647 };
19648
19649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19651 if (!SWIG_IsOK(res1)) {
19652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19653 }
19654 arg1 = reinterpret_cast< wxImage * >(argp1);
19655 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19656 if (!SWIG_IsOK(ecode2)) {
19657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
19658 }
19659 arg2 = static_cast< byte >(val2);
19660 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19661 if (!SWIG_IsOK(ecode3)) {
19662 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
19663 }
19664 arg3 = static_cast< byte >(val3);
19665 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19666 if (!SWIG_IsOK(ecode4)) {
19667 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
19668 }
19669 arg4 = static_cast< byte >(val4);
19670 {
19671 if (!wxPyCheckForApp()) SWIG_fail;
19672 PyThreadState* __tstate = wxPyBeginAllowThreads();
19673 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
19674 wxPyEndAllowThreads(__tstate);
19675 if (PyErr_Occurred()) SWIG_fail;
19676 }
19677 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19678 return resultobj;
19679 fail:
19680 return NULL;
19681 }
19682
19683
19684 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19685 PyObject *resultobj = 0;
19686 wxImage *arg1 = (wxImage *) 0 ;
19687 double arg2 ;
19688 void *argp1 = 0 ;
19689 int res1 = 0 ;
19690 double val2 ;
19691 int ecode2 = 0 ;
19692 PyObject * obj0 = 0 ;
19693 PyObject * obj1 = 0 ;
19694 char * kwnames[] = {
19695 (char *) "self",(char *) "angle", NULL
19696 };
19697
19698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
19699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19700 if (!SWIG_IsOK(res1)) {
19701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
19702 }
19703 arg1 = reinterpret_cast< wxImage * >(argp1);
19704 ecode2 = SWIG_AsVal_double(obj1, &val2);
19705 if (!SWIG_IsOK(ecode2)) {
19706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
19707 }
19708 arg2 = static_cast< double >(val2);
19709 {
19710 PyThreadState* __tstate = wxPyBeginAllowThreads();
19711 (arg1)->RotateHue(arg2);
19712 wxPyEndAllowThreads(__tstate);
19713 if (PyErr_Occurred()) SWIG_fail;
19714 }
19715 resultobj = SWIG_Py_Void();
19716 return resultobj;
19717 fail:
19718 return NULL;
19719 }
19720
19721
19722 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19723 PyObject *resultobj = 0;
19724 wxImage_RGBValue arg1 ;
19725 wxImage_HSVValue result;
19726 void *argp1 ;
19727 int res1 = 0 ;
19728 PyObject * obj0 = 0 ;
19729 char * kwnames[] = {
19730 (char *) "rgb", NULL
19731 };
19732
19733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
19734 {
19735 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
19736 if (!SWIG_IsOK(res1)) {
19737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19738 }
19739 if (!argp1) {
19740 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19741 } else {
19742 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
19743 arg1 = *temp;
19744 if (SWIG_IsNewObj(res1)) delete temp;
19745 }
19746 }
19747 {
19748 PyThreadState* __tstate = wxPyBeginAllowThreads();
19749 result = wxImage::RGBtoHSV(arg1);
19750 wxPyEndAllowThreads(__tstate);
19751 if (PyErr_Occurred()) SWIG_fail;
19752 }
19753 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
19754 return resultobj;
19755 fail:
19756 return NULL;
19757 }
19758
19759
19760 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19761 PyObject *resultobj = 0;
19762 wxImage_HSVValue arg1 ;
19763 wxImage_RGBValue result;
19764 void *argp1 ;
19765 int res1 = 0 ;
19766 PyObject * obj0 = 0 ;
19767 char * kwnames[] = {
19768 (char *) "hsv", NULL
19769 };
19770
19771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
19772 {
19773 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
19774 if (!SWIG_IsOK(res1)) {
19775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19776 }
19777 if (!argp1) {
19778 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19779 } else {
19780 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
19781 arg1 = *temp;
19782 if (SWIG_IsNewObj(res1)) delete temp;
19783 }
19784 }
19785 {
19786 PyThreadState* __tstate = wxPyBeginAllowThreads();
19787 result = wxImage::HSVtoRGB(arg1);
19788 wxPyEndAllowThreads(__tstate);
19789 if (PyErr_Occurred()) SWIG_fail;
19790 }
19791 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
19792 return resultobj;
19793 fail:
19794 return NULL;
19795 }
19796
19797
19798 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19799 PyObject *obj;
19800 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19801 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
19802 return SWIG_Py_Void();
19803 }
19804
19805 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19806 return SWIG_Python_InitShadowInstance(args);
19807 }
19808
19809 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19810 PyObject *resultobj = 0;
19811 int arg1 ;
19812 int arg2 ;
19813 buffer arg3 ;
19814 int arg4 ;
19815 buffer arg5 = (buffer) NULL ;
19816 int arg6 = (int) 0 ;
19817 wxImage *result = 0 ;
19818 int val1 ;
19819 int ecode1 = 0 ;
19820 int val2 ;
19821 int ecode2 = 0 ;
19822 Py_ssize_t temp3 ;
19823 Py_ssize_t temp5 ;
19824 PyObject * obj0 = 0 ;
19825 PyObject * obj1 = 0 ;
19826 PyObject * obj2 = 0 ;
19827 PyObject * obj3 = 0 ;
19828 char * kwnames[] = {
19829 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
19830 };
19831
19832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19833 ecode1 = SWIG_AsVal_int(obj0, &val1);
19834 if (!SWIG_IsOK(ecode1)) {
19835 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
19836 }
19837 arg1 = static_cast< int >(val1);
19838 ecode2 = SWIG_AsVal_int(obj1, &val2);
19839 if (!SWIG_IsOK(ecode2)) {
19840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
19841 }
19842 arg2 = static_cast< int >(val2);
19843 {
19844 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
19845 arg4 = (int)temp3;
19846 }
19847 if (obj3) {
19848 {
19849 if (obj3 != Py_None) {
19850 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
19851 arg6 = (int)temp5;
19852 }
19853 }
19854 }
19855 {
19856 PyThreadState* __tstate = wxPyBeginAllowThreads();
19857 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
19858 wxPyEndAllowThreads(__tstate);
19859 if (PyErr_Occurred()) SWIG_fail;
19860 }
19861 {
19862 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
19863 }
19864 return resultobj;
19865 fail:
19866 return NULL;
19867 }
19868
19869
19870 SWIGINTERN int NullImage_set(PyObject *) {
19871 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
19872 return 1;
19873 }
19874
19875
19876 SWIGINTERN PyObject *NullImage_get(void) {
19877 PyObject *pyobj = 0;
19878
19879 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
19880 return pyobj;
19881 }
19882
19883
19884 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
19885 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
19886 return 1;
19887 }
19888
19889
19890 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
19891 PyObject *pyobj = 0;
19892
19893 {
19894 #if wxUSE_UNICODE
19895 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19896 #else
19897 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19898 #endif
19899 }
19900 return pyobj;
19901 }
19902
19903
19904 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
19905 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
19906 return 1;
19907 }
19908
19909
19910 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
19911 PyObject *pyobj = 0;
19912
19913 {
19914 #if wxUSE_UNICODE
19915 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19916 #else
19917 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19918 #endif
19919 }
19920 return pyobj;
19921 }
19922
19923
19924 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
19925 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
19926 return 1;
19927 }
19928
19929
19930 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
19931 PyObject *pyobj = 0;
19932
19933 {
19934 #if wxUSE_UNICODE
19935 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19936 #else
19937 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19938 #endif
19939 }
19940 return pyobj;
19941 }
19942
19943
19944 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
19945 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
19946 return 1;
19947 }
19948
19949
19950 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
19951 PyObject *pyobj = 0;
19952
19953 {
19954 #if wxUSE_UNICODE
19955 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19956 #else
19957 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19958 #endif
19959 }
19960 return pyobj;
19961 }
19962
19963
19964 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
19965 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
19966 return 1;
19967 }
19968
19969
19970 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
19971 PyObject *pyobj = 0;
19972
19973 {
19974 #if wxUSE_UNICODE
19975 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19976 #else
19977 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19978 #endif
19979 }
19980 return pyobj;
19981 }
19982
19983
19984 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
19985 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
19986 return 1;
19987 }
19988
19989
19990 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
19991 PyObject *pyobj = 0;
19992
19993 {
19994 #if wxUSE_UNICODE
19995 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
19996 #else
19997 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
19998 #endif
19999 }
20000 return pyobj;
20001 }
20002
20003
20004 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
20005 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
20006 return 1;
20007 }
20008
20009
20010 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
20011 PyObject *pyobj = 0;
20012
20013 {
20014 #if wxUSE_UNICODE
20015 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
20016 #else
20017 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
20018 #endif
20019 }
20020 return pyobj;
20021 }
20022
20023
20024 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
20025 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
20026 return 1;
20027 }
20028
20029
20030 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
20031 PyObject *pyobj = 0;
20032
20033 {
20034 #if wxUSE_UNICODE
20035 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
20036 #else
20037 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
20038 #endif
20039 }
20040 return pyobj;
20041 }
20042
20043
20044 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
20045 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
20046 return 1;
20047 }
20048
20049
20050 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
20051 PyObject *pyobj = 0;
20052
20053 {
20054 #if wxUSE_UNICODE
20055 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
20056 #else
20057 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
20058 #endif
20059 }
20060 return pyobj;
20061 }
20062
20063
20064 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
20065 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
20066 return 1;
20067 }
20068
20069
20070 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
20071 PyObject *pyobj = 0;
20072
20073 {
20074 #if wxUSE_UNICODE
20075 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20076 #else
20077 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20078 #endif
20079 }
20080 return pyobj;
20081 }
20082
20083
20084 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
20085 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
20086 return 1;
20087 }
20088
20089
20090 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
20091 PyObject *pyobj = 0;
20092
20093 {
20094 #if wxUSE_UNICODE
20095 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20096 #else
20097 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20098 #endif
20099 }
20100 return pyobj;
20101 }
20102
20103
20104 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
20105 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
20106 return 1;
20107 }
20108
20109
20110 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
20111 PyObject *pyobj = 0;
20112
20113 {
20114 #if wxUSE_UNICODE
20115 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20116 #else
20117 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20118 #endif
20119 }
20120 return pyobj;
20121 }
20122
20123
20124 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
20125 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
20126 return 1;
20127 }
20128
20129
20130 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
20131 PyObject *pyobj = 0;
20132
20133 {
20134 #if wxUSE_UNICODE
20135 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20136 #else
20137 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20138 #endif
20139 }
20140 return pyobj;
20141 }
20142
20143
20144 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
20145 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
20146 return 1;
20147 }
20148
20149
20150 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
20151 PyObject *pyobj = 0;
20152
20153 {
20154 #if wxUSE_UNICODE
20155 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20156 #else
20157 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20158 #endif
20159 }
20160 return pyobj;
20161 }
20162
20163
20164 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
20165 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
20166 return 1;
20167 }
20168
20169
20170 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
20171 PyObject *pyobj = 0;
20172
20173 {
20174 #if wxUSE_UNICODE
20175 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20176 #else
20177 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20178 #endif
20179 }
20180 return pyobj;
20181 }
20182
20183
20184 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20185 PyObject *resultobj = 0;
20186 wxBMPHandler *result = 0 ;
20187
20188 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
20189 {
20190 PyThreadState* __tstate = wxPyBeginAllowThreads();
20191 result = (wxBMPHandler *)new wxBMPHandler();
20192 wxPyEndAllowThreads(__tstate);
20193 if (PyErr_Occurred()) SWIG_fail;
20194 }
20195 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
20196 return resultobj;
20197 fail:
20198 return NULL;
20199 }
20200
20201
20202 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20203 PyObject *obj;
20204 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20205 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
20206 return SWIG_Py_Void();
20207 }
20208
20209 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20210 return SWIG_Python_InitShadowInstance(args);
20211 }
20212
20213 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20214 PyObject *resultobj = 0;
20215 wxICOHandler *result = 0 ;
20216
20217 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
20218 {
20219 PyThreadState* __tstate = wxPyBeginAllowThreads();
20220 result = (wxICOHandler *)new wxICOHandler();
20221 wxPyEndAllowThreads(__tstate);
20222 if (PyErr_Occurred()) SWIG_fail;
20223 }
20224 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
20225 return resultobj;
20226 fail:
20227 return NULL;
20228 }
20229
20230
20231 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20232 PyObject *obj;
20233 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20234 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
20235 return SWIG_Py_Void();
20236 }
20237
20238 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20239 return SWIG_Python_InitShadowInstance(args);
20240 }
20241
20242 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20243 PyObject *resultobj = 0;
20244 wxCURHandler *result = 0 ;
20245
20246 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
20247 {
20248 PyThreadState* __tstate = wxPyBeginAllowThreads();
20249 result = (wxCURHandler *)new wxCURHandler();
20250 wxPyEndAllowThreads(__tstate);
20251 if (PyErr_Occurred()) SWIG_fail;
20252 }
20253 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
20254 return resultobj;
20255 fail:
20256 return NULL;
20257 }
20258
20259
20260 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20261 PyObject *obj;
20262 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20263 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
20264 return SWIG_Py_Void();
20265 }
20266
20267 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20268 return SWIG_Python_InitShadowInstance(args);
20269 }
20270
20271 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20272 PyObject *resultobj = 0;
20273 wxANIHandler *result = 0 ;
20274
20275 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
20276 {
20277 PyThreadState* __tstate = wxPyBeginAllowThreads();
20278 result = (wxANIHandler *)new wxANIHandler();
20279 wxPyEndAllowThreads(__tstate);
20280 if (PyErr_Occurred()) SWIG_fail;
20281 }
20282 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
20283 return resultobj;
20284 fail:
20285 return NULL;
20286 }
20287
20288
20289 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20290 PyObject *obj;
20291 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20292 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
20293 return SWIG_Py_Void();
20294 }
20295
20296 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20297 return SWIG_Python_InitShadowInstance(args);
20298 }
20299
20300 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20301 PyObject *resultobj = 0;
20302 wxPNGHandler *result = 0 ;
20303
20304 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
20305 {
20306 PyThreadState* __tstate = wxPyBeginAllowThreads();
20307 result = (wxPNGHandler *)new wxPNGHandler();
20308 wxPyEndAllowThreads(__tstate);
20309 if (PyErr_Occurred()) SWIG_fail;
20310 }
20311 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
20312 return resultobj;
20313 fail:
20314 return NULL;
20315 }
20316
20317
20318 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20319 PyObject *obj;
20320 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20321 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
20322 return SWIG_Py_Void();
20323 }
20324
20325 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20326 return SWIG_Python_InitShadowInstance(args);
20327 }
20328
20329 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20330 PyObject *resultobj = 0;
20331 wxGIFHandler *result = 0 ;
20332
20333 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
20334 {
20335 PyThreadState* __tstate = wxPyBeginAllowThreads();
20336 result = (wxGIFHandler *)new wxGIFHandler();
20337 wxPyEndAllowThreads(__tstate);
20338 if (PyErr_Occurred()) SWIG_fail;
20339 }
20340 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
20341 return resultobj;
20342 fail:
20343 return NULL;
20344 }
20345
20346
20347 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20348 PyObject *obj;
20349 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20350 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
20351 return SWIG_Py_Void();
20352 }
20353
20354 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20355 return SWIG_Python_InitShadowInstance(args);
20356 }
20357
20358 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20359 PyObject *resultobj = 0;
20360 wxPCXHandler *result = 0 ;
20361
20362 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
20363 {
20364 PyThreadState* __tstate = wxPyBeginAllowThreads();
20365 result = (wxPCXHandler *)new wxPCXHandler();
20366 wxPyEndAllowThreads(__tstate);
20367 if (PyErr_Occurred()) SWIG_fail;
20368 }
20369 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
20370 return resultobj;
20371 fail:
20372 return NULL;
20373 }
20374
20375
20376 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20377 PyObject *obj;
20378 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20379 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
20380 return SWIG_Py_Void();
20381 }
20382
20383 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20384 return SWIG_Python_InitShadowInstance(args);
20385 }
20386
20387 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20388 PyObject *resultobj = 0;
20389 wxJPEGHandler *result = 0 ;
20390
20391 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
20392 {
20393 PyThreadState* __tstate = wxPyBeginAllowThreads();
20394 result = (wxJPEGHandler *)new wxJPEGHandler();
20395 wxPyEndAllowThreads(__tstate);
20396 if (PyErr_Occurred()) SWIG_fail;
20397 }
20398 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
20399 return resultobj;
20400 fail:
20401 return NULL;
20402 }
20403
20404
20405 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20406 PyObject *obj;
20407 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20408 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
20409 return SWIG_Py_Void();
20410 }
20411
20412 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20413 return SWIG_Python_InitShadowInstance(args);
20414 }
20415
20416 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20417 PyObject *resultobj = 0;
20418 wxPNMHandler *result = 0 ;
20419
20420 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
20421 {
20422 PyThreadState* __tstate = wxPyBeginAllowThreads();
20423 result = (wxPNMHandler *)new wxPNMHandler();
20424 wxPyEndAllowThreads(__tstate);
20425 if (PyErr_Occurred()) SWIG_fail;
20426 }
20427 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
20428 return resultobj;
20429 fail:
20430 return NULL;
20431 }
20432
20433
20434 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20435 PyObject *obj;
20436 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20437 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
20438 return SWIG_Py_Void();
20439 }
20440
20441 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20442 return SWIG_Python_InitShadowInstance(args);
20443 }
20444
20445 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20446 PyObject *resultobj = 0;
20447 wxXPMHandler *result = 0 ;
20448
20449 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
20450 {
20451 PyThreadState* __tstate = wxPyBeginAllowThreads();
20452 result = (wxXPMHandler *)new wxXPMHandler();
20453 wxPyEndAllowThreads(__tstate);
20454 if (PyErr_Occurred()) SWIG_fail;
20455 }
20456 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
20457 return resultobj;
20458 fail:
20459 return NULL;
20460 }
20461
20462
20463 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20464 PyObject *obj;
20465 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20466 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
20467 return SWIG_Py_Void();
20468 }
20469
20470 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20471 return SWIG_Python_InitShadowInstance(args);
20472 }
20473
20474 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20475 PyObject *resultobj = 0;
20476 wxTIFFHandler *result = 0 ;
20477
20478 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
20479 {
20480 PyThreadState* __tstate = wxPyBeginAllowThreads();
20481 result = (wxTIFFHandler *)new wxTIFFHandler();
20482 wxPyEndAllowThreads(__tstate);
20483 if (PyErr_Occurred()) SWIG_fail;
20484 }
20485 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
20486 return resultobj;
20487 fail:
20488 return NULL;
20489 }
20490
20491
20492 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20493 PyObject *obj;
20494 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20495 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
20496 return SWIG_Py_Void();
20497 }
20498
20499 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20500 return SWIG_Python_InitShadowInstance(args);
20501 }
20502
20503 SWIGINTERN PyObject *_wrap_new_TGAHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20504 PyObject *resultobj = 0;
20505 wxTGAHandler *result = 0 ;
20506
20507 if (!SWIG_Python_UnpackTuple(args,"new_TGAHandler",0,0,0)) SWIG_fail;
20508 {
20509 PyThreadState* __tstate = wxPyBeginAllowThreads();
20510 result = (wxTGAHandler *)new wxTGAHandler();
20511 wxPyEndAllowThreads(__tstate);
20512 if (PyErr_Occurred()) SWIG_fail;
20513 }
20514 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTGAHandler, SWIG_POINTER_NEW | 0 );
20515 return resultobj;
20516 fail:
20517 return NULL;
20518 }
20519
20520
20521 SWIGINTERN PyObject *TGAHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20522 PyObject *obj;
20523 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20524 SWIG_TypeNewClientData(SWIGTYPE_p_wxTGAHandler, SWIG_NewClientData(obj));
20525 return SWIG_Py_Void();
20526 }
20527
20528 SWIGINTERN PyObject *TGAHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20529 return SWIG_Python_InitShadowInstance(args);
20530 }
20531
20532 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20533 PyObject *resultobj = 0;
20534 wxImage *arg1 = 0 ;
20535 wxImage *arg2 = 0 ;
20536 int arg3 = (int) 236 ;
20537 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
20538 bool result;
20539 void *argp1 = 0 ;
20540 int res1 = 0 ;
20541 void *argp2 = 0 ;
20542 int res2 = 0 ;
20543 int val3 ;
20544 int ecode3 = 0 ;
20545 int val4 ;
20546 int ecode4 = 0 ;
20547 PyObject * obj0 = 0 ;
20548 PyObject * obj1 = 0 ;
20549 PyObject * obj2 = 0 ;
20550 PyObject * obj3 = 0 ;
20551 char * kwnames[] = {
20552 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
20553 };
20554
20555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20556 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
20557 if (!SWIG_IsOK(res1)) {
20558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20559 }
20560 if (!argp1) {
20561 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20562 }
20563 arg1 = reinterpret_cast< wxImage * >(argp1);
20564 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
20565 if (!SWIG_IsOK(res2)) {
20566 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20567 }
20568 if (!argp2) {
20569 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20570 }
20571 arg2 = reinterpret_cast< wxImage * >(argp2);
20572 if (obj2) {
20573 ecode3 = SWIG_AsVal_int(obj2, &val3);
20574 if (!SWIG_IsOK(ecode3)) {
20575 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
20576 }
20577 arg3 = static_cast< int >(val3);
20578 }
20579 if (obj3) {
20580 ecode4 = SWIG_AsVal_int(obj3, &val4);
20581 if (!SWIG_IsOK(ecode4)) {
20582 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
20583 }
20584 arg4 = static_cast< int >(val4);
20585 }
20586 {
20587 PyThreadState* __tstate = wxPyBeginAllowThreads();
20588 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
20589 wxPyEndAllowThreads(__tstate);
20590 if (PyErr_Occurred()) SWIG_fail;
20591 }
20592 {
20593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20594 }
20595 return resultobj;
20596 fail:
20597 return NULL;
20598 }
20599
20600
20601 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20602 PyObject *obj;
20603 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20604 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
20605 return SWIG_Py_Void();
20606 }
20607
20608 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20609 PyObject *resultobj = 0;
20610 wxEvtHandler *result = 0 ;
20611
20612 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
20613 {
20614 PyThreadState* __tstate = wxPyBeginAllowThreads();
20615 result = (wxEvtHandler *)new wxEvtHandler();
20616 wxPyEndAllowThreads(__tstate);
20617 if (PyErr_Occurred()) SWIG_fail;
20618 }
20619 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
20620 return resultobj;
20621 fail:
20622 return NULL;
20623 }
20624
20625
20626 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20627 PyObject *resultobj = 0;
20628 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20629 wxEvtHandler *result = 0 ;
20630 void *argp1 = 0 ;
20631 int res1 = 0 ;
20632 PyObject *swig_obj[1] ;
20633
20634 if (!args) SWIG_fail;
20635 swig_obj[0] = args;
20636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20637 if (!SWIG_IsOK(res1)) {
20638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20639 }
20640 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20641 {
20642 PyThreadState* __tstate = wxPyBeginAllowThreads();
20643 result = (wxEvtHandler *)(arg1)->GetNextHandler();
20644 wxPyEndAllowThreads(__tstate);
20645 if (PyErr_Occurred()) SWIG_fail;
20646 }
20647 {
20648 resultobj = wxPyMake_wxObject(result, 0);
20649 }
20650 return resultobj;
20651 fail:
20652 return NULL;
20653 }
20654
20655
20656 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20657 PyObject *resultobj = 0;
20658 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20659 wxEvtHandler *result = 0 ;
20660 void *argp1 = 0 ;
20661 int res1 = 0 ;
20662 PyObject *swig_obj[1] ;
20663
20664 if (!args) SWIG_fail;
20665 swig_obj[0] = args;
20666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20667 if (!SWIG_IsOK(res1)) {
20668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20669 }
20670 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20671 {
20672 PyThreadState* __tstate = wxPyBeginAllowThreads();
20673 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
20674 wxPyEndAllowThreads(__tstate);
20675 if (PyErr_Occurred()) SWIG_fail;
20676 }
20677 {
20678 resultobj = wxPyMake_wxObject(result, 0);
20679 }
20680 return resultobj;
20681 fail:
20682 return NULL;
20683 }
20684
20685
20686 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20687 PyObject *resultobj = 0;
20688 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20689 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20690 void *argp1 = 0 ;
20691 int res1 = 0 ;
20692 void *argp2 = 0 ;
20693 int res2 = 0 ;
20694 PyObject * obj0 = 0 ;
20695 PyObject * obj1 = 0 ;
20696 char * kwnames[] = {
20697 (char *) "self",(char *) "handler", NULL
20698 };
20699
20700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20702 if (!SWIG_IsOK(res1)) {
20703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20704 }
20705 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20706 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20707 if (!SWIG_IsOK(res2)) {
20708 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20709 }
20710 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20711 {
20712 PyThreadState* __tstate = wxPyBeginAllowThreads();
20713 (arg1)->SetNextHandler(arg2);
20714 wxPyEndAllowThreads(__tstate);
20715 if (PyErr_Occurred()) SWIG_fail;
20716 }
20717 resultobj = SWIG_Py_Void();
20718 return resultobj;
20719 fail:
20720 return NULL;
20721 }
20722
20723
20724 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20725 PyObject *resultobj = 0;
20726 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20727 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20728 void *argp1 = 0 ;
20729 int res1 = 0 ;
20730 void *argp2 = 0 ;
20731 int res2 = 0 ;
20732 PyObject * obj0 = 0 ;
20733 PyObject * obj1 = 0 ;
20734 char * kwnames[] = {
20735 (char *) "self",(char *) "handler", NULL
20736 };
20737
20738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20740 if (!SWIG_IsOK(res1)) {
20741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20742 }
20743 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20744 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20745 if (!SWIG_IsOK(res2)) {
20746 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20747 }
20748 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20749 {
20750 PyThreadState* __tstate = wxPyBeginAllowThreads();
20751 (arg1)->SetPreviousHandler(arg2);
20752 wxPyEndAllowThreads(__tstate);
20753 if (PyErr_Occurred()) SWIG_fail;
20754 }
20755 resultobj = SWIG_Py_Void();
20756 return resultobj;
20757 fail:
20758 return NULL;
20759 }
20760
20761
20762 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20763 PyObject *resultobj = 0;
20764 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20765 bool result;
20766 void *argp1 = 0 ;
20767 int res1 = 0 ;
20768 PyObject *swig_obj[1] ;
20769
20770 if (!args) SWIG_fail;
20771 swig_obj[0] = args;
20772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20773 if (!SWIG_IsOK(res1)) {
20774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20775 }
20776 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20777 {
20778 PyThreadState* __tstate = wxPyBeginAllowThreads();
20779 result = (bool)(arg1)->GetEvtHandlerEnabled();
20780 wxPyEndAllowThreads(__tstate);
20781 if (PyErr_Occurred()) SWIG_fail;
20782 }
20783 {
20784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20785 }
20786 return resultobj;
20787 fail:
20788 return NULL;
20789 }
20790
20791
20792 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20793 PyObject *resultobj = 0;
20794 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20795 bool arg2 ;
20796 void *argp1 = 0 ;
20797 int res1 = 0 ;
20798 bool val2 ;
20799 int ecode2 = 0 ;
20800 PyObject * obj0 = 0 ;
20801 PyObject * obj1 = 0 ;
20802 char * kwnames[] = {
20803 (char *) "self",(char *) "enabled", NULL
20804 };
20805
20806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
20807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20808 if (!SWIG_IsOK(res1)) {
20809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20810 }
20811 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20812 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20813 if (!SWIG_IsOK(ecode2)) {
20814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
20815 }
20816 arg2 = static_cast< bool >(val2);
20817 {
20818 PyThreadState* __tstate = wxPyBeginAllowThreads();
20819 (arg1)->SetEvtHandlerEnabled(arg2);
20820 wxPyEndAllowThreads(__tstate);
20821 if (PyErr_Occurred()) SWIG_fail;
20822 }
20823 resultobj = SWIG_Py_Void();
20824 return resultobj;
20825 fail:
20826 return NULL;
20827 }
20828
20829
20830 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20831 PyObject *resultobj = 0;
20832 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20833 wxEvent *arg2 = 0 ;
20834 bool result;
20835 void *argp1 = 0 ;
20836 int res1 = 0 ;
20837 void *argp2 = 0 ;
20838 int res2 = 0 ;
20839 PyObject * obj0 = 0 ;
20840 PyObject * obj1 = 0 ;
20841 char * kwnames[] = {
20842 (char *) "self",(char *) "event", NULL
20843 };
20844
20845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20847 if (!SWIG_IsOK(res1)) {
20848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20849 }
20850 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20851 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20852 if (!SWIG_IsOK(res2)) {
20853 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20854 }
20855 if (!argp2) {
20856 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20857 }
20858 arg2 = reinterpret_cast< wxEvent * >(argp2);
20859 {
20860 PyThreadState* __tstate = wxPyBeginAllowThreads();
20861 result = (bool)(arg1)->ProcessEvent(*arg2);
20862 wxPyEndAllowThreads(__tstate);
20863 if (PyErr_Occurred()) SWIG_fail;
20864 }
20865 {
20866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20867 }
20868 return resultobj;
20869 fail:
20870 return NULL;
20871 }
20872
20873
20874 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20875 PyObject *resultobj = 0;
20876 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20877 wxEvent *arg2 = 0 ;
20878 void *argp1 = 0 ;
20879 int res1 = 0 ;
20880 void *argp2 = 0 ;
20881 int res2 = 0 ;
20882 PyObject * obj0 = 0 ;
20883 PyObject * obj1 = 0 ;
20884 char * kwnames[] = {
20885 (char *) "self",(char *) "event", NULL
20886 };
20887
20888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20890 if (!SWIG_IsOK(res1)) {
20891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20892 }
20893 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20894 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20895 if (!SWIG_IsOK(res2)) {
20896 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20897 }
20898 if (!argp2) {
20899 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20900 }
20901 arg2 = reinterpret_cast< wxEvent * >(argp2);
20902 {
20903 PyThreadState* __tstate = wxPyBeginAllowThreads();
20904 (arg1)->AddPendingEvent(*arg2);
20905 wxPyEndAllowThreads(__tstate);
20906 if (PyErr_Occurred()) SWIG_fail;
20907 }
20908 resultobj = SWIG_Py_Void();
20909 return resultobj;
20910 fail:
20911 return NULL;
20912 }
20913
20914
20915 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20916 PyObject *resultobj = 0;
20917 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20918 void *argp1 = 0 ;
20919 int res1 = 0 ;
20920 PyObject *swig_obj[1] ;
20921
20922 if (!args) SWIG_fail;
20923 swig_obj[0] = args;
20924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20925 if (!SWIG_IsOK(res1)) {
20926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20927 }
20928 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20929 {
20930 PyThreadState* __tstate = wxPyBeginAllowThreads();
20931 (arg1)->ProcessPendingEvents();
20932 wxPyEndAllowThreads(__tstate);
20933 if (PyErr_Occurred()) SWIG_fail;
20934 }
20935 resultobj = SWIG_Py_Void();
20936 return resultobj;
20937 fail:
20938 return NULL;
20939 }
20940
20941
20942 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20943 PyObject *resultobj = 0;
20944 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20945 int arg2 ;
20946 int arg3 ;
20947 int arg4 ;
20948 PyObject *arg5 = (PyObject *) 0 ;
20949 void *argp1 = 0 ;
20950 int res1 = 0 ;
20951 int val2 ;
20952 int ecode2 = 0 ;
20953 int val3 ;
20954 int ecode3 = 0 ;
20955 int val4 ;
20956 int ecode4 = 0 ;
20957 PyObject * obj0 = 0 ;
20958 PyObject * obj1 = 0 ;
20959 PyObject * obj2 = 0 ;
20960 PyObject * obj3 = 0 ;
20961 PyObject * obj4 = 0 ;
20962 char * kwnames[] = {
20963 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
20964 };
20965
20966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
20967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20968 if (!SWIG_IsOK(res1)) {
20969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20970 }
20971 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20972 ecode2 = SWIG_AsVal_int(obj1, &val2);
20973 if (!SWIG_IsOK(ecode2)) {
20974 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
20975 }
20976 arg2 = static_cast< int >(val2);
20977 ecode3 = SWIG_AsVal_int(obj2, &val3);
20978 if (!SWIG_IsOK(ecode3)) {
20979 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
20980 }
20981 arg3 = static_cast< int >(val3);
20982 ecode4 = SWIG_AsVal_int(obj3, &val4);
20983 if (!SWIG_IsOK(ecode4)) {
20984 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
20985 }
20986 arg4 = static_cast< int >(val4);
20987 arg5 = obj4;
20988 {
20989 PyThreadState* __tstate = wxPyBeginAllowThreads();
20990 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
20991 wxPyEndAllowThreads(__tstate);
20992 if (PyErr_Occurred()) SWIG_fail;
20993 }
20994 resultobj = SWIG_Py_Void();
20995 return resultobj;
20996 fail:
20997 return NULL;
20998 }
20999
21000
21001 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21002 PyObject *resultobj = 0;
21003 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21004 int arg2 ;
21005 int arg3 = (int) -1 ;
21006 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
21007 bool result;
21008 void *argp1 = 0 ;
21009 int res1 = 0 ;
21010 int val2 ;
21011 int ecode2 = 0 ;
21012 int val3 ;
21013 int ecode3 = 0 ;
21014 int val4 ;
21015 int ecode4 = 0 ;
21016 PyObject * obj0 = 0 ;
21017 PyObject * obj1 = 0 ;
21018 PyObject * obj2 = 0 ;
21019 PyObject * obj3 = 0 ;
21020 char * kwnames[] = {
21021 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
21022 };
21023
21024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
21025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21026 if (!SWIG_IsOK(res1)) {
21027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21028 }
21029 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21030 ecode2 = SWIG_AsVal_int(obj1, &val2);
21031 if (!SWIG_IsOK(ecode2)) {
21032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
21033 }
21034 arg2 = static_cast< int >(val2);
21035 if (obj2) {
21036 ecode3 = SWIG_AsVal_int(obj2, &val3);
21037 if (!SWIG_IsOK(ecode3)) {
21038 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
21039 }
21040 arg3 = static_cast< int >(val3);
21041 }
21042 if (obj3) {
21043 ecode4 = SWIG_AsVal_int(obj3, &val4);
21044 if (!SWIG_IsOK(ecode4)) {
21045 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
21046 }
21047 arg4 = static_cast< wxEventType >(val4);
21048 }
21049 {
21050 PyThreadState* __tstate = wxPyBeginAllowThreads();
21051 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
21052 wxPyEndAllowThreads(__tstate);
21053 if (PyErr_Occurred()) SWIG_fail;
21054 }
21055 {
21056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21057 }
21058 return resultobj;
21059 fail:
21060 return NULL;
21061 }
21062
21063
21064 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21065 PyObject *resultobj = 0;
21066 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21067 PyObject *arg2 = (PyObject *) 0 ;
21068 bool arg3 = (bool) true ;
21069 void *argp1 = 0 ;
21070 int res1 = 0 ;
21071 bool val3 ;
21072 int ecode3 = 0 ;
21073 PyObject * obj0 = 0 ;
21074 PyObject * obj1 = 0 ;
21075 PyObject * obj2 = 0 ;
21076 char * kwnames[] = {
21077 (char *) "self",(char *) "_self",(char *) "incref", NULL
21078 };
21079
21080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21082 if (!SWIG_IsOK(res1)) {
21083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21084 }
21085 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21086 arg2 = obj1;
21087 if (obj2) {
21088 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21089 if (!SWIG_IsOK(ecode3)) {
21090 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
21091 }
21092 arg3 = static_cast< bool >(val3);
21093 }
21094 {
21095 PyThreadState* __tstate = wxPyBeginAllowThreads();
21096 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
21097 wxPyEndAllowThreads(__tstate);
21098 if (PyErr_Occurred()) SWIG_fail;
21099 }
21100 resultobj = SWIG_Py_Void();
21101 return resultobj;
21102 fail:
21103 return NULL;
21104 }
21105
21106
21107 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21108 PyObject *obj;
21109 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21110 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
21111 return SWIG_Py_Void();
21112 }
21113
21114 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21115 return SWIG_Python_InitShadowInstance(args);
21116 }
21117
21118 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21119 PyObject *resultobj = 0;
21120 wxEventType result;
21121
21122 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
21123 {
21124 PyThreadState* __tstate = wxPyBeginAllowThreads();
21125 result = (wxEventType)wxNewEventType();
21126 wxPyEndAllowThreads(__tstate);
21127 if (PyErr_Occurred()) SWIG_fail;
21128 }
21129 resultobj = SWIG_From_int(static_cast< int >(result));
21130 return resultobj;
21131 fail:
21132 return NULL;
21133 }
21134
21135
21136 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21137 PyObject *resultobj = 0;
21138 wxEvent *arg1 = (wxEvent *) 0 ;
21139 void *argp1 = 0 ;
21140 int res1 = 0 ;
21141 PyObject *swig_obj[1] ;
21142
21143 if (!args) SWIG_fail;
21144 swig_obj[0] = args;
21145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
21146 if (!SWIG_IsOK(res1)) {
21147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
21148 }
21149 arg1 = reinterpret_cast< wxEvent * >(argp1);
21150 {
21151 PyThreadState* __tstate = wxPyBeginAllowThreads();
21152 delete arg1;
21153
21154 wxPyEndAllowThreads(__tstate);
21155 if (PyErr_Occurred()) SWIG_fail;
21156 }
21157 resultobj = SWIG_Py_Void();
21158 return resultobj;
21159 fail:
21160 return NULL;
21161 }
21162
21163
21164 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21165 PyObject *resultobj = 0;
21166 wxEvent *arg1 = (wxEvent *) 0 ;
21167 wxEventType arg2 ;
21168 void *argp1 = 0 ;
21169 int res1 = 0 ;
21170 int val2 ;
21171 int ecode2 = 0 ;
21172 PyObject * obj0 = 0 ;
21173 PyObject * obj1 = 0 ;
21174 char * kwnames[] = {
21175 (char *) "self",(char *) "typ", NULL
21176 };
21177
21178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
21179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21180 if (!SWIG_IsOK(res1)) {
21181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
21182 }
21183 arg1 = reinterpret_cast< wxEvent * >(argp1);
21184 ecode2 = SWIG_AsVal_int(obj1, &val2);
21185 if (!SWIG_IsOK(ecode2)) {
21186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
21187 }
21188 arg2 = static_cast< wxEventType >(val2);
21189 {
21190 PyThreadState* __tstate = wxPyBeginAllowThreads();
21191 (arg1)->SetEventType(arg2);
21192 wxPyEndAllowThreads(__tstate);
21193 if (PyErr_Occurred()) SWIG_fail;
21194 }
21195 resultobj = SWIG_Py_Void();
21196 return resultobj;
21197 fail:
21198 return NULL;
21199 }
21200
21201
21202 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21203 PyObject *resultobj = 0;
21204 wxEvent *arg1 = (wxEvent *) 0 ;
21205 wxEventType result;
21206 void *argp1 = 0 ;
21207 int res1 = 0 ;
21208 PyObject *swig_obj[1] ;
21209
21210 if (!args) SWIG_fail;
21211 swig_obj[0] = args;
21212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21213 if (!SWIG_IsOK(res1)) {
21214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
21215 }
21216 arg1 = reinterpret_cast< wxEvent * >(argp1);
21217 {
21218 PyThreadState* __tstate = wxPyBeginAllowThreads();
21219 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
21220 wxPyEndAllowThreads(__tstate);
21221 if (PyErr_Occurred()) SWIG_fail;
21222 }
21223 resultobj = SWIG_From_int(static_cast< int >(result));
21224 return resultobj;
21225 fail:
21226 return NULL;
21227 }
21228
21229
21230 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21231 PyObject *resultobj = 0;
21232 wxEvent *arg1 = (wxEvent *) 0 ;
21233 wxObject *result = 0 ;
21234 void *argp1 = 0 ;
21235 int res1 = 0 ;
21236 PyObject *swig_obj[1] ;
21237
21238 if (!args) SWIG_fail;
21239 swig_obj[0] = args;
21240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21241 if (!SWIG_IsOK(res1)) {
21242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
21243 }
21244 arg1 = reinterpret_cast< wxEvent * >(argp1);
21245 {
21246 PyThreadState* __tstate = wxPyBeginAllowThreads();
21247 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
21248 wxPyEndAllowThreads(__tstate);
21249 if (PyErr_Occurred()) SWIG_fail;
21250 }
21251 {
21252 resultobj = wxPyMake_wxObject(result, (bool)0);
21253 }
21254 return resultobj;
21255 fail:
21256 return NULL;
21257 }
21258
21259
21260 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21261 PyObject *resultobj = 0;
21262 wxEvent *arg1 = (wxEvent *) 0 ;
21263 wxObject *arg2 = (wxObject *) 0 ;
21264 void *argp1 = 0 ;
21265 int res1 = 0 ;
21266 void *argp2 = 0 ;
21267 int res2 = 0 ;
21268 PyObject * obj0 = 0 ;
21269 PyObject * obj1 = 0 ;
21270 char * kwnames[] = {
21271 (char *) "self",(char *) "obj", NULL
21272 };
21273
21274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
21275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21276 if (!SWIG_IsOK(res1)) {
21277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
21278 }
21279 arg1 = reinterpret_cast< wxEvent * >(argp1);
21280 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
21281 if (!SWIG_IsOK(res2)) {
21282 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
21283 }
21284 arg2 = reinterpret_cast< wxObject * >(argp2);
21285 {
21286 PyThreadState* __tstate = wxPyBeginAllowThreads();
21287 (arg1)->SetEventObject(arg2);
21288 wxPyEndAllowThreads(__tstate);
21289 if (PyErr_Occurred()) SWIG_fail;
21290 }
21291 resultobj = SWIG_Py_Void();
21292 return resultobj;
21293 fail:
21294 return NULL;
21295 }
21296
21297
21298 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21299 PyObject *resultobj = 0;
21300 wxEvent *arg1 = (wxEvent *) 0 ;
21301 long result;
21302 void *argp1 = 0 ;
21303 int res1 = 0 ;
21304 PyObject *swig_obj[1] ;
21305
21306 if (!args) SWIG_fail;
21307 swig_obj[0] = args;
21308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21309 if (!SWIG_IsOK(res1)) {
21310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
21311 }
21312 arg1 = reinterpret_cast< wxEvent * >(argp1);
21313 {
21314 PyThreadState* __tstate = wxPyBeginAllowThreads();
21315 result = (long)((wxEvent const *)arg1)->GetTimestamp();
21316 wxPyEndAllowThreads(__tstate);
21317 if (PyErr_Occurred()) SWIG_fail;
21318 }
21319 resultobj = SWIG_From_long(static_cast< long >(result));
21320 return resultobj;
21321 fail:
21322 return NULL;
21323 }
21324
21325
21326 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21327 PyObject *resultobj = 0;
21328 wxEvent *arg1 = (wxEvent *) 0 ;
21329 long arg2 = (long) 0 ;
21330 void *argp1 = 0 ;
21331 int res1 = 0 ;
21332 long val2 ;
21333 int ecode2 = 0 ;
21334 PyObject * obj0 = 0 ;
21335 PyObject * obj1 = 0 ;
21336 char * kwnames[] = {
21337 (char *) "self",(char *) "ts", NULL
21338 };
21339
21340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
21341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21342 if (!SWIG_IsOK(res1)) {
21343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
21344 }
21345 arg1 = reinterpret_cast< wxEvent * >(argp1);
21346 if (obj1) {
21347 ecode2 = SWIG_AsVal_long(obj1, &val2);
21348 if (!SWIG_IsOK(ecode2)) {
21349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
21350 }
21351 arg2 = static_cast< long >(val2);
21352 }
21353 {
21354 PyThreadState* __tstate = wxPyBeginAllowThreads();
21355 (arg1)->SetTimestamp(arg2);
21356 wxPyEndAllowThreads(__tstate);
21357 if (PyErr_Occurred()) SWIG_fail;
21358 }
21359 resultobj = SWIG_Py_Void();
21360 return resultobj;
21361 fail:
21362 return NULL;
21363 }
21364
21365
21366 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21367 PyObject *resultobj = 0;
21368 wxEvent *arg1 = (wxEvent *) 0 ;
21369 int result;
21370 void *argp1 = 0 ;
21371 int res1 = 0 ;
21372 PyObject *swig_obj[1] ;
21373
21374 if (!args) SWIG_fail;
21375 swig_obj[0] = args;
21376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21377 if (!SWIG_IsOK(res1)) {
21378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
21379 }
21380 arg1 = reinterpret_cast< wxEvent * >(argp1);
21381 {
21382 PyThreadState* __tstate = wxPyBeginAllowThreads();
21383 result = (int)((wxEvent const *)arg1)->GetId();
21384 wxPyEndAllowThreads(__tstate);
21385 if (PyErr_Occurred()) SWIG_fail;
21386 }
21387 resultobj = SWIG_From_int(static_cast< int >(result));
21388 return resultobj;
21389 fail:
21390 return NULL;
21391 }
21392
21393
21394 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21395 PyObject *resultobj = 0;
21396 wxEvent *arg1 = (wxEvent *) 0 ;
21397 int arg2 ;
21398 void *argp1 = 0 ;
21399 int res1 = 0 ;
21400 int val2 ;
21401 int ecode2 = 0 ;
21402 PyObject * obj0 = 0 ;
21403 PyObject * obj1 = 0 ;
21404 char * kwnames[] = {
21405 (char *) "self",(char *) "Id", NULL
21406 };
21407
21408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
21409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21410 if (!SWIG_IsOK(res1)) {
21411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
21412 }
21413 arg1 = reinterpret_cast< wxEvent * >(argp1);
21414 ecode2 = SWIG_AsVal_int(obj1, &val2);
21415 if (!SWIG_IsOK(ecode2)) {
21416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
21417 }
21418 arg2 = static_cast< int >(val2);
21419 {
21420 PyThreadState* __tstate = wxPyBeginAllowThreads();
21421 (arg1)->SetId(arg2);
21422 wxPyEndAllowThreads(__tstate);
21423 if (PyErr_Occurred()) SWIG_fail;
21424 }
21425 resultobj = SWIG_Py_Void();
21426 return resultobj;
21427 fail:
21428 return NULL;
21429 }
21430
21431
21432 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21433 PyObject *resultobj = 0;
21434 wxEvent *arg1 = (wxEvent *) 0 ;
21435 bool result;
21436 void *argp1 = 0 ;
21437 int res1 = 0 ;
21438 PyObject *swig_obj[1] ;
21439
21440 if (!args) SWIG_fail;
21441 swig_obj[0] = args;
21442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21443 if (!SWIG_IsOK(res1)) {
21444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
21445 }
21446 arg1 = reinterpret_cast< wxEvent * >(argp1);
21447 {
21448 PyThreadState* __tstate = wxPyBeginAllowThreads();
21449 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
21450 wxPyEndAllowThreads(__tstate);
21451 if (PyErr_Occurred()) SWIG_fail;
21452 }
21453 {
21454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21455 }
21456 return resultobj;
21457 fail:
21458 return NULL;
21459 }
21460
21461
21462 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21463 PyObject *resultobj = 0;
21464 wxEvent *arg1 = (wxEvent *) 0 ;
21465 bool arg2 = (bool) true ;
21466 void *argp1 = 0 ;
21467 int res1 = 0 ;
21468 bool val2 ;
21469 int ecode2 = 0 ;
21470 PyObject * obj0 = 0 ;
21471 PyObject * obj1 = 0 ;
21472 char * kwnames[] = {
21473 (char *) "self",(char *) "skip", NULL
21474 };
21475
21476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
21477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21478 if (!SWIG_IsOK(res1)) {
21479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
21480 }
21481 arg1 = reinterpret_cast< wxEvent * >(argp1);
21482 if (obj1) {
21483 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21484 if (!SWIG_IsOK(ecode2)) {
21485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
21486 }
21487 arg2 = static_cast< bool >(val2);
21488 }
21489 {
21490 PyThreadState* __tstate = wxPyBeginAllowThreads();
21491 (arg1)->Skip(arg2);
21492 wxPyEndAllowThreads(__tstate);
21493 if (PyErr_Occurred()) SWIG_fail;
21494 }
21495 resultobj = SWIG_Py_Void();
21496 return resultobj;
21497 fail:
21498 return NULL;
21499 }
21500
21501
21502 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21503 PyObject *resultobj = 0;
21504 wxEvent *arg1 = (wxEvent *) 0 ;
21505 bool result;
21506 void *argp1 = 0 ;
21507 int res1 = 0 ;
21508 PyObject *swig_obj[1] ;
21509
21510 if (!args) SWIG_fail;
21511 swig_obj[0] = args;
21512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21513 if (!SWIG_IsOK(res1)) {
21514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
21515 }
21516 arg1 = reinterpret_cast< wxEvent * >(argp1);
21517 {
21518 PyThreadState* __tstate = wxPyBeginAllowThreads();
21519 result = (bool)((wxEvent const *)arg1)->GetSkipped();
21520 wxPyEndAllowThreads(__tstate);
21521 if (PyErr_Occurred()) SWIG_fail;
21522 }
21523 {
21524 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21525 }
21526 return resultobj;
21527 fail:
21528 return NULL;
21529 }
21530
21531
21532 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21533 PyObject *resultobj = 0;
21534 wxEvent *arg1 = (wxEvent *) 0 ;
21535 bool result;
21536 void *argp1 = 0 ;
21537 int res1 = 0 ;
21538 PyObject *swig_obj[1] ;
21539
21540 if (!args) SWIG_fail;
21541 swig_obj[0] = args;
21542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21543 if (!SWIG_IsOK(res1)) {
21544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
21545 }
21546 arg1 = reinterpret_cast< wxEvent * >(argp1);
21547 {
21548 PyThreadState* __tstate = wxPyBeginAllowThreads();
21549 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
21550 wxPyEndAllowThreads(__tstate);
21551 if (PyErr_Occurred()) SWIG_fail;
21552 }
21553 {
21554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21555 }
21556 return resultobj;
21557 fail:
21558 return NULL;
21559 }
21560
21561
21562 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21563 PyObject *resultobj = 0;
21564 wxEvent *arg1 = (wxEvent *) 0 ;
21565 int result;
21566 void *argp1 = 0 ;
21567 int res1 = 0 ;
21568 PyObject *swig_obj[1] ;
21569
21570 if (!args) SWIG_fail;
21571 swig_obj[0] = args;
21572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21573 if (!SWIG_IsOK(res1)) {
21574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21575 }
21576 arg1 = reinterpret_cast< wxEvent * >(argp1);
21577 {
21578 PyThreadState* __tstate = wxPyBeginAllowThreads();
21579 result = (int)(arg1)->StopPropagation();
21580 wxPyEndAllowThreads(__tstate);
21581 if (PyErr_Occurred()) SWIG_fail;
21582 }
21583 resultobj = SWIG_From_int(static_cast< int >(result));
21584 return resultobj;
21585 fail:
21586 return NULL;
21587 }
21588
21589
21590 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21591 PyObject *resultobj = 0;
21592 wxEvent *arg1 = (wxEvent *) 0 ;
21593 int arg2 ;
21594 void *argp1 = 0 ;
21595 int res1 = 0 ;
21596 int val2 ;
21597 int ecode2 = 0 ;
21598 PyObject * obj0 = 0 ;
21599 PyObject * obj1 = 0 ;
21600 char * kwnames[] = {
21601 (char *) "self",(char *) "propagationLevel", NULL
21602 };
21603
21604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
21605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21606 if (!SWIG_IsOK(res1)) {
21607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21608 }
21609 arg1 = reinterpret_cast< wxEvent * >(argp1);
21610 ecode2 = SWIG_AsVal_int(obj1, &val2);
21611 if (!SWIG_IsOK(ecode2)) {
21612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
21613 }
21614 arg2 = static_cast< int >(val2);
21615 {
21616 PyThreadState* __tstate = wxPyBeginAllowThreads();
21617 (arg1)->ResumePropagation(arg2);
21618 wxPyEndAllowThreads(__tstate);
21619 if (PyErr_Occurred()) SWIG_fail;
21620 }
21621 resultobj = SWIG_Py_Void();
21622 return resultobj;
21623 fail:
21624 return NULL;
21625 }
21626
21627
21628 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21629 PyObject *resultobj = 0;
21630 wxEvent *arg1 = (wxEvent *) 0 ;
21631 wxEvent *result = 0 ;
21632 void *argp1 = 0 ;
21633 int res1 = 0 ;
21634 PyObject *swig_obj[1] ;
21635
21636 if (!args) SWIG_fail;
21637 swig_obj[0] = args;
21638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21639 if (!SWIG_IsOK(res1)) {
21640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
21641 }
21642 arg1 = reinterpret_cast< wxEvent * >(argp1);
21643 {
21644 PyThreadState* __tstate = wxPyBeginAllowThreads();
21645 result = (wxEvent *)(arg1)->Clone();
21646 wxPyEndAllowThreads(__tstate);
21647 if (PyErr_Occurred()) SWIG_fail;
21648 }
21649 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
21650 return resultobj;
21651 fail:
21652 return NULL;
21653 }
21654
21655
21656 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21657 PyObject *obj;
21658 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21659 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
21660 return SWIG_Py_Void();
21661 }
21662
21663 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21664 PyObject *resultobj = 0;
21665 wxEvent *arg1 = 0 ;
21666 wxPropagationDisabler *result = 0 ;
21667 void *argp1 = 0 ;
21668 int res1 = 0 ;
21669 PyObject * obj0 = 0 ;
21670 char * kwnames[] = {
21671 (char *) "event", NULL
21672 };
21673
21674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
21675 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21676 if (!SWIG_IsOK(res1)) {
21677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21678 }
21679 if (!argp1) {
21680 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21681 }
21682 arg1 = reinterpret_cast< wxEvent * >(argp1);
21683 {
21684 PyThreadState* __tstate = wxPyBeginAllowThreads();
21685 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
21686 wxPyEndAllowThreads(__tstate);
21687 if (PyErr_Occurred()) SWIG_fail;
21688 }
21689 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
21690 return resultobj;
21691 fail:
21692 return NULL;
21693 }
21694
21695
21696 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21697 PyObject *resultobj = 0;
21698 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
21699 void *argp1 = 0 ;
21700 int res1 = 0 ;
21701 PyObject *swig_obj[1] ;
21702
21703 if (!args) SWIG_fail;
21704 swig_obj[0] = args;
21705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
21706 if (!SWIG_IsOK(res1)) {
21707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
21708 }
21709 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
21710 {
21711 PyThreadState* __tstate = wxPyBeginAllowThreads();
21712 delete arg1;
21713
21714 wxPyEndAllowThreads(__tstate);
21715 if (PyErr_Occurred()) SWIG_fail;
21716 }
21717 resultobj = SWIG_Py_Void();
21718 return resultobj;
21719 fail:
21720 return NULL;
21721 }
21722
21723
21724 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21725 PyObject *obj;
21726 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21727 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
21728 return SWIG_Py_Void();
21729 }
21730
21731 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21732 return SWIG_Python_InitShadowInstance(args);
21733 }
21734
21735 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21736 PyObject *resultobj = 0;
21737 wxEvent *arg1 = 0 ;
21738 wxPropagateOnce *result = 0 ;
21739 void *argp1 = 0 ;
21740 int res1 = 0 ;
21741 PyObject * obj0 = 0 ;
21742 char * kwnames[] = {
21743 (char *) "event", NULL
21744 };
21745
21746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
21747 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21748 if (!SWIG_IsOK(res1)) {
21749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21750 }
21751 if (!argp1) {
21752 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21753 }
21754 arg1 = reinterpret_cast< wxEvent * >(argp1);
21755 {
21756 PyThreadState* __tstate = wxPyBeginAllowThreads();
21757 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
21758 wxPyEndAllowThreads(__tstate);
21759 if (PyErr_Occurred()) SWIG_fail;
21760 }
21761 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
21762 return resultobj;
21763 fail:
21764 return NULL;
21765 }
21766
21767
21768 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21769 PyObject *resultobj = 0;
21770 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
21771 void *argp1 = 0 ;
21772 int res1 = 0 ;
21773 PyObject *swig_obj[1] ;
21774
21775 if (!args) SWIG_fail;
21776 swig_obj[0] = args;
21777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
21778 if (!SWIG_IsOK(res1)) {
21779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
21780 }
21781 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
21782 {
21783 PyThreadState* __tstate = wxPyBeginAllowThreads();
21784 delete arg1;
21785
21786 wxPyEndAllowThreads(__tstate);
21787 if (PyErr_Occurred()) SWIG_fail;
21788 }
21789 resultobj = SWIG_Py_Void();
21790 return resultobj;
21791 fail:
21792 return NULL;
21793 }
21794
21795
21796 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21797 PyObject *obj;
21798 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21799 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
21800 return SWIG_Py_Void();
21801 }
21802
21803 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21804 return SWIG_Python_InitShadowInstance(args);
21805 }
21806
21807 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21808 PyObject *resultobj = 0;
21809 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21810 int arg2 = (int) 0 ;
21811 wxCommandEvent *result = 0 ;
21812 int val1 ;
21813 int ecode1 = 0 ;
21814 int val2 ;
21815 int ecode2 = 0 ;
21816 PyObject * obj0 = 0 ;
21817 PyObject * obj1 = 0 ;
21818 char * kwnames[] = {
21819 (char *) "commandType",(char *) "winid", NULL
21820 };
21821
21822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21823 if (obj0) {
21824 ecode1 = SWIG_AsVal_int(obj0, &val1);
21825 if (!SWIG_IsOK(ecode1)) {
21826 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21827 }
21828 arg1 = static_cast< wxEventType >(val1);
21829 }
21830 if (obj1) {
21831 ecode2 = SWIG_AsVal_int(obj1, &val2);
21832 if (!SWIG_IsOK(ecode2)) {
21833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
21834 }
21835 arg2 = static_cast< int >(val2);
21836 }
21837 {
21838 PyThreadState* __tstate = wxPyBeginAllowThreads();
21839 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
21840 wxPyEndAllowThreads(__tstate);
21841 if (PyErr_Occurred()) SWIG_fail;
21842 }
21843 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
21844 return resultobj;
21845 fail:
21846 return NULL;
21847 }
21848
21849
21850 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21851 PyObject *resultobj = 0;
21852 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21853 int 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_wxCommandEvent, 0 | 0 );
21861 if (!SWIG_IsOK(res1)) {
21862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21863 }
21864 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21865 {
21866 PyThreadState* __tstate = wxPyBeginAllowThreads();
21867 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
21868 wxPyEndAllowThreads(__tstate);
21869 if (PyErr_Occurred()) SWIG_fail;
21870 }
21871 resultobj = SWIG_From_int(static_cast< int >(result));
21872 return resultobj;
21873 fail:
21874 return NULL;
21875 }
21876
21877
21878 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21879 PyObject *resultobj = 0;
21880 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21881 wxString *arg2 = 0 ;
21882 void *argp1 = 0 ;
21883 int res1 = 0 ;
21884 bool temp2 = false ;
21885 PyObject * obj0 = 0 ;
21886 PyObject * obj1 = 0 ;
21887 char * kwnames[] = {
21888 (char *) "self",(char *) "s", NULL
21889 };
21890
21891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
21892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21893 if (!SWIG_IsOK(res1)) {
21894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
21895 }
21896 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21897 {
21898 arg2 = wxString_in_helper(obj1);
21899 if (arg2 == NULL) SWIG_fail;
21900 temp2 = true;
21901 }
21902 {
21903 PyThreadState* __tstate = wxPyBeginAllowThreads();
21904 (arg1)->SetString((wxString const &)*arg2);
21905 wxPyEndAllowThreads(__tstate);
21906 if (PyErr_Occurred()) SWIG_fail;
21907 }
21908 resultobj = SWIG_Py_Void();
21909 {
21910 if (temp2)
21911 delete arg2;
21912 }
21913 return resultobj;
21914 fail:
21915 {
21916 if (temp2)
21917 delete arg2;
21918 }
21919 return NULL;
21920 }
21921
21922
21923 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21924 PyObject *resultobj = 0;
21925 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21926 wxString result;
21927 void *argp1 = 0 ;
21928 int res1 = 0 ;
21929 PyObject *swig_obj[1] ;
21930
21931 if (!args) SWIG_fail;
21932 swig_obj[0] = args;
21933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21934 if (!SWIG_IsOK(res1)) {
21935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21936 }
21937 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21938 {
21939 PyThreadState* __tstate = wxPyBeginAllowThreads();
21940 result = ((wxCommandEvent const *)arg1)->GetString();
21941 wxPyEndAllowThreads(__tstate);
21942 if (PyErr_Occurred()) SWIG_fail;
21943 }
21944 {
21945 #if wxUSE_UNICODE
21946 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21947 #else
21948 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21949 #endif
21950 }
21951 return resultobj;
21952 fail:
21953 return NULL;
21954 }
21955
21956
21957 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21958 PyObject *resultobj = 0;
21959 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21960 bool result;
21961 void *argp1 = 0 ;
21962 int res1 = 0 ;
21963 PyObject *swig_obj[1] ;
21964
21965 if (!args) SWIG_fail;
21966 swig_obj[0] = args;
21967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21968 if (!SWIG_IsOK(res1)) {
21969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21970 }
21971 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21972 {
21973 PyThreadState* __tstate = wxPyBeginAllowThreads();
21974 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
21975 wxPyEndAllowThreads(__tstate);
21976 if (PyErr_Occurred()) SWIG_fail;
21977 }
21978 {
21979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21980 }
21981 return resultobj;
21982 fail:
21983 return NULL;
21984 }
21985
21986
21987 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21988 PyObject *resultobj = 0;
21989 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21990 bool result;
21991 void *argp1 = 0 ;
21992 int res1 = 0 ;
21993 PyObject *swig_obj[1] ;
21994
21995 if (!args) SWIG_fail;
21996 swig_obj[0] = args;
21997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21998 if (!SWIG_IsOK(res1)) {
21999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22000 }
22001 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22002 {
22003 PyThreadState* __tstate = wxPyBeginAllowThreads();
22004 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
22005 wxPyEndAllowThreads(__tstate);
22006 if (PyErr_Occurred()) SWIG_fail;
22007 }
22008 {
22009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22010 }
22011 return resultobj;
22012 fail:
22013 return NULL;
22014 }
22015
22016
22017 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22018 PyObject *resultobj = 0;
22019 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22020 long arg2 ;
22021 void *argp1 = 0 ;
22022 int res1 = 0 ;
22023 long val2 ;
22024 int ecode2 = 0 ;
22025 PyObject * obj0 = 0 ;
22026 PyObject * obj1 = 0 ;
22027 char * kwnames[] = {
22028 (char *) "self",(char *) "extraLong", NULL
22029 };
22030
22031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
22032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22033 if (!SWIG_IsOK(res1)) {
22034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22035 }
22036 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22037 ecode2 = SWIG_AsVal_long(obj1, &val2);
22038 if (!SWIG_IsOK(ecode2)) {
22039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
22040 }
22041 arg2 = static_cast< long >(val2);
22042 {
22043 PyThreadState* __tstate = wxPyBeginAllowThreads();
22044 (arg1)->SetExtraLong(arg2);
22045 wxPyEndAllowThreads(__tstate);
22046 if (PyErr_Occurred()) SWIG_fail;
22047 }
22048 resultobj = SWIG_Py_Void();
22049 return resultobj;
22050 fail:
22051 return NULL;
22052 }
22053
22054
22055 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22056 PyObject *resultobj = 0;
22057 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22058 long result;
22059 void *argp1 = 0 ;
22060 int res1 = 0 ;
22061 PyObject *swig_obj[1] ;
22062
22063 if (!args) SWIG_fail;
22064 swig_obj[0] = args;
22065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22066 if (!SWIG_IsOK(res1)) {
22067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22068 }
22069 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22070 {
22071 PyThreadState* __tstate = wxPyBeginAllowThreads();
22072 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
22073 wxPyEndAllowThreads(__tstate);
22074 if (PyErr_Occurred()) SWIG_fail;
22075 }
22076 resultobj = SWIG_From_long(static_cast< long >(result));
22077 return resultobj;
22078 fail:
22079 return NULL;
22080 }
22081
22082
22083 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22084 PyObject *resultobj = 0;
22085 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22086 int arg2 ;
22087 void *argp1 = 0 ;
22088 int res1 = 0 ;
22089 int val2 ;
22090 int ecode2 = 0 ;
22091 PyObject * obj0 = 0 ;
22092 PyObject * obj1 = 0 ;
22093 char * kwnames[] = {
22094 (char *) "self",(char *) "i", NULL
22095 };
22096
22097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
22098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22099 if (!SWIG_IsOK(res1)) {
22100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22101 }
22102 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22103 ecode2 = SWIG_AsVal_int(obj1, &val2);
22104 if (!SWIG_IsOK(ecode2)) {
22105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
22106 }
22107 arg2 = static_cast< int >(val2);
22108 {
22109 PyThreadState* __tstate = wxPyBeginAllowThreads();
22110 (arg1)->SetInt(arg2);
22111 wxPyEndAllowThreads(__tstate);
22112 if (PyErr_Occurred()) SWIG_fail;
22113 }
22114 resultobj = SWIG_Py_Void();
22115 return resultobj;
22116 fail:
22117 return NULL;
22118 }
22119
22120
22121 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22122 PyObject *resultobj = 0;
22123 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22124 int result;
22125 void *argp1 = 0 ;
22126 int res1 = 0 ;
22127 PyObject *swig_obj[1] ;
22128
22129 if (!args) SWIG_fail;
22130 swig_obj[0] = args;
22131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22132 if (!SWIG_IsOK(res1)) {
22133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22134 }
22135 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22136 {
22137 PyThreadState* __tstate = wxPyBeginAllowThreads();
22138 result = (int)((wxCommandEvent const *)arg1)->GetInt();
22139 wxPyEndAllowThreads(__tstate);
22140 if (PyErr_Occurred()) SWIG_fail;
22141 }
22142 resultobj = SWIG_From_int(static_cast< int >(result));
22143 return resultobj;
22144 fail:
22145 return NULL;
22146 }
22147
22148
22149 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22150 PyObject *resultobj = 0;
22151 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22152 PyObject *result = 0 ;
22153 void *argp1 = 0 ;
22154 int res1 = 0 ;
22155 PyObject *swig_obj[1] ;
22156
22157 if (!args) SWIG_fail;
22158 swig_obj[0] = args;
22159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22160 if (!SWIG_IsOK(res1)) {
22161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22162 }
22163 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22164 {
22165 PyThreadState* __tstate = wxPyBeginAllowThreads();
22166 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
22167 wxPyEndAllowThreads(__tstate);
22168 if (PyErr_Occurred()) SWIG_fail;
22169 }
22170 resultobj = result;
22171 return resultobj;
22172 fail:
22173 return NULL;
22174 }
22175
22176
22177 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22178 PyObject *resultobj = 0;
22179 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22180 PyObject *arg2 = (PyObject *) 0 ;
22181 void *argp1 = 0 ;
22182 int res1 = 0 ;
22183 PyObject * obj0 = 0 ;
22184 PyObject * obj1 = 0 ;
22185 char * kwnames[] = {
22186 (char *) "self",(char *) "clientData", NULL
22187 };
22188
22189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
22190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22191 if (!SWIG_IsOK(res1)) {
22192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22193 }
22194 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22195 arg2 = obj1;
22196 {
22197 PyThreadState* __tstate = wxPyBeginAllowThreads();
22198 wxCommandEvent_SetClientData(arg1,arg2);
22199 wxPyEndAllowThreads(__tstate);
22200 if (PyErr_Occurred()) SWIG_fail;
22201 }
22202 resultobj = SWIG_Py_Void();
22203 return resultobj;
22204 fail:
22205 return NULL;
22206 }
22207
22208
22209 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22210 PyObject *resultobj = 0;
22211 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22212 wxEvent *result = 0 ;
22213 void *argp1 = 0 ;
22214 int res1 = 0 ;
22215 PyObject *swig_obj[1] ;
22216
22217 if (!args) SWIG_fail;
22218 swig_obj[0] = args;
22219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22220 if (!SWIG_IsOK(res1)) {
22221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22222 }
22223 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22224 {
22225 PyThreadState* __tstate = wxPyBeginAllowThreads();
22226 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
22227 wxPyEndAllowThreads(__tstate);
22228 if (PyErr_Occurred()) SWIG_fail;
22229 }
22230 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
22231 return resultobj;
22232 fail:
22233 return NULL;
22234 }
22235
22236
22237 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22238 PyObject *obj;
22239 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22240 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
22241 return SWIG_Py_Void();
22242 }
22243
22244 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22245 return SWIG_Python_InitShadowInstance(args);
22246 }
22247
22248 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22249 PyObject *resultobj = 0;
22250 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22251 int arg2 = (int) 0 ;
22252 wxNotifyEvent *result = 0 ;
22253 int val1 ;
22254 int ecode1 = 0 ;
22255 int val2 ;
22256 int ecode2 = 0 ;
22257 PyObject * obj0 = 0 ;
22258 PyObject * obj1 = 0 ;
22259 char * kwnames[] = {
22260 (char *) "commandType",(char *) "winid", NULL
22261 };
22262
22263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22264 if (obj0) {
22265 ecode1 = SWIG_AsVal_int(obj0, &val1);
22266 if (!SWIG_IsOK(ecode1)) {
22267 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22268 }
22269 arg1 = static_cast< wxEventType >(val1);
22270 }
22271 if (obj1) {
22272 ecode2 = SWIG_AsVal_int(obj1, &val2);
22273 if (!SWIG_IsOK(ecode2)) {
22274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
22275 }
22276 arg2 = static_cast< int >(val2);
22277 }
22278 {
22279 PyThreadState* __tstate = wxPyBeginAllowThreads();
22280 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
22281 wxPyEndAllowThreads(__tstate);
22282 if (PyErr_Occurred()) SWIG_fail;
22283 }
22284 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
22285 return resultobj;
22286 fail:
22287 return NULL;
22288 }
22289
22290
22291 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22292 PyObject *resultobj = 0;
22293 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22294 void *argp1 = 0 ;
22295 int res1 = 0 ;
22296 PyObject *swig_obj[1] ;
22297
22298 if (!args) SWIG_fail;
22299 swig_obj[0] = args;
22300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22301 if (!SWIG_IsOK(res1)) {
22302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22303 }
22304 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22305 {
22306 PyThreadState* __tstate = wxPyBeginAllowThreads();
22307 (arg1)->Veto();
22308 wxPyEndAllowThreads(__tstate);
22309 if (PyErr_Occurred()) SWIG_fail;
22310 }
22311 resultobj = SWIG_Py_Void();
22312 return resultobj;
22313 fail:
22314 return NULL;
22315 }
22316
22317
22318 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22319 PyObject *resultobj = 0;
22320 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22321 void *argp1 = 0 ;
22322 int res1 = 0 ;
22323 PyObject *swig_obj[1] ;
22324
22325 if (!args) SWIG_fail;
22326 swig_obj[0] = args;
22327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22328 if (!SWIG_IsOK(res1)) {
22329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22330 }
22331 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22332 {
22333 PyThreadState* __tstate = wxPyBeginAllowThreads();
22334 (arg1)->Allow();
22335 wxPyEndAllowThreads(__tstate);
22336 if (PyErr_Occurred()) SWIG_fail;
22337 }
22338 resultobj = SWIG_Py_Void();
22339 return resultobj;
22340 fail:
22341 return NULL;
22342 }
22343
22344
22345 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22346 PyObject *resultobj = 0;
22347 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22348 bool result;
22349 void *argp1 = 0 ;
22350 int res1 = 0 ;
22351 PyObject *swig_obj[1] ;
22352
22353 if (!args) SWIG_fail;
22354 swig_obj[0] = args;
22355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22356 if (!SWIG_IsOK(res1)) {
22357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22358 }
22359 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22360 {
22361 PyThreadState* __tstate = wxPyBeginAllowThreads();
22362 result = (bool)(arg1)->IsAllowed();
22363 wxPyEndAllowThreads(__tstate);
22364 if (PyErr_Occurred()) SWIG_fail;
22365 }
22366 {
22367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22368 }
22369 return resultobj;
22370 fail:
22371 return NULL;
22372 }
22373
22374
22375 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22376 PyObject *obj;
22377 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22378 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
22379 return SWIG_Py_Void();
22380 }
22381
22382 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22383 return SWIG_Python_InitShadowInstance(args);
22384 }
22385
22386 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22387 PyObject *resultobj = 0;
22388 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22389 int arg2 = (int) 0 ;
22390 int arg3 = (int) 0 ;
22391 int arg4 = (int) 0 ;
22392 wxScrollEvent *result = 0 ;
22393 int val1 ;
22394 int ecode1 = 0 ;
22395 int val2 ;
22396 int ecode2 = 0 ;
22397 int val3 ;
22398 int ecode3 = 0 ;
22399 int val4 ;
22400 int ecode4 = 0 ;
22401 PyObject * obj0 = 0 ;
22402 PyObject * obj1 = 0 ;
22403 PyObject * obj2 = 0 ;
22404 PyObject * obj3 = 0 ;
22405 char * kwnames[] = {
22406 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
22407 };
22408
22409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22410 if (obj0) {
22411 ecode1 = SWIG_AsVal_int(obj0, &val1);
22412 if (!SWIG_IsOK(ecode1)) {
22413 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22414 }
22415 arg1 = static_cast< wxEventType >(val1);
22416 }
22417 if (obj1) {
22418 ecode2 = SWIG_AsVal_int(obj1, &val2);
22419 if (!SWIG_IsOK(ecode2)) {
22420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
22421 }
22422 arg2 = static_cast< int >(val2);
22423 }
22424 if (obj2) {
22425 ecode3 = SWIG_AsVal_int(obj2, &val3);
22426 if (!SWIG_IsOK(ecode3)) {
22427 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
22428 }
22429 arg3 = static_cast< int >(val3);
22430 }
22431 if (obj3) {
22432 ecode4 = SWIG_AsVal_int(obj3, &val4);
22433 if (!SWIG_IsOK(ecode4)) {
22434 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
22435 }
22436 arg4 = static_cast< int >(val4);
22437 }
22438 {
22439 PyThreadState* __tstate = wxPyBeginAllowThreads();
22440 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
22441 wxPyEndAllowThreads(__tstate);
22442 if (PyErr_Occurred()) SWIG_fail;
22443 }
22444 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
22445 return resultobj;
22446 fail:
22447 return NULL;
22448 }
22449
22450
22451 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22452 PyObject *resultobj = 0;
22453 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22454 int result;
22455 void *argp1 = 0 ;
22456 int res1 = 0 ;
22457 PyObject *swig_obj[1] ;
22458
22459 if (!args) SWIG_fail;
22460 swig_obj[0] = args;
22461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22462 if (!SWIG_IsOK(res1)) {
22463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22464 }
22465 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22466 {
22467 PyThreadState* __tstate = wxPyBeginAllowThreads();
22468 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
22469 wxPyEndAllowThreads(__tstate);
22470 if (PyErr_Occurred()) SWIG_fail;
22471 }
22472 resultobj = SWIG_From_int(static_cast< int >(result));
22473 return resultobj;
22474 fail:
22475 return NULL;
22476 }
22477
22478
22479 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22480 PyObject *resultobj = 0;
22481 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22482 int result;
22483 void *argp1 = 0 ;
22484 int res1 = 0 ;
22485 PyObject *swig_obj[1] ;
22486
22487 if (!args) SWIG_fail;
22488 swig_obj[0] = args;
22489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22490 if (!SWIG_IsOK(res1)) {
22491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22492 }
22493 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22494 {
22495 PyThreadState* __tstate = wxPyBeginAllowThreads();
22496 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
22497 wxPyEndAllowThreads(__tstate);
22498 if (PyErr_Occurred()) SWIG_fail;
22499 }
22500 resultobj = SWIG_From_int(static_cast< int >(result));
22501 return resultobj;
22502 fail:
22503 return NULL;
22504 }
22505
22506
22507 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22508 PyObject *resultobj = 0;
22509 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22510 int arg2 ;
22511 void *argp1 = 0 ;
22512 int res1 = 0 ;
22513 int val2 ;
22514 int ecode2 = 0 ;
22515 PyObject * obj0 = 0 ;
22516 PyObject * obj1 = 0 ;
22517 char * kwnames[] = {
22518 (char *) "self",(char *) "orient", NULL
22519 };
22520
22521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22523 if (!SWIG_IsOK(res1)) {
22524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22525 }
22526 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22527 ecode2 = SWIG_AsVal_int(obj1, &val2);
22528 if (!SWIG_IsOK(ecode2)) {
22529 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22530 }
22531 arg2 = static_cast< int >(val2);
22532 {
22533 PyThreadState* __tstate = wxPyBeginAllowThreads();
22534 (arg1)->SetOrientation(arg2);
22535 wxPyEndAllowThreads(__tstate);
22536 if (PyErr_Occurred()) SWIG_fail;
22537 }
22538 resultobj = SWIG_Py_Void();
22539 return resultobj;
22540 fail:
22541 return NULL;
22542 }
22543
22544
22545 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22546 PyObject *resultobj = 0;
22547 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22548 int arg2 ;
22549 void *argp1 = 0 ;
22550 int res1 = 0 ;
22551 int val2 ;
22552 int ecode2 = 0 ;
22553 PyObject * obj0 = 0 ;
22554 PyObject * obj1 = 0 ;
22555 char * kwnames[] = {
22556 (char *) "self",(char *) "pos", NULL
22557 };
22558
22559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22561 if (!SWIG_IsOK(res1)) {
22562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22563 }
22564 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22565 ecode2 = SWIG_AsVal_int(obj1, &val2);
22566 if (!SWIG_IsOK(ecode2)) {
22567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22568 }
22569 arg2 = static_cast< int >(val2);
22570 {
22571 PyThreadState* __tstate = wxPyBeginAllowThreads();
22572 (arg1)->SetPosition(arg2);
22573 wxPyEndAllowThreads(__tstate);
22574 if (PyErr_Occurred()) SWIG_fail;
22575 }
22576 resultobj = SWIG_Py_Void();
22577 return resultobj;
22578 fail:
22579 return NULL;
22580 }
22581
22582
22583 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22584 PyObject *obj;
22585 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22586 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
22587 return SWIG_Py_Void();
22588 }
22589
22590 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22591 return SWIG_Python_InitShadowInstance(args);
22592 }
22593
22594 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22595 PyObject *resultobj = 0;
22596 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22597 int arg2 = (int) 0 ;
22598 int arg3 = (int) 0 ;
22599 wxScrollWinEvent *result = 0 ;
22600 int val1 ;
22601 int ecode1 = 0 ;
22602 int val2 ;
22603 int ecode2 = 0 ;
22604 int val3 ;
22605 int ecode3 = 0 ;
22606 PyObject * obj0 = 0 ;
22607 PyObject * obj1 = 0 ;
22608 PyObject * obj2 = 0 ;
22609 char * kwnames[] = {
22610 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
22611 };
22612
22613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22614 if (obj0) {
22615 ecode1 = SWIG_AsVal_int(obj0, &val1);
22616 if (!SWIG_IsOK(ecode1)) {
22617 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22618 }
22619 arg1 = static_cast< wxEventType >(val1);
22620 }
22621 if (obj1) {
22622 ecode2 = SWIG_AsVal_int(obj1, &val2);
22623 if (!SWIG_IsOK(ecode2)) {
22624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
22625 }
22626 arg2 = static_cast< int >(val2);
22627 }
22628 if (obj2) {
22629 ecode3 = SWIG_AsVal_int(obj2, &val3);
22630 if (!SWIG_IsOK(ecode3)) {
22631 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
22632 }
22633 arg3 = static_cast< int >(val3);
22634 }
22635 {
22636 PyThreadState* __tstate = wxPyBeginAllowThreads();
22637 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
22638 wxPyEndAllowThreads(__tstate);
22639 if (PyErr_Occurred()) SWIG_fail;
22640 }
22641 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
22642 return resultobj;
22643 fail:
22644 return NULL;
22645 }
22646
22647
22648 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22649 PyObject *resultobj = 0;
22650 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22651 int result;
22652 void *argp1 = 0 ;
22653 int res1 = 0 ;
22654 PyObject *swig_obj[1] ;
22655
22656 if (!args) SWIG_fail;
22657 swig_obj[0] = args;
22658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22659 if (!SWIG_IsOK(res1)) {
22660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22661 }
22662 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22663 {
22664 PyThreadState* __tstate = wxPyBeginAllowThreads();
22665 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
22666 wxPyEndAllowThreads(__tstate);
22667 if (PyErr_Occurred()) SWIG_fail;
22668 }
22669 resultobj = SWIG_From_int(static_cast< int >(result));
22670 return resultobj;
22671 fail:
22672 return NULL;
22673 }
22674
22675
22676 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22677 PyObject *resultobj = 0;
22678 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22679 int result;
22680 void *argp1 = 0 ;
22681 int res1 = 0 ;
22682 PyObject *swig_obj[1] ;
22683
22684 if (!args) SWIG_fail;
22685 swig_obj[0] = args;
22686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22687 if (!SWIG_IsOK(res1)) {
22688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22689 }
22690 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22691 {
22692 PyThreadState* __tstate = wxPyBeginAllowThreads();
22693 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
22694 wxPyEndAllowThreads(__tstate);
22695 if (PyErr_Occurred()) SWIG_fail;
22696 }
22697 resultobj = SWIG_From_int(static_cast< int >(result));
22698 return resultobj;
22699 fail:
22700 return NULL;
22701 }
22702
22703
22704 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22705 PyObject *resultobj = 0;
22706 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22707 int arg2 ;
22708 void *argp1 = 0 ;
22709 int res1 = 0 ;
22710 int val2 ;
22711 int ecode2 = 0 ;
22712 PyObject * obj0 = 0 ;
22713 PyObject * obj1 = 0 ;
22714 char * kwnames[] = {
22715 (char *) "self",(char *) "orient", NULL
22716 };
22717
22718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22720 if (!SWIG_IsOK(res1)) {
22721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22722 }
22723 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22724 ecode2 = SWIG_AsVal_int(obj1, &val2);
22725 if (!SWIG_IsOK(ecode2)) {
22726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22727 }
22728 arg2 = static_cast< int >(val2);
22729 {
22730 PyThreadState* __tstate = wxPyBeginAllowThreads();
22731 (arg1)->SetOrientation(arg2);
22732 wxPyEndAllowThreads(__tstate);
22733 if (PyErr_Occurred()) SWIG_fail;
22734 }
22735 resultobj = SWIG_Py_Void();
22736 return resultobj;
22737 fail:
22738 return NULL;
22739 }
22740
22741
22742 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22743 PyObject *resultobj = 0;
22744 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22745 int arg2 ;
22746 void *argp1 = 0 ;
22747 int res1 = 0 ;
22748 int val2 ;
22749 int ecode2 = 0 ;
22750 PyObject * obj0 = 0 ;
22751 PyObject * obj1 = 0 ;
22752 char * kwnames[] = {
22753 (char *) "self",(char *) "pos", NULL
22754 };
22755
22756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22758 if (!SWIG_IsOK(res1)) {
22759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22760 }
22761 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22762 ecode2 = SWIG_AsVal_int(obj1, &val2);
22763 if (!SWIG_IsOK(ecode2)) {
22764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22765 }
22766 arg2 = static_cast< int >(val2);
22767 {
22768 PyThreadState* __tstate = wxPyBeginAllowThreads();
22769 (arg1)->SetPosition(arg2);
22770 wxPyEndAllowThreads(__tstate);
22771 if (PyErr_Occurred()) SWIG_fail;
22772 }
22773 resultobj = SWIG_Py_Void();
22774 return resultobj;
22775 fail:
22776 return NULL;
22777 }
22778
22779
22780 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22781 PyObject *obj;
22782 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22783 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
22784 return SWIG_Py_Void();
22785 }
22786
22787 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22788 return SWIG_Python_InitShadowInstance(args);
22789 }
22790
22791 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22792 PyObject *resultobj = 0;
22793 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22794 wxMouseEvent *result = 0 ;
22795 int val1 ;
22796 int ecode1 = 0 ;
22797 PyObject * obj0 = 0 ;
22798 char * kwnames[] = {
22799 (char *) "mouseType", NULL
22800 };
22801
22802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
22803 if (obj0) {
22804 ecode1 = SWIG_AsVal_int(obj0, &val1);
22805 if (!SWIG_IsOK(ecode1)) {
22806 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22807 }
22808 arg1 = static_cast< wxEventType >(val1);
22809 }
22810 {
22811 PyThreadState* __tstate = wxPyBeginAllowThreads();
22812 result = (wxMouseEvent *)new wxMouseEvent(arg1);
22813 wxPyEndAllowThreads(__tstate);
22814 if (PyErr_Occurred()) SWIG_fail;
22815 }
22816 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_NEW | 0 );
22817 return resultobj;
22818 fail:
22819 return NULL;
22820 }
22821
22822
22823 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22824 PyObject *resultobj = 0;
22825 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22826 bool result;
22827 void *argp1 = 0 ;
22828 int res1 = 0 ;
22829 PyObject *swig_obj[1] ;
22830
22831 if (!args) SWIG_fail;
22832 swig_obj[0] = args;
22833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22834 if (!SWIG_IsOK(res1)) {
22835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22836 }
22837 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22838 {
22839 PyThreadState* __tstate = wxPyBeginAllowThreads();
22840 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
22841 wxPyEndAllowThreads(__tstate);
22842 if (PyErr_Occurred()) SWIG_fail;
22843 }
22844 {
22845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22846 }
22847 return resultobj;
22848 fail:
22849 return NULL;
22850 }
22851
22852
22853 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22854 PyObject *resultobj = 0;
22855 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22856 int arg2 = (int) wxMOUSE_BTN_ANY ;
22857 bool result;
22858 void *argp1 = 0 ;
22859 int res1 = 0 ;
22860 int val2 ;
22861 int ecode2 = 0 ;
22862 PyObject * obj0 = 0 ;
22863 PyObject * obj1 = 0 ;
22864 char * kwnames[] = {
22865 (char *) "self",(char *) "but", NULL
22866 };
22867
22868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
22869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22870 if (!SWIG_IsOK(res1)) {
22871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22872 }
22873 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22874 if (obj1) {
22875 ecode2 = SWIG_AsVal_int(obj1, &val2);
22876 if (!SWIG_IsOK(ecode2)) {
22877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
22878 }
22879 arg2 = static_cast< int >(val2);
22880 }
22881 {
22882 PyThreadState* __tstate = wxPyBeginAllowThreads();
22883 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
22884 wxPyEndAllowThreads(__tstate);
22885 if (PyErr_Occurred()) SWIG_fail;
22886 }
22887 {
22888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22889 }
22890 return resultobj;
22891 fail:
22892 return NULL;
22893 }
22894
22895
22896 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22897 PyObject *resultobj = 0;
22898 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22899 int arg2 = (int) wxMOUSE_BTN_ANY ;
22900 bool result;
22901 void *argp1 = 0 ;
22902 int res1 = 0 ;
22903 int val2 ;
22904 int ecode2 = 0 ;
22905 PyObject * obj0 = 0 ;
22906 PyObject * obj1 = 0 ;
22907 char * kwnames[] = {
22908 (char *) "self",(char *) "but", NULL
22909 };
22910
22911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
22912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22913 if (!SWIG_IsOK(res1)) {
22914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22915 }
22916 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22917 if (obj1) {
22918 ecode2 = SWIG_AsVal_int(obj1, &val2);
22919 if (!SWIG_IsOK(ecode2)) {
22920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
22921 }
22922 arg2 = static_cast< int >(val2);
22923 }
22924 {
22925 PyThreadState* __tstate = wxPyBeginAllowThreads();
22926 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
22927 wxPyEndAllowThreads(__tstate);
22928 if (PyErr_Occurred()) SWIG_fail;
22929 }
22930 {
22931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22932 }
22933 return resultobj;
22934 fail:
22935 return NULL;
22936 }
22937
22938
22939 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22940 PyObject *resultobj = 0;
22941 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22942 int arg2 = (int) wxMOUSE_BTN_ANY ;
22943 bool result;
22944 void *argp1 = 0 ;
22945 int res1 = 0 ;
22946 int val2 ;
22947 int ecode2 = 0 ;
22948 PyObject * obj0 = 0 ;
22949 PyObject * obj1 = 0 ;
22950 char * kwnames[] = {
22951 (char *) "self",(char *) "but", NULL
22952 };
22953
22954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
22955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22956 if (!SWIG_IsOK(res1)) {
22957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22958 }
22959 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22960 if (obj1) {
22961 ecode2 = SWIG_AsVal_int(obj1, &val2);
22962 if (!SWIG_IsOK(ecode2)) {
22963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
22964 }
22965 arg2 = static_cast< int >(val2);
22966 }
22967 {
22968 PyThreadState* __tstate = wxPyBeginAllowThreads();
22969 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
22970 wxPyEndAllowThreads(__tstate);
22971 if (PyErr_Occurred()) SWIG_fail;
22972 }
22973 {
22974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22975 }
22976 return resultobj;
22977 fail:
22978 return NULL;
22979 }
22980
22981
22982 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22983 PyObject *resultobj = 0;
22984 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22985 int arg2 ;
22986 bool result;
22987 void *argp1 = 0 ;
22988 int res1 = 0 ;
22989 int val2 ;
22990 int ecode2 = 0 ;
22991 PyObject * obj0 = 0 ;
22992 PyObject * obj1 = 0 ;
22993 char * kwnames[] = {
22994 (char *) "self",(char *) "button", NULL
22995 };
22996
22997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
22998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22999 if (!SWIG_IsOK(res1)) {
23000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23001 }
23002 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23003 ecode2 = SWIG_AsVal_int(obj1, &val2);
23004 if (!SWIG_IsOK(ecode2)) {
23005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
23006 }
23007 arg2 = static_cast< int >(val2);
23008 {
23009 PyThreadState* __tstate = wxPyBeginAllowThreads();
23010 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
23011 wxPyEndAllowThreads(__tstate);
23012 if (PyErr_Occurred()) SWIG_fail;
23013 }
23014 {
23015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23016 }
23017 return resultobj;
23018 fail:
23019 return NULL;
23020 }
23021
23022
23023 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23024 PyObject *resultobj = 0;
23025 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23026 int arg2 ;
23027 bool result;
23028 void *argp1 = 0 ;
23029 int res1 = 0 ;
23030 int val2 ;
23031 int ecode2 = 0 ;
23032 PyObject * obj0 = 0 ;
23033 PyObject * obj1 = 0 ;
23034 char * kwnames[] = {
23035 (char *) "self",(char *) "but", NULL
23036 };
23037
23038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
23039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23040 if (!SWIG_IsOK(res1)) {
23041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23042 }
23043 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23044 ecode2 = SWIG_AsVal_int(obj1, &val2);
23045 if (!SWIG_IsOK(ecode2)) {
23046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
23047 }
23048 arg2 = static_cast< int >(val2);
23049 {
23050 PyThreadState* __tstate = wxPyBeginAllowThreads();
23051 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
23052 wxPyEndAllowThreads(__tstate);
23053 if (PyErr_Occurred()) SWIG_fail;
23054 }
23055 {
23056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23057 }
23058 return resultobj;
23059 fail:
23060 return NULL;
23061 }
23062
23063
23064 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23065 PyObject *resultobj = 0;
23066 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23067 int result;
23068 void *argp1 = 0 ;
23069 int res1 = 0 ;
23070 PyObject *swig_obj[1] ;
23071
23072 if (!args) SWIG_fail;
23073 swig_obj[0] = args;
23074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23075 if (!SWIG_IsOK(res1)) {
23076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23077 }
23078 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23079 {
23080 PyThreadState* __tstate = wxPyBeginAllowThreads();
23081 result = (int)((wxMouseEvent const *)arg1)->GetButton();
23082 wxPyEndAllowThreads(__tstate);
23083 if (PyErr_Occurred()) SWIG_fail;
23084 }
23085 resultobj = SWIG_From_int(static_cast< int >(result));
23086 return resultobj;
23087 fail:
23088 return NULL;
23089 }
23090
23091
23092 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23093 PyObject *resultobj = 0;
23094 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23095 bool result;
23096 void *argp1 = 0 ;
23097 int res1 = 0 ;
23098 PyObject *swig_obj[1] ;
23099
23100 if (!args) SWIG_fail;
23101 swig_obj[0] = args;
23102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23103 if (!SWIG_IsOK(res1)) {
23104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23105 }
23106 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23107 {
23108 PyThreadState* __tstate = wxPyBeginAllowThreads();
23109 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
23110 wxPyEndAllowThreads(__tstate);
23111 if (PyErr_Occurred()) SWIG_fail;
23112 }
23113 {
23114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23115 }
23116 return resultobj;
23117 fail:
23118 return NULL;
23119 }
23120
23121
23122 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23123 PyObject *resultobj = 0;
23124 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23125 bool result;
23126 void *argp1 = 0 ;
23127 int res1 = 0 ;
23128 PyObject *swig_obj[1] ;
23129
23130 if (!args) SWIG_fail;
23131 swig_obj[0] = args;
23132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23133 if (!SWIG_IsOK(res1)) {
23134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23135 }
23136 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23137 {
23138 PyThreadState* __tstate = wxPyBeginAllowThreads();
23139 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
23140 wxPyEndAllowThreads(__tstate);
23141 if (PyErr_Occurred()) SWIG_fail;
23142 }
23143 {
23144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23145 }
23146 return resultobj;
23147 fail:
23148 return NULL;
23149 }
23150
23151
23152 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23153 PyObject *resultobj = 0;
23154 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23155 bool result;
23156 void *argp1 = 0 ;
23157 int res1 = 0 ;
23158 PyObject *swig_obj[1] ;
23159
23160 if (!args) SWIG_fail;
23161 swig_obj[0] = args;
23162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23163 if (!SWIG_IsOK(res1)) {
23164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23165 }
23166 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23167 {
23168 PyThreadState* __tstate = wxPyBeginAllowThreads();
23169 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
23170 wxPyEndAllowThreads(__tstate);
23171 if (PyErr_Occurred()) SWIG_fail;
23172 }
23173 {
23174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23175 }
23176 return resultobj;
23177 fail:
23178 return NULL;
23179 }
23180
23181
23182 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23183 PyObject *resultobj = 0;
23184 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23185 bool result;
23186 void *argp1 = 0 ;
23187 int res1 = 0 ;
23188 PyObject *swig_obj[1] ;
23189
23190 if (!args) SWIG_fail;
23191 swig_obj[0] = args;
23192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23193 if (!SWIG_IsOK(res1)) {
23194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23195 }
23196 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23197 {
23198 PyThreadState* __tstate = wxPyBeginAllowThreads();
23199 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
23200 wxPyEndAllowThreads(__tstate);
23201 if (PyErr_Occurred()) SWIG_fail;
23202 }
23203 {
23204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23205 }
23206 return resultobj;
23207 fail:
23208 return NULL;
23209 }
23210
23211
23212 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23213 PyObject *resultobj = 0;
23214 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23215 bool result;
23216 void *argp1 = 0 ;
23217 int res1 = 0 ;
23218 PyObject *swig_obj[1] ;
23219
23220 if (!args) SWIG_fail;
23221 swig_obj[0] = args;
23222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23223 if (!SWIG_IsOK(res1)) {
23224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23225 }
23226 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23227 {
23228 PyThreadState* __tstate = wxPyBeginAllowThreads();
23229 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
23230 wxPyEndAllowThreads(__tstate);
23231 if (PyErr_Occurred()) SWIG_fail;
23232 }
23233 {
23234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23235 }
23236 return resultobj;
23237 fail:
23238 return NULL;
23239 }
23240
23241
23242 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23243 PyObject *resultobj = 0;
23244 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23245 bool result;
23246 void *argp1 = 0 ;
23247 int res1 = 0 ;
23248 PyObject *swig_obj[1] ;
23249
23250 if (!args) SWIG_fail;
23251 swig_obj[0] = args;
23252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23253 if (!SWIG_IsOK(res1)) {
23254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23255 }
23256 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23257 {
23258 PyThreadState* __tstate = wxPyBeginAllowThreads();
23259 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
23260 wxPyEndAllowThreads(__tstate);
23261 if (PyErr_Occurred()) SWIG_fail;
23262 }
23263 {
23264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23265 }
23266 return resultobj;
23267 fail:
23268 return NULL;
23269 }
23270
23271
23272 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23273 PyObject *resultobj = 0;
23274 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23275 bool result;
23276 void *argp1 = 0 ;
23277 int res1 = 0 ;
23278 PyObject *swig_obj[1] ;
23279
23280 if (!args) SWIG_fail;
23281 swig_obj[0] = args;
23282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23283 if (!SWIG_IsOK(res1)) {
23284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23285 }
23286 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23287 {
23288 PyThreadState* __tstate = wxPyBeginAllowThreads();
23289 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
23290 wxPyEndAllowThreads(__tstate);
23291 if (PyErr_Occurred()) SWIG_fail;
23292 }
23293 {
23294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23295 }
23296 return resultobj;
23297 fail:
23298 return NULL;
23299 }
23300
23301
23302 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23303 PyObject *resultobj = 0;
23304 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23305 bool result;
23306 void *argp1 = 0 ;
23307 int res1 = 0 ;
23308 PyObject *swig_obj[1] ;
23309
23310 if (!args) SWIG_fail;
23311 swig_obj[0] = args;
23312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23313 if (!SWIG_IsOK(res1)) {
23314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23315 }
23316 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23317 {
23318 PyThreadState* __tstate = wxPyBeginAllowThreads();
23319 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
23320 wxPyEndAllowThreads(__tstate);
23321 if (PyErr_Occurred()) SWIG_fail;
23322 }
23323 {
23324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23325 }
23326 return resultobj;
23327 fail:
23328 return NULL;
23329 }
23330
23331
23332 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23333 PyObject *resultobj = 0;
23334 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23335 bool result;
23336 void *argp1 = 0 ;
23337 int res1 = 0 ;
23338 PyObject *swig_obj[1] ;
23339
23340 if (!args) SWIG_fail;
23341 swig_obj[0] = args;
23342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23343 if (!SWIG_IsOK(res1)) {
23344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23345 }
23346 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23347 {
23348 PyThreadState* __tstate = wxPyBeginAllowThreads();
23349 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
23350 wxPyEndAllowThreads(__tstate);
23351 if (PyErr_Occurred()) SWIG_fail;
23352 }
23353 {
23354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23355 }
23356 return resultobj;
23357 fail:
23358 return NULL;
23359 }
23360
23361
23362 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23363 PyObject *resultobj = 0;
23364 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23365 bool result;
23366 void *argp1 = 0 ;
23367 int res1 = 0 ;
23368 PyObject *swig_obj[1] ;
23369
23370 if (!args) SWIG_fail;
23371 swig_obj[0] = args;
23372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23373 if (!SWIG_IsOK(res1)) {
23374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23375 }
23376 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23377 {
23378 PyThreadState* __tstate = wxPyBeginAllowThreads();
23379 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
23380 wxPyEndAllowThreads(__tstate);
23381 if (PyErr_Occurred()) SWIG_fail;
23382 }
23383 {
23384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23385 }
23386 return resultobj;
23387 fail:
23388 return NULL;
23389 }
23390
23391
23392 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23393 PyObject *resultobj = 0;
23394 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23395 bool result;
23396 void *argp1 = 0 ;
23397 int res1 = 0 ;
23398 PyObject *swig_obj[1] ;
23399
23400 if (!args) SWIG_fail;
23401 swig_obj[0] = args;
23402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23403 if (!SWIG_IsOK(res1)) {
23404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23405 }
23406 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23407 {
23408 PyThreadState* __tstate = wxPyBeginAllowThreads();
23409 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
23410 wxPyEndAllowThreads(__tstate);
23411 if (PyErr_Occurred()) SWIG_fail;
23412 }
23413 {
23414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23415 }
23416 return resultobj;
23417 fail:
23418 return NULL;
23419 }
23420
23421
23422 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23423 PyObject *resultobj = 0;
23424 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23425 bool result;
23426 void *argp1 = 0 ;
23427 int res1 = 0 ;
23428 PyObject *swig_obj[1] ;
23429
23430 if (!args) SWIG_fail;
23431 swig_obj[0] = args;
23432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23433 if (!SWIG_IsOK(res1)) {
23434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23435 }
23436 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23437 {
23438 PyThreadState* __tstate = wxPyBeginAllowThreads();
23439 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
23440 wxPyEndAllowThreads(__tstate);
23441 if (PyErr_Occurred()) SWIG_fail;
23442 }
23443 {
23444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23445 }
23446 return resultobj;
23447 fail:
23448 return NULL;
23449 }
23450
23451
23452 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23453 PyObject *resultobj = 0;
23454 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23455 bool result;
23456 void *argp1 = 0 ;
23457 int res1 = 0 ;
23458 PyObject *swig_obj[1] ;
23459
23460 if (!args) SWIG_fail;
23461 swig_obj[0] = args;
23462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23463 if (!SWIG_IsOK(res1)) {
23464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23465 }
23466 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23467 {
23468 PyThreadState* __tstate = wxPyBeginAllowThreads();
23469 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
23470 wxPyEndAllowThreads(__tstate);
23471 if (PyErr_Occurred()) SWIG_fail;
23472 }
23473 {
23474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23475 }
23476 return resultobj;
23477 fail:
23478 return NULL;
23479 }
23480
23481
23482 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23483 PyObject *resultobj = 0;
23484 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23485 bool result;
23486 void *argp1 = 0 ;
23487 int res1 = 0 ;
23488 PyObject *swig_obj[1] ;
23489
23490 if (!args) SWIG_fail;
23491 swig_obj[0] = args;
23492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23493 if (!SWIG_IsOK(res1)) {
23494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23495 }
23496 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23497 {
23498 PyThreadState* __tstate = wxPyBeginAllowThreads();
23499 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
23500 wxPyEndAllowThreads(__tstate);
23501 if (PyErr_Occurred()) SWIG_fail;
23502 }
23503 {
23504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23505 }
23506 return resultobj;
23507 fail:
23508 return NULL;
23509 }
23510
23511
23512 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23513 PyObject *resultobj = 0;
23514 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23515 bool result;
23516 void *argp1 = 0 ;
23517 int res1 = 0 ;
23518 PyObject *swig_obj[1] ;
23519
23520 if (!args) SWIG_fail;
23521 swig_obj[0] = args;
23522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23523 if (!SWIG_IsOK(res1)) {
23524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23525 }
23526 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23527 {
23528 PyThreadState* __tstate = wxPyBeginAllowThreads();
23529 result = (bool)(arg1)->LeftIsDown();
23530 wxPyEndAllowThreads(__tstate);
23531 if (PyErr_Occurred()) SWIG_fail;
23532 }
23533 {
23534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23535 }
23536 return resultobj;
23537 fail:
23538 return NULL;
23539 }
23540
23541
23542 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23543 PyObject *resultobj = 0;
23544 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23545 bool result;
23546 void *argp1 = 0 ;
23547 int res1 = 0 ;
23548 PyObject *swig_obj[1] ;
23549
23550 if (!args) SWIG_fail;
23551 swig_obj[0] = args;
23552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23553 if (!SWIG_IsOK(res1)) {
23554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23555 }
23556 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23557 {
23558 PyThreadState* __tstate = wxPyBeginAllowThreads();
23559 result = (bool)(arg1)->MiddleIsDown();
23560 wxPyEndAllowThreads(__tstate);
23561 if (PyErr_Occurred()) SWIG_fail;
23562 }
23563 {
23564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23565 }
23566 return resultobj;
23567 fail:
23568 return NULL;
23569 }
23570
23571
23572 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23573 PyObject *resultobj = 0;
23574 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23575 bool result;
23576 void *argp1 = 0 ;
23577 int res1 = 0 ;
23578 PyObject *swig_obj[1] ;
23579
23580 if (!args) SWIG_fail;
23581 swig_obj[0] = args;
23582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23583 if (!SWIG_IsOK(res1)) {
23584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23585 }
23586 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23587 {
23588 PyThreadState* __tstate = wxPyBeginAllowThreads();
23589 result = (bool)(arg1)->RightIsDown();
23590 wxPyEndAllowThreads(__tstate);
23591 if (PyErr_Occurred()) SWIG_fail;
23592 }
23593 {
23594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23595 }
23596 return resultobj;
23597 fail:
23598 return NULL;
23599 }
23600
23601
23602 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23603 PyObject *resultobj = 0;
23604 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23605 bool result;
23606 void *argp1 = 0 ;
23607 int res1 = 0 ;
23608 PyObject *swig_obj[1] ;
23609
23610 if (!args) SWIG_fail;
23611 swig_obj[0] = args;
23612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23613 if (!SWIG_IsOK(res1)) {
23614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23615 }
23616 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23617 {
23618 PyThreadState* __tstate = wxPyBeginAllowThreads();
23619 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
23620 wxPyEndAllowThreads(__tstate);
23621 if (PyErr_Occurred()) SWIG_fail;
23622 }
23623 {
23624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23625 }
23626 return resultobj;
23627 fail:
23628 return NULL;
23629 }
23630
23631
23632 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23633 PyObject *resultobj = 0;
23634 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23635 bool result;
23636 void *argp1 = 0 ;
23637 int res1 = 0 ;
23638 PyObject *swig_obj[1] ;
23639
23640 if (!args) SWIG_fail;
23641 swig_obj[0] = args;
23642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23643 if (!SWIG_IsOK(res1)) {
23644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23645 }
23646 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23647 {
23648 PyThreadState* __tstate = wxPyBeginAllowThreads();
23649 result = (bool)((wxMouseEvent const *)arg1)->Moving();
23650 wxPyEndAllowThreads(__tstate);
23651 if (PyErr_Occurred()) SWIG_fail;
23652 }
23653 {
23654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23655 }
23656 return resultobj;
23657 fail:
23658 return NULL;
23659 }
23660
23661
23662 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23663 PyObject *resultobj = 0;
23664 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23665 bool result;
23666 void *argp1 = 0 ;
23667 int res1 = 0 ;
23668 PyObject *swig_obj[1] ;
23669
23670 if (!args) SWIG_fail;
23671 swig_obj[0] = args;
23672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23673 if (!SWIG_IsOK(res1)) {
23674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23675 }
23676 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23677 {
23678 PyThreadState* __tstate = wxPyBeginAllowThreads();
23679 result = (bool)((wxMouseEvent const *)arg1)->Entering();
23680 wxPyEndAllowThreads(__tstate);
23681 if (PyErr_Occurred()) SWIG_fail;
23682 }
23683 {
23684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23685 }
23686 return resultobj;
23687 fail:
23688 return NULL;
23689 }
23690
23691
23692 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23693 PyObject *resultobj = 0;
23694 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23695 bool result;
23696 void *argp1 = 0 ;
23697 int res1 = 0 ;
23698 PyObject *swig_obj[1] ;
23699
23700 if (!args) SWIG_fail;
23701 swig_obj[0] = args;
23702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23703 if (!SWIG_IsOK(res1)) {
23704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23705 }
23706 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23707 {
23708 PyThreadState* __tstate = wxPyBeginAllowThreads();
23709 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
23710 wxPyEndAllowThreads(__tstate);
23711 if (PyErr_Occurred()) SWIG_fail;
23712 }
23713 {
23714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23715 }
23716 return resultobj;
23717 fail:
23718 return NULL;
23719 }
23720
23721
23722 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23723 PyObject *resultobj = 0;
23724 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23725 wxPoint result;
23726 void *argp1 = 0 ;
23727 int res1 = 0 ;
23728 PyObject *swig_obj[1] ;
23729
23730 if (!args) SWIG_fail;
23731 swig_obj[0] = args;
23732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23733 if (!SWIG_IsOK(res1)) {
23734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23735 }
23736 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23737 {
23738 PyThreadState* __tstate = wxPyBeginAllowThreads();
23739 result = (arg1)->GetPosition();
23740 wxPyEndAllowThreads(__tstate);
23741 if (PyErr_Occurred()) SWIG_fail;
23742 }
23743 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23744 return resultobj;
23745 fail:
23746 return NULL;
23747 }
23748
23749
23750 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23751 PyObject *resultobj = 0;
23752 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23753 long *arg2 = (long *) 0 ;
23754 long *arg3 = (long *) 0 ;
23755 void *argp1 = 0 ;
23756 int res1 = 0 ;
23757 long temp2 ;
23758 int res2 = SWIG_TMPOBJ ;
23759 long temp3 ;
23760 int res3 = SWIG_TMPOBJ ;
23761 PyObject *swig_obj[1] ;
23762
23763 arg2 = &temp2;
23764 arg3 = &temp3;
23765 if (!args) SWIG_fail;
23766 swig_obj[0] = args;
23767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23768 if (!SWIG_IsOK(res1)) {
23769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23770 }
23771 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23772 {
23773 PyThreadState* __tstate = wxPyBeginAllowThreads();
23774 (arg1)->GetPosition(arg2,arg3);
23775 wxPyEndAllowThreads(__tstate);
23776 if (PyErr_Occurred()) SWIG_fail;
23777 }
23778 resultobj = SWIG_Py_Void();
23779 if (SWIG_IsTmpObj(res2)) {
23780 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
23781 } else {
23782 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23783 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
23784 }
23785 if (SWIG_IsTmpObj(res3)) {
23786 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
23787 } else {
23788 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23789 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
23790 }
23791 return resultobj;
23792 fail:
23793 return NULL;
23794 }
23795
23796
23797 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23798 PyObject *resultobj = 0;
23799 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23800 wxDC *arg2 = 0 ;
23801 wxPoint result;
23802 void *argp1 = 0 ;
23803 int res1 = 0 ;
23804 void *argp2 = 0 ;
23805 int res2 = 0 ;
23806 PyObject * obj0 = 0 ;
23807 PyObject * obj1 = 0 ;
23808 char * kwnames[] = {
23809 (char *) "self",(char *) "dc", NULL
23810 };
23811
23812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23814 if (!SWIG_IsOK(res1)) {
23815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23816 }
23817 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23818 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
23819 if (!SWIG_IsOK(res2)) {
23820 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23821 }
23822 if (!argp2) {
23823 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23824 }
23825 arg2 = reinterpret_cast< wxDC * >(argp2);
23826 {
23827 PyThreadState* __tstate = wxPyBeginAllowThreads();
23828 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
23829 wxPyEndAllowThreads(__tstate);
23830 if (PyErr_Occurred()) SWIG_fail;
23831 }
23832 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23833 return resultobj;
23834 fail:
23835 return NULL;
23836 }
23837
23838
23839 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23840 PyObject *resultobj = 0;
23841 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23842 int result;
23843 void *argp1 = 0 ;
23844 int res1 = 0 ;
23845 PyObject *swig_obj[1] ;
23846
23847 if (!args) SWIG_fail;
23848 swig_obj[0] = args;
23849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23850 if (!SWIG_IsOK(res1)) {
23851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23852 }
23853 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23854 {
23855 PyThreadState* __tstate = wxPyBeginAllowThreads();
23856 result = (int)((wxMouseEvent const *)arg1)->GetX();
23857 wxPyEndAllowThreads(__tstate);
23858 if (PyErr_Occurred()) SWIG_fail;
23859 }
23860 resultobj = SWIG_From_int(static_cast< int >(result));
23861 return resultobj;
23862 fail:
23863 return NULL;
23864 }
23865
23866
23867 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23868 PyObject *resultobj = 0;
23869 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23870 int result;
23871 void *argp1 = 0 ;
23872 int res1 = 0 ;
23873 PyObject *swig_obj[1] ;
23874
23875 if (!args) SWIG_fail;
23876 swig_obj[0] = args;
23877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23878 if (!SWIG_IsOK(res1)) {
23879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23880 }
23881 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23882 {
23883 PyThreadState* __tstate = wxPyBeginAllowThreads();
23884 result = (int)((wxMouseEvent const *)arg1)->GetY();
23885 wxPyEndAllowThreads(__tstate);
23886 if (PyErr_Occurred()) SWIG_fail;
23887 }
23888 resultobj = SWIG_From_int(static_cast< int >(result));
23889 return resultobj;
23890 fail:
23891 return NULL;
23892 }
23893
23894
23895 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23896 PyObject *resultobj = 0;
23897 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23898 int result;
23899 void *argp1 = 0 ;
23900 int res1 = 0 ;
23901 PyObject *swig_obj[1] ;
23902
23903 if (!args) SWIG_fail;
23904 swig_obj[0] = args;
23905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23906 if (!SWIG_IsOK(res1)) {
23907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23908 }
23909 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23910 {
23911 PyThreadState* __tstate = wxPyBeginAllowThreads();
23912 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
23913 wxPyEndAllowThreads(__tstate);
23914 if (PyErr_Occurred()) SWIG_fail;
23915 }
23916 resultobj = SWIG_From_int(static_cast< int >(result));
23917 return resultobj;
23918 fail:
23919 return NULL;
23920 }
23921
23922
23923 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23924 PyObject *resultobj = 0;
23925 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23926 int result;
23927 void *argp1 = 0 ;
23928 int res1 = 0 ;
23929 PyObject *swig_obj[1] ;
23930
23931 if (!args) SWIG_fail;
23932 swig_obj[0] = args;
23933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23934 if (!SWIG_IsOK(res1)) {
23935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23936 }
23937 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23938 {
23939 PyThreadState* __tstate = wxPyBeginAllowThreads();
23940 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
23941 wxPyEndAllowThreads(__tstate);
23942 if (PyErr_Occurred()) SWIG_fail;
23943 }
23944 resultobj = SWIG_From_int(static_cast< int >(result));
23945 return resultobj;
23946 fail:
23947 return NULL;
23948 }
23949
23950
23951 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelAxis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23952 PyObject *resultobj = 0;
23953 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23954 int result;
23955 void *argp1 = 0 ;
23956 int res1 = 0 ;
23957 PyObject *swig_obj[1] ;
23958
23959 if (!args) SWIG_fail;
23960 swig_obj[0] = args;
23961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23962 if (!SWIG_IsOK(res1)) {
23963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelAxis" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23964 }
23965 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23966 {
23967 PyThreadState* __tstate = wxPyBeginAllowThreads();
23968 result = (int)((wxMouseEvent const *)arg1)->GetWheelAxis();
23969 wxPyEndAllowThreads(__tstate);
23970 if (PyErr_Occurred()) SWIG_fail;
23971 }
23972 resultobj = SWIG_From_int(static_cast< int >(result));
23973 return resultobj;
23974 fail:
23975 return NULL;
23976 }
23977
23978
23979 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23980 PyObject *resultobj = 0;
23981 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23982 int result;
23983 void *argp1 = 0 ;
23984 int res1 = 0 ;
23985 PyObject *swig_obj[1] ;
23986
23987 if (!args) SWIG_fail;
23988 swig_obj[0] = args;
23989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23990 if (!SWIG_IsOK(res1)) {
23991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23992 }
23993 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23994 {
23995 PyThreadState* __tstate = wxPyBeginAllowThreads();
23996 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
23997 wxPyEndAllowThreads(__tstate);
23998 if (PyErr_Occurred()) SWIG_fail;
23999 }
24000 resultobj = SWIG_From_int(static_cast< int >(result));
24001 return resultobj;
24002 fail:
24003 return NULL;
24004 }
24005
24006
24007 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24008 PyObject *resultobj = 0;
24009 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24010 bool result;
24011 void *argp1 = 0 ;
24012 int res1 = 0 ;
24013 PyObject *swig_obj[1] ;
24014
24015 if (!args) SWIG_fail;
24016 swig_obj[0] = args;
24017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24018 if (!SWIG_IsOK(res1)) {
24019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24020 }
24021 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24022 {
24023 PyThreadState* __tstate = wxPyBeginAllowThreads();
24024 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
24025 wxPyEndAllowThreads(__tstate);
24026 if (PyErr_Occurred()) SWIG_fail;
24027 }
24028 {
24029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24030 }
24031 return resultobj;
24032 fail:
24033 return NULL;
24034 }
24035
24036
24037 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24038 PyObject *resultobj = 0;
24039 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24040 int arg2 ;
24041 void *argp1 = 0 ;
24042 int res1 = 0 ;
24043 int val2 ;
24044 int ecode2 = 0 ;
24045 PyObject *swig_obj[2] ;
24046
24047 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
24048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24049 if (!SWIG_IsOK(res1)) {
24050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24051 }
24052 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24053 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24054 if (!SWIG_IsOK(ecode2)) {
24055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
24056 }
24057 arg2 = static_cast< int >(val2);
24058 if (arg1) (arg1)->m_x = arg2;
24059
24060 resultobj = SWIG_Py_Void();
24061 return resultobj;
24062 fail:
24063 return NULL;
24064 }
24065
24066
24067 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24068 PyObject *resultobj = 0;
24069 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24070 int result;
24071 void *argp1 = 0 ;
24072 int res1 = 0 ;
24073 PyObject *swig_obj[1] ;
24074
24075 if (!args) SWIG_fail;
24076 swig_obj[0] = args;
24077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24078 if (!SWIG_IsOK(res1)) {
24079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24080 }
24081 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24082 result = (int) ((arg1)->m_x);
24083 resultobj = SWIG_From_int(static_cast< int >(result));
24084 return resultobj;
24085 fail:
24086 return NULL;
24087 }
24088
24089
24090 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24091 PyObject *resultobj = 0;
24092 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24093 int arg2 ;
24094 void *argp1 = 0 ;
24095 int res1 = 0 ;
24096 int val2 ;
24097 int ecode2 = 0 ;
24098 PyObject *swig_obj[2] ;
24099
24100 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
24101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24102 if (!SWIG_IsOK(res1)) {
24103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24104 }
24105 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24106 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24107 if (!SWIG_IsOK(ecode2)) {
24108 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
24109 }
24110 arg2 = static_cast< int >(val2);
24111 if (arg1) (arg1)->m_y = arg2;
24112
24113 resultobj = SWIG_Py_Void();
24114 return resultobj;
24115 fail:
24116 return NULL;
24117 }
24118
24119
24120 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24121 PyObject *resultobj = 0;
24122 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24123 int result;
24124 void *argp1 = 0 ;
24125 int res1 = 0 ;
24126 PyObject *swig_obj[1] ;
24127
24128 if (!args) SWIG_fail;
24129 swig_obj[0] = args;
24130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24131 if (!SWIG_IsOK(res1)) {
24132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24133 }
24134 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24135 result = (int) ((arg1)->m_y);
24136 resultobj = SWIG_From_int(static_cast< int >(result));
24137 return resultobj;
24138 fail:
24139 return NULL;
24140 }
24141
24142
24143 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24144 PyObject *resultobj = 0;
24145 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24146 bool arg2 ;
24147 void *argp1 = 0 ;
24148 int res1 = 0 ;
24149 bool val2 ;
24150 int ecode2 = 0 ;
24151 PyObject *swig_obj[2] ;
24152
24153 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
24154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24155 if (!SWIG_IsOK(res1)) {
24156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24157 }
24158 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24159 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24160 if (!SWIG_IsOK(ecode2)) {
24161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
24162 }
24163 arg2 = static_cast< bool >(val2);
24164 if (arg1) (arg1)->m_leftDown = arg2;
24165
24166 resultobj = SWIG_Py_Void();
24167 return resultobj;
24168 fail:
24169 return NULL;
24170 }
24171
24172
24173 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24174 PyObject *resultobj = 0;
24175 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24176 bool result;
24177 void *argp1 = 0 ;
24178 int res1 = 0 ;
24179 PyObject *swig_obj[1] ;
24180
24181 if (!args) SWIG_fail;
24182 swig_obj[0] = args;
24183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24184 if (!SWIG_IsOK(res1)) {
24185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24186 }
24187 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24188 result = (bool) ((arg1)->m_leftDown);
24189 {
24190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24191 }
24192 return resultobj;
24193 fail:
24194 return NULL;
24195 }
24196
24197
24198 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24199 PyObject *resultobj = 0;
24200 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24201 bool arg2 ;
24202 void *argp1 = 0 ;
24203 int res1 = 0 ;
24204 bool val2 ;
24205 int ecode2 = 0 ;
24206 PyObject *swig_obj[2] ;
24207
24208 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
24209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24210 if (!SWIG_IsOK(res1)) {
24211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24212 }
24213 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24214 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24215 if (!SWIG_IsOK(ecode2)) {
24216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
24217 }
24218 arg2 = static_cast< bool >(val2);
24219 if (arg1) (arg1)->m_middleDown = arg2;
24220
24221 resultobj = SWIG_Py_Void();
24222 return resultobj;
24223 fail:
24224 return NULL;
24225 }
24226
24227
24228 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24229 PyObject *resultobj = 0;
24230 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24231 bool result;
24232 void *argp1 = 0 ;
24233 int res1 = 0 ;
24234 PyObject *swig_obj[1] ;
24235
24236 if (!args) SWIG_fail;
24237 swig_obj[0] = args;
24238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24239 if (!SWIG_IsOK(res1)) {
24240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24241 }
24242 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24243 result = (bool) ((arg1)->m_middleDown);
24244 {
24245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24246 }
24247 return resultobj;
24248 fail:
24249 return NULL;
24250 }
24251
24252
24253 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24254 PyObject *resultobj = 0;
24255 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24256 bool arg2 ;
24257 void *argp1 = 0 ;
24258 int res1 = 0 ;
24259 bool val2 ;
24260 int ecode2 = 0 ;
24261 PyObject *swig_obj[2] ;
24262
24263 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
24264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24265 if (!SWIG_IsOK(res1)) {
24266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24267 }
24268 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24269 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24270 if (!SWIG_IsOK(ecode2)) {
24271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
24272 }
24273 arg2 = static_cast< bool >(val2);
24274 if (arg1) (arg1)->m_rightDown = arg2;
24275
24276 resultobj = SWIG_Py_Void();
24277 return resultobj;
24278 fail:
24279 return NULL;
24280 }
24281
24282
24283 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24284 PyObject *resultobj = 0;
24285 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24286 bool result;
24287 void *argp1 = 0 ;
24288 int res1 = 0 ;
24289 PyObject *swig_obj[1] ;
24290
24291 if (!args) SWIG_fail;
24292 swig_obj[0] = args;
24293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24294 if (!SWIG_IsOK(res1)) {
24295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24296 }
24297 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24298 result = (bool) ((arg1)->m_rightDown);
24299 {
24300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24301 }
24302 return resultobj;
24303 fail:
24304 return NULL;
24305 }
24306
24307
24308 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24309 PyObject *resultobj = 0;
24310 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24311 bool arg2 ;
24312 void *argp1 = 0 ;
24313 int res1 = 0 ;
24314 bool val2 ;
24315 int ecode2 = 0 ;
24316 PyObject *swig_obj[2] ;
24317
24318 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
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_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24322 }
24323 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24324 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24325 if (!SWIG_IsOK(ecode2)) {
24326 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
24327 }
24328 arg2 = static_cast< bool >(val2);
24329 if (arg1) (arg1)->m_controlDown = arg2;
24330
24331 resultobj = SWIG_Py_Void();
24332 return resultobj;
24333 fail:
24334 return NULL;
24335 }
24336
24337
24338 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24339 PyObject *resultobj = 0;
24340 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24341 bool result;
24342 void *argp1 = 0 ;
24343 int res1 = 0 ;
24344 PyObject *swig_obj[1] ;
24345
24346 if (!args) SWIG_fail;
24347 swig_obj[0] = args;
24348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24349 if (!SWIG_IsOK(res1)) {
24350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24351 }
24352 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24353 result = (bool) ((arg1)->m_controlDown);
24354 {
24355 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24356 }
24357 return resultobj;
24358 fail:
24359 return NULL;
24360 }
24361
24362
24363 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24364 PyObject *resultobj = 0;
24365 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24366 bool arg2 ;
24367 void *argp1 = 0 ;
24368 int res1 = 0 ;
24369 bool val2 ;
24370 int ecode2 = 0 ;
24371 PyObject *swig_obj[2] ;
24372
24373 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
24374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24375 if (!SWIG_IsOK(res1)) {
24376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24377 }
24378 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24379 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24380 if (!SWIG_IsOK(ecode2)) {
24381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
24382 }
24383 arg2 = static_cast< bool >(val2);
24384 if (arg1) (arg1)->m_shiftDown = arg2;
24385
24386 resultobj = SWIG_Py_Void();
24387 return resultobj;
24388 fail:
24389 return NULL;
24390 }
24391
24392
24393 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24394 PyObject *resultobj = 0;
24395 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24396 bool result;
24397 void *argp1 = 0 ;
24398 int res1 = 0 ;
24399 PyObject *swig_obj[1] ;
24400
24401 if (!args) SWIG_fail;
24402 swig_obj[0] = args;
24403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24404 if (!SWIG_IsOK(res1)) {
24405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24406 }
24407 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24408 result = (bool) ((arg1)->m_shiftDown);
24409 {
24410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24411 }
24412 return resultobj;
24413 fail:
24414 return NULL;
24415 }
24416
24417
24418 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24419 PyObject *resultobj = 0;
24420 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24421 bool arg2 ;
24422 void *argp1 = 0 ;
24423 int res1 = 0 ;
24424 bool val2 ;
24425 int ecode2 = 0 ;
24426 PyObject *swig_obj[2] ;
24427
24428 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
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_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24432 }
24433 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24434 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24435 if (!SWIG_IsOK(ecode2)) {
24436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
24437 }
24438 arg2 = static_cast< bool >(val2);
24439 if (arg1) (arg1)->m_altDown = arg2;
24440
24441 resultobj = SWIG_Py_Void();
24442 return resultobj;
24443 fail:
24444 return NULL;
24445 }
24446
24447
24448 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24449 PyObject *resultobj = 0;
24450 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24451 bool result;
24452 void *argp1 = 0 ;
24453 int res1 = 0 ;
24454 PyObject *swig_obj[1] ;
24455
24456 if (!args) SWIG_fail;
24457 swig_obj[0] = args;
24458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24459 if (!SWIG_IsOK(res1)) {
24460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24461 }
24462 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24463 result = (bool) ((arg1)->m_altDown);
24464 {
24465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24466 }
24467 return resultobj;
24468 fail:
24469 return NULL;
24470 }
24471
24472
24473 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24474 PyObject *resultobj = 0;
24475 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24476 bool arg2 ;
24477 void *argp1 = 0 ;
24478 int res1 = 0 ;
24479 bool val2 ;
24480 int ecode2 = 0 ;
24481 PyObject *swig_obj[2] ;
24482
24483 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
24484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24485 if (!SWIG_IsOK(res1)) {
24486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24487 }
24488 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24489 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24490 if (!SWIG_IsOK(ecode2)) {
24491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
24492 }
24493 arg2 = static_cast< bool >(val2);
24494 if (arg1) (arg1)->m_metaDown = arg2;
24495
24496 resultobj = SWIG_Py_Void();
24497 return resultobj;
24498 fail:
24499 return NULL;
24500 }
24501
24502
24503 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24504 PyObject *resultobj = 0;
24505 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24506 bool 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_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24516 }
24517 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24518 result = (bool) ((arg1)->m_metaDown);
24519 {
24520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24521 }
24522 return resultobj;
24523 fail:
24524 return NULL;
24525 }
24526
24527
24528 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24529 PyObject *resultobj = 0;
24530 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24531 int arg2 ;
24532 void *argp1 = 0 ;
24533 int res1 = 0 ;
24534 int val2 ;
24535 int ecode2 = 0 ;
24536 PyObject *swig_obj[2] ;
24537
24538 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
24539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24540 if (!SWIG_IsOK(res1)) {
24541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24542 }
24543 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24544 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24545 if (!SWIG_IsOK(ecode2)) {
24546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
24547 }
24548 arg2 = static_cast< int >(val2);
24549 if (arg1) (arg1)->m_wheelRotation = arg2;
24550
24551 resultobj = SWIG_Py_Void();
24552 return resultobj;
24553 fail:
24554 return NULL;
24555 }
24556
24557
24558 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24559 PyObject *resultobj = 0;
24560 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24561 int result;
24562 void *argp1 = 0 ;
24563 int res1 = 0 ;
24564 PyObject *swig_obj[1] ;
24565
24566 if (!args) SWIG_fail;
24567 swig_obj[0] = args;
24568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24569 if (!SWIG_IsOK(res1)) {
24570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24571 }
24572 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24573 result = (int) ((arg1)->m_wheelRotation);
24574 resultobj = SWIG_From_int(static_cast< int >(result));
24575 return resultobj;
24576 fail:
24577 return NULL;
24578 }
24579
24580
24581 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24582 PyObject *resultobj = 0;
24583 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24584 int arg2 ;
24585 void *argp1 = 0 ;
24586 int res1 = 0 ;
24587 int val2 ;
24588 int ecode2 = 0 ;
24589 PyObject *swig_obj[2] ;
24590
24591 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
24592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24593 if (!SWIG_IsOK(res1)) {
24594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24595 }
24596 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24597 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24598 if (!SWIG_IsOK(ecode2)) {
24599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
24600 }
24601 arg2 = static_cast< int >(val2);
24602 if (arg1) (arg1)->m_wheelDelta = arg2;
24603
24604 resultobj = SWIG_Py_Void();
24605 return resultobj;
24606 fail:
24607 return NULL;
24608 }
24609
24610
24611 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24612 PyObject *resultobj = 0;
24613 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24614 int result;
24615 void *argp1 = 0 ;
24616 int res1 = 0 ;
24617 PyObject *swig_obj[1] ;
24618
24619 if (!args) SWIG_fail;
24620 swig_obj[0] = args;
24621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24622 if (!SWIG_IsOK(res1)) {
24623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24624 }
24625 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24626 result = (int) ((arg1)->m_wheelDelta);
24627 resultobj = SWIG_From_int(static_cast< int >(result));
24628 return resultobj;
24629 fail:
24630 return NULL;
24631 }
24632
24633
24634 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24635 PyObject *resultobj = 0;
24636 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24637 int arg2 ;
24638 void *argp1 = 0 ;
24639 int res1 = 0 ;
24640 int val2 ;
24641 int ecode2 = 0 ;
24642 PyObject *swig_obj[2] ;
24643
24644 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
24645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24646 if (!SWIG_IsOK(res1)) {
24647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24648 }
24649 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24650 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24651 if (!SWIG_IsOK(ecode2)) {
24652 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
24653 }
24654 arg2 = static_cast< int >(val2);
24655 if (arg1) (arg1)->m_linesPerAction = arg2;
24656
24657 resultobj = SWIG_Py_Void();
24658 return resultobj;
24659 fail:
24660 return NULL;
24661 }
24662
24663
24664 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24665 PyObject *resultobj = 0;
24666 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24667 int result;
24668 void *argp1 = 0 ;
24669 int res1 = 0 ;
24670 PyObject *swig_obj[1] ;
24671
24672 if (!args) SWIG_fail;
24673 swig_obj[0] = args;
24674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24675 if (!SWIG_IsOK(res1)) {
24676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24677 }
24678 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24679 result = (int) ((arg1)->m_linesPerAction);
24680 resultobj = SWIG_From_int(static_cast< int >(result));
24681 return resultobj;
24682 fail:
24683 return NULL;
24684 }
24685
24686
24687 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24688 PyObject *obj;
24689 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24690 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
24691 return SWIG_Py_Void();
24692 }
24693
24694 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24695 return SWIG_Python_InitShadowInstance(args);
24696 }
24697
24698 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24699 PyObject *resultobj = 0;
24700 int arg1 = (int) 0 ;
24701 int arg2 = (int) 0 ;
24702 wxSetCursorEvent *result = 0 ;
24703 int val1 ;
24704 int ecode1 = 0 ;
24705 int val2 ;
24706 int ecode2 = 0 ;
24707 PyObject * obj0 = 0 ;
24708 PyObject * obj1 = 0 ;
24709 char * kwnames[] = {
24710 (char *) "x",(char *) "y", NULL
24711 };
24712
24713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24714 if (obj0) {
24715 ecode1 = SWIG_AsVal_int(obj0, &val1);
24716 if (!SWIG_IsOK(ecode1)) {
24717 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
24718 }
24719 arg1 = static_cast< int >(val1);
24720 }
24721 if (obj1) {
24722 ecode2 = SWIG_AsVal_int(obj1, &val2);
24723 if (!SWIG_IsOK(ecode2)) {
24724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
24725 }
24726 arg2 = static_cast< int >(val2);
24727 }
24728 {
24729 PyThreadState* __tstate = wxPyBeginAllowThreads();
24730 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
24731 wxPyEndAllowThreads(__tstate);
24732 if (PyErr_Occurred()) SWIG_fail;
24733 }
24734 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
24735 return resultobj;
24736 fail:
24737 return NULL;
24738 }
24739
24740
24741 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24742 PyObject *resultobj = 0;
24743 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24744 int result;
24745 void *argp1 = 0 ;
24746 int res1 = 0 ;
24747 PyObject *swig_obj[1] ;
24748
24749 if (!args) SWIG_fail;
24750 swig_obj[0] = args;
24751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24752 if (!SWIG_IsOK(res1)) {
24753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24754 }
24755 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24756 {
24757 PyThreadState* __tstate = wxPyBeginAllowThreads();
24758 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
24759 wxPyEndAllowThreads(__tstate);
24760 if (PyErr_Occurred()) SWIG_fail;
24761 }
24762 resultobj = SWIG_From_int(static_cast< int >(result));
24763 return resultobj;
24764 fail:
24765 return NULL;
24766 }
24767
24768
24769 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24770 PyObject *resultobj = 0;
24771 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24772 int result;
24773 void *argp1 = 0 ;
24774 int res1 = 0 ;
24775 PyObject *swig_obj[1] ;
24776
24777 if (!args) SWIG_fail;
24778 swig_obj[0] = args;
24779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24780 if (!SWIG_IsOK(res1)) {
24781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24782 }
24783 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24784 {
24785 PyThreadState* __tstate = wxPyBeginAllowThreads();
24786 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
24787 wxPyEndAllowThreads(__tstate);
24788 if (PyErr_Occurred()) SWIG_fail;
24789 }
24790 resultobj = SWIG_From_int(static_cast< int >(result));
24791 return resultobj;
24792 fail:
24793 return NULL;
24794 }
24795
24796
24797 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24798 PyObject *resultobj = 0;
24799 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24800 wxCursor *arg2 = 0 ;
24801 void *argp1 = 0 ;
24802 int res1 = 0 ;
24803 void *argp2 = 0 ;
24804 int res2 = 0 ;
24805 PyObject * obj0 = 0 ;
24806 PyObject * obj1 = 0 ;
24807 char * kwnames[] = {
24808 (char *) "self",(char *) "cursor", NULL
24809 };
24810
24811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
24812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24813 if (!SWIG_IsOK(res1)) {
24814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
24815 }
24816 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24817 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
24818 if (!SWIG_IsOK(res2)) {
24819 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24820 }
24821 if (!argp2) {
24822 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24823 }
24824 arg2 = reinterpret_cast< wxCursor * >(argp2);
24825 {
24826 PyThreadState* __tstate = wxPyBeginAllowThreads();
24827 (arg1)->SetCursor((wxCursor const &)*arg2);
24828 wxPyEndAllowThreads(__tstate);
24829 if (PyErr_Occurred()) SWIG_fail;
24830 }
24831 resultobj = SWIG_Py_Void();
24832 return resultobj;
24833 fail:
24834 return NULL;
24835 }
24836
24837
24838 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24839 PyObject *resultobj = 0;
24840 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24841 wxCursor *result = 0 ;
24842 void *argp1 = 0 ;
24843 int res1 = 0 ;
24844 PyObject *swig_obj[1] ;
24845
24846 if (!args) SWIG_fail;
24847 swig_obj[0] = args;
24848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24849 if (!SWIG_IsOK(res1)) {
24850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24851 }
24852 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24853 {
24854 PyThreadState* __tstate = wxPyBeginAllowThreads();
24855 {
24856 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
24857 result = (wxCursor *) &_result_ref;
24858 }
24859 wxPyEndAllowThreads(__tstate);
24860 if (PyErr_Occurred()) SWIG_fail;
24861 }
24862 {
24863 wxCursor* resultptr = new wxCursor(*result);
24864 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
24865 }
24866 return resultobj;
24867 fail:
24868 return NULL;
24869 }
24870
24871
24872 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24873 PyObject *resultobj = 0;
24874 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24875 bool result;
24876 void *argp1 = 0 ;
24877 int res1 = 0 ;
24878 PyObject *swig_obj[1] ;
24879
24880 if (!args) SWIG_fail;
24881 swig_obj[0] = args;
24882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24883 if (!SWIG_IsOK(res1)) {
24884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24885 }
24886 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24887 {
24888 PyThreadState* __tstate = wxPyBeginAllowThreads();
24889 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
24890 wxPyEndAllowThreads(__tstate);
24891 if (PyErr_Occurred()) SWIG_fail;
24892 }
24893 {
24894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24895 }
24896 return resultobj;
24897 fail:
24898 return NULL;
24899 }
24900
24901
24902 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24903 PyObject *obj;
24904 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24905 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
24906 return SWIG_Py_Void();
24907 }
24908
24909 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24910 return SWIG_Python_InitShadowInstance(args);
24911 }
24912
24913 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24914 PyObject *resultobj = 0;
24915 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24916 wxKeyEvent *result = 0 ;
24917 int val1 ;
24918 int ecode1 = 0 ;
24919 PyObject * obj0 = 0 ;
24920 char * kwnames[] = {
24921 (char *) "eventType", NULL
24922 };
24923
24924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
24925 if (obj0) {
24926 ecode1 = SWIG_AsVal_int(obj0, &val1);
24927 if (!SWIG_IsOK(ecode1)) {
24928 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24929 }
24930 arg1 = static_cast< wxEventType >(val1);
24931 }
24932 {
24933 PyThreadState* __tstate = wxPyBeginAllowThreads();
24934 result = (wxKeyEvent *)new wxKeyEvent(arg1);
24935 wxPyEndAllowThreads(__tstate);
24936 if (PyErr_Occurred()) SWIG_fail;
24937 }
24938 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
24939 return resultobj;
24940 fail:
24941 return NULL;
24942 }
24943
24944
24945 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24946 PyObject *resultobj = 0;
24947 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24948 int 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_wxKeyEvent, 0 | 0 );
24956 if (!SWIG_IsOK(res1)) {
24957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24958 }
24959 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24960 {
24961 PyThreadState* __tstate = wxPyBeginAllowThreads();
24962 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
24963 wxPyEndAllowThreads(__tstate);
24964 if (PyErr_Occurred()) SWIG_fail;
24965 }
24966 resultobj = SWIG_From_int(static_cast< int >(result));
24967 return resultobj;
24968 fail:
24969 return NULL;
24970 }
24971
24972
24973 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24974 PyObject *resultobj = 0;
24975 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24976 bool result;
24977 void *argp1 = 0 ;
24978 int res1 = 0 ;
24979 PyObject *swig_obj[1] ;
24980
24981 if (!args) SWIG_fail;
24982 swig_obj[0] = args;
24983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24984 if (!SWIG_IsOK(res1)) {
24985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24986 }
24987 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24988 {
24989 PyThreadState* __tstate = wxPyBeginAllowThreads();
24990 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
24991 wxPyEndAllowThreads(__tstate);
24992 if (PyErr_Occurred()) SWIG_fail;
24993 }
24994 {
24995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24996 }
24997 return resultobj;
24998 fail:
24999 return NULL;
25000 }
25001
25002
25003 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25004 PyObject *resultobj = 0;
25005 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25006 bool result;
25007 void *argp1 = 0 ;
25008 int res1 = 0 ;
25009 PyObject *swig_obj[1] ;
25010
25011 if (!args) SWIG_fail;
25012 swig_obj[0] = args;
25013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25014 if (!SWIG_IsOK(res1)) {
25015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25016 }
25017 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25018 {
25019 PyThreadState* __tstate = wxPyBeginAllowThreads();
25020 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
25021 wxPyEndAllowThreads(__tstate);
25022 if (PyErr_Occurred()) SWIG_fail;
25023 }
25024 {
25025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25026 }
25027 return resultobj;
25028 fail:
25029 return NULL;
25030 }
25031
25032
25033 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25034 PyObject *resultobj = 0;
25035 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25036 bool result;
25037 void *argp1 = 0 ;
25038 int res1 = 0 ;
25039 PyObject *swig_obj[1] ;
25040
25041 if (!args) SWIG_fail;
25042 swig_obj[0] = args;
25043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25044 if (!SWIG_IsOK(res1)) {
25045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25046 }
25047 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25048 {
25049 PyThreadState* __tstate = wxPyBeginAllowThreads();
25050 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
25051 wxPyEndAllowThreads(__tstate);
25052 if (PyErr_Occurred()) SWIG_fail;
25053 }
25054 {
25055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25056 }
25057 return resultobj;
25058 fail:
25059 return NULL;
25060 }
25061
25062
25063 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25064 PyObject *resultobj = 0;
25065 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25066 bool result;
25067 void *argp1 = 0 ;
25068 int res1 = 0 ;
25069 PyObject *swig_obj[1] ;
25070
25071 if (!args) SWIG_fail;
25072 swig_obj[0] = args;
25073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25074 if (!SWIG_IsOK(res1)) {
25075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25076 }
25077 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25078 {
25079 PyThreadState* __tstate = wxPyBeginAllowThreads();
25080 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
25081 wxPyEndAllowThreads(__tstate);
25082 if (PyErr_Occurred()) SWIG_fail;
25083 }
25084 {
25085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25086 }
25087 return resultobj;
25088 fail:
25089 return NULL;
25090 }
25091
25092
25093 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25094 PyObject *resultobj = 0;
25095 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25096 bool result;
25097 void *argp1 = 0 ;
25098 int res1 = 0 ;
25099 PyObject *swig_obj[1] ;
25100
25101 if (!args) SWIG_fail;
25102 swig_obj[0] = args;
25103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25104 if (!SWIG_IsOK(res1)) {
25105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25106 }
25107 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25108 {
25109 PyThreadState* __tstate = wxPyBeginAllowThreads();
25110 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
25111 wxPyEndAllowThreads(__tstate);
25112 if (PyErr_Occurred()) SWIG_fail;
25113 }
25114 {
25115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25116 }
25117 return resultobj;
25118 fail:
25119 return NULL;
25120 }
25121
25122
25123 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25124 PyObject *resultobj = 0;
25125 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25126 bool result;
25127 void *argp1 = 0 ;
25128 int res1 = 0 ;
25129 PyObject *swig_obj[1] ;
25130
25131 if (!args) SWIG_fail;
25132 swig_obj[0] = args;
25133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25134 if (!SWIG_IsOK(res1)) {
25135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25136 }
25137 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25138 {
25139 PyThreadState* __tstate = wxPyBeginAllowThreads();
25140 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
25141 wxPyEndAllowThreads(__tstate);
25142 if (PyErr_Occurred()) SWIG_fail;
25143 }
25144 {
25145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25146 }
25147 return resultobj;
25148 fail:
25149 return NULL;
25150 }
25151
25152
25153 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25154 PyObject *resultobj = 0;
25155 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25156 int result;
25157 void *argp1 = 0 ;
25158 int res1 = 0 ;
25159 PyObject *swig_obj[1] ;
25160
25161 if (!args) SWIG_fail;
25162 swig_obj[0] = args;
25163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25164 if (!SWIG_IsOK(res1)) {
25165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25166 }
25167 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25168 {
25169 PyThreadState* __tstate = wxPyBeginAllowThreads();
25170 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
25171 wxPyEndAllowThreads(__tstate);
25172 if (PyErr_Occurred()) SWIG_fail;
25173 }
25174 resultobj = SWIG_From_int(static_cast< int >(result));
25175 return resultobj;
25176 fail:
25177 return NULL;
25178 }
25179
25180
25181 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25182 PyObject *resultobj = 0;
25183 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25184 int result;
25185 void *argp1 = 0 ;
25186 int res1 = 0 ;
25187 PyObject *swig_obj[1] ;
25188
25189 if (!args) SWIG_fail;
25190 swig_obj[0] = args;
25191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25192 if (!SWIG_IsOK(res1)) {
25193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25194 }
25195 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25196 {
25197 PyThreadState* __tstate = wxPyBeginAllowThreads();
25198 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
25199 wxPyEndAllowThreads(__tstate);
25200 if (PyErr_Occurred()) SWIG_fail;
25201 }
25202 resultobj = SWIG_From_int(static_cast< int >(result));
25203 return resultobj;
25204 fail:
25205 return NULL;
25206 }
25207
25208
25209 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25210 PyObject *resultobj = 0;
25211 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25212 int arg2 ;
25213 void *argp1 = 0 ;
25214 int res1 = 0 ;
25215 int val2 ;
25216 int ecode2 = 0 ;
25217 PyObject * obj0 = 0 ;
25218 PyObject * obj1 = 0 ;
25219 char * kwnames[] = {
25220 (char *) "self",(char *) "uniChar", NULL
25221 };
25222
25223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
25224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25225 if (!SWIG_IsOK(res1)) {
25226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25227 }
25228 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25229 ecode2 = SWIG_AsVal_int(obj1, &val2);
25230 if (!SWIG_IsOK(ecode2)) {
25231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
25232 }
25233 arg2 = static_cast< int >(val2);
25234 {
25235 PyThreadState* __tstate = wxPyBeginAllowThreads();
25236 wxKeyEvent_SetUnicodeKey(arg1,arg2);
25237 wxPyEndAllowThreads(__tstate);
25238 if (PyErr_Occurred()) SWIG_fail;
25239 }
25240 resultobj = SWIG_Py_Void();
25241 return resultobj;
25242 fail:
25243 return NULL;
25244 }
25245
25246
25247 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25248 PyObject *resultobj = 0;
25249 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25250 unsigned int result;
25251 void *argp1 = 0 ;
25252 int res1 = 0 ;
25253 PyObject *swig_obj[1] ;
25254
25255 if (!args) SWIG_fail;
25256 swig_obj[0] = args;
25257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25258 if (!SWIG_IsOK(res1)) {
25259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25260 }
25261 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25262 {
25263 PyThreadState* __tstate = wxPyBeginAllowThreads();
25264 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
25265 wxPyEndAllowThreads(__tstate);
25266 if (PyErr_Occurred()) SWIG_fail;
25267 }
25268 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25269 return resultobj;
25270 fail:
25271 return NULL;
25272 }
25273
25274
25275 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25276 PyObject *resultobj = 0;
25277 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25278 unsigned int result;
25279 void *argp1 = 0 ;
25280 int res1 = 0 ;
25281 PyObject *swig_obj[1] ;
25282
25283 if (!args) SWIG_fail;
25284 swig_obj[0] = args;
25285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25286 if (!SWIG_IsOK(res1)) {
25287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25288 }
25289 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25290 {
25291 PyThreadState* __tstate = wxPyBeginAllowThreads();
25292 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
25293 wxPyEndAllowThreads(__tstate);
25294 if (PyErr_Occurred()) SWIG_fail;
25295 }
25296 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25297 return resultobj;
25298 fail:
25299 return NULL;
25300 }
25301
25302
25303 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25304 PyObject *resultobj = 0;
25305 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25306 wxPoint result;
25307 void *argp1 = 0 ;
25308 int res1 = 0 ;
25309 PyObject *swig_obj[1] ;
25310
25311 if (!args) SWIG_fail;
25312 swig_obj[0] = args;
25313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25314 if (!SWIG_IsOK(res1)) {
25315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25316 }
25317 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25318 {
25319 PyThreadState* __tstate = wxPyBeginAllowThreads();
25320 result = (arg1)->GetPosition();
25321 wxPyEndAllowThreads(__tstate);
25322 if (PyErr_Occurred()) SWIG_fail;
25323 }
25324 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25325 return resultobj;
25326 fail:
25327 return NULL;
25328 }
25329
25330
25331 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25332 PyObject *resultobj = 0;
25333 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25334 long *arg2 = (long *) 0 ;
25335 long *arg3 = (long *) 0 ;
25336 void *argp1 = 0 ;
25337 int res1 = 0 ;
25338 long temp2 ;
25339 int res2 = SWIG_TMPOBJ ;
25340 long temp3 ;
25341 int res3 = SWIG_TMPOBJ ;
25342 PyObject *swig_obj[1] ;
25343
25344 arg2 = &temp2;
25345 arg3 = &temp3;
25346 if (!args) SWIG_fail;
25347 swig_obj[0] = args;
25348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25349 if (!SWIG_IsOK(res1)) {
25350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25351 }
25352 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25353 {
25354 PyThreadState* __tstate = wxPyBeginAllowThreads();
25355 (arg1)->GetPosition(arg2,arg3);
25356 wxPyEndAllowThreads(__tstate);
25357 if (PyErr_Occurred()) SWIG_fail;
25358 }
25359 resultobj = SWIG_Py_Void();
25360 if (SWIG_IsTmpObj(res2)) {
25361 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
25362 } else {
25363 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25364 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
25365 }
25366 if (SWIG_IsTmpObj(res3)) {
25367 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
25368 } else {
25369 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25370 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
25371 }
25372 return resultobj;
25373 fail:
25374 return NULL;
25375 }
25376
25377
25378 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25379 PyObject *resultobj = 0;
25380 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25381 int result;
25382 void *argp1 = 0 ;
25383 int res1 = 0 ;
25384 PyObject *swig_obj[1] ;
25385
25386 if (!args) SWIG_fail;
25387 swig_obj[0] = args;
25388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25389 if (!SWIG_IsOK(res1)) {
25390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25391 }
25392 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25393 {
25394 PyThreadState* __tstate = wxPyBeginAllowThreads();
25395 result = (int)((wxKeyEvent const *)arg1)->GetX();
25396 wxPyEndAllowThreads(__tstate);
25397 if (PyErr_Occurred()) SWIG_fail;
25398 }
25399 resultobj = SWIG_From_int(static_cast< int >(result));
25400 return resultobj;
25401 fail:
25402 return NULL;
25403 }
25404
25405
25406 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25407 PyObject *resultobj = 0;
25408 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25409 int result;
25410 void *argp1 = 0 ;
25411 int res1 = 0 ;
25412 PyObject *swig_obj[1] ;
25413
25414 if (!args) SWIG_fail;
25415 swig_obj[0] = args;
25416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25417 if (!SWIG_IsOK(res1)) {
25418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25419 }
25420 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25421 {
25422 PyThreadState* __tstate = wxPyBeginAllowThreads();
25423 result = (int)((wxKeyEvent const *)arg1)->GetY();
25424 wxPyEndAllowThreads(__tstate);
25425 if (PyErr_Occurred()) SWIG_fail;
25426 }
25427 resultobj = SWIG_From_int(static_cast< int >(result));
25428 return resultobj;
25429 fail:
25430 return NULL;
25431 }
25432
25433
25434 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25435 PyObject *resultobj = 0;
25436 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25437 int arg2 ;
25438 void *argp1 = 0 ;
25439 int res1 = 0 ;
25440 int val2 ;
25441 int ecode2 = 0 ;
25442 PyObject *swig_obj[2] ;
25443
25444 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
25445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25446 if (!SWIG_IsOK(res1)) {
25447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25448 }
25449 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25450 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25451 if (!SWIG_IsOK(ecode2)) {
25452 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
25453 }
25454 arg2 = static_cast< int >(val2);
25455 if (arg1) (arg1)->m_x = arg2;
25456
25457 resultobj = SWIG_Py_Void();
25458 return resultobj;
25459 fail:
25460 return NULL;
25461 }
25462
25463
25464 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25465 PyObject *resultobj = 0;
25466 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25467 int result;
25468 void *argp1 = 0 ;
25469 int res1 = 0 ;
25470 PyObject *swig_obj[1] ;
25471
25472 if (!args) SWIG_fail;
25473 swig_obj[0] = args;
25474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25475 if (!SWIG_IsOK(res1)) {
25476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25477 }
25478 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25479 result = (int) ((arg1)->m_x);
25480 resultobj = SWIG_From_int(static_cast< int >(result));
25481 return resultobj;
25482 fail:
25483 return NULL;
25484 }
25485
25486
25487 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25488 PyObject *resultobj = 0;
25489 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25490 int arg2 ;
25491 void *argp1 = 0 ;
25492 int res1 = 0 ;
25493 int val2 ;
25494 int ecode2 = 0 ;
25495 PyObject *swig_obj[2] ;
25496
25497 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
25498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25499 if (!SWIG_IsOK(res1)) {
25500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25501 }
25502 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25503 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25504 if (!SWIG_IsOK(ecode2)) {
25505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
25506 }
25507 arg2 = static_cast< int >(val2);
25508 if (arg1) (arg1)->m_y = arg2;
25509
25510 resultobj = SWIG_Py_Void();
25511 return resultobj;
25512 fail:
25513 return NULL;
25514 }
25515
25516
25517 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25518 PyObject *resultobj = 0;
25519 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25520 int result;
25521 void *argp1 = 0 ;
25522 int res1 = 0 ;
25523 PyObject *swig_obj[1] ;
25524
25525 if (!args) SWIG_fail;
25526 swig_obj[0] = args;
25527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25528 if (!SWIG_IsOK(res1)) {
25529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25530 }
25531 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25532 result = (int) ((arg1)->m_y);
25533 resultobj = SWIG_From_int(static_cast< int >(result));
25534 return resultobj;
25535 fail:
25536 return NULL;
25537 }
25538
25539
25540 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25541 PyObject *resultobj = 0;
25542 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25543 long arg2 ;
25544 void *argp1 = 0 ;
25545 int res1 = 0 ;
25546 long val2 ;
25547 int ecode2 = 0 ;
25548 PyObject *swig_obj[2] ;
25549
25550 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
25551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25552 if (!SWIG_IsOK(res1)) {
25553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25554 }
25555 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25556 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
25557 if (!SWIG_IsOK(ecode2)) {
25558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
25559 }
25560 arg2 = static_cast< long >(val2);
25561 if (arg1) (arg1)->m_keyCode = arg2;
25562
25563 resultobj = SWIG_Py_Void();
25564 return resultobj;
25565 fail:
25566 return NULL;
25567 }
25568
25569
25570 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25571 PyObject *resultobj = 0;
25572 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25573 long result;
25574 void *argp1 = 0 ;
25575 int res1 = 0 ;
25576 PyObject *swig_obj[1] ;
25577
25578 if (!args) SWIG_fail;
25579 swig_obj[0] = args;
25580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25581 if (!SWIG_IsOK(res1)) {
25582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25583 }
25584 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25585 result = (long) ((arg1)->m_keyCode);
25586 resultobj = SWIG_From_long(static_cast< long >(result));
25587 return resultobj;
25588 fail:
25589 return NULL;
25590 }
25591
25592
25593 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25594 PyObject *resultobj = 0;
25595 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25596 bool arg2 ;
25597 void *argp1 = 0 ;
25598 int res1 = 0 ;
25599 bool val2 ;
25600 int ecode2 = 0 ;
25601 PyObject *swig_obj[2] ;
25602
25603 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
25604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25605 if (!SWIG_IsOK(res1)) {
25606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25607 }
25608 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25609 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25610 if (!SWIG_IsOK(ecode2)) {
25611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
25612 }
25613 arg2 = static_cast< bool >(val2);
25614 if (arg1) (arg1)->m_controlDown = arg2;
25615
25616 resultobj = SWIG_Py_Void();
25617 return resultobj;
25618 fail:
25619 return NULL;
25620 }
25621
25622
25623 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25624 PyObject *resultobj = 0;
25625 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25626 bool result;
25627 void *argp1 = 0 ;
25628 int res1 = 0 ;
25629 PyObject *swig_obj[1] ;
25630
25631 if (!args) SWIG_fail;
25632 swig_obj[0] = args;
25633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25634 if (!SWIG_IsOK(res1)) {
25635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25636 }
25637 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25638 result = (bool) ((arg1)->m_controlDown);
25639 {
25640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25641 }
25642 return resultobj;
25643 fail:
25644 return NULL;
25645 }
25646
25647
25648 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25649 PyObject *resultobj = 0;
25650 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25651 bool arg2 ;
25652 void *argp1 = 0 ;
25653 int res1 = 0 ;
25654 bool val2 ;
25655 int ecode2 = 0 ;
25656 PyObject *swig_obj[2] ;
25657
25658 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
25659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25660 if (!SWIG_IsOK(res1)) {
25661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25662 }
25663 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25664 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25665 if (!SWIG_IsOK(ecode2)) {
25666 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
25667 }
25668 arg2 = static_cast< bool >(val2);
25669 if (arg1) (arg1)->m_shiftDown = arg2;
25670
25671 resultobj = SWIG_Py_Void();
25672 return resultobj;
25673 fail:
25674 return NULL;
25675 }
25676
25677
25678 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25679 PyObject *resultobj = 0;
25680 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25681 bool result;
25682 void *argp1 = 0 ;
25683 int res1 = 0 ;
25684 PyObject *swig_obj[1] ;
25685
25686 if (!args) SWIG_fail;
25687 swig_obj[0] = args;
25688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25689 if (!SWIG_IsOK(res1)) {
25690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25691 }
25692 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25693 result = (bool) ((arg1)->m_shiftDown);
25694 {
25695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25696 }
25697 return resultobj;
25698 fail:
25699 return NULL;
25700 }
25701
25702
25703 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25704 PyObject *resultobj = 0;
25705 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25706 bool arg2 ;
25707 void *argp1 = 0 ;
25708 int res1 = 0 ;
25709 bool val2 ;
25710 int ecode2 = 0 ;
25711 PyObject *swig_obj[2] ;
25712
25713 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
25714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25715 if (!SWIG_IsOK(res1)) {
25716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25717 }
25718 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25719 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25720 if (!SWIG_IsOK(ecode2)) {
25721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
25722 }
25723 arg2 = static_cast< bool >(val2);
25724 if (arg1) (arg1)->m_altDown = arg2;
25725
25726 resultobj = SWIG_Py_Void();
25727 return resultobj;
25728 fail:
25729 return NULL;
25730 }
25731
25732
25733 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25734 PyObject *resultobj = 0;
25735 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25736 bool 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_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25746 }
25747 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25748 result = (bool) ((arg1)->m_altDown);
25749 {
25750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25751 }
25752 return resultobj;
25753 fail:
25754 return NULL;
25755 }
25756
25757
25758 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25759 PyObject *resultobj = 0;
25760 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25761 bool arg2 ;
25762 void *argp1 = 0 ;
25763 int res1 = 0 ;
25764 bool val2 ;
25765 int ecode2 = 0 ;
25766 PyObject *swig_obj[2] ;
25767
25768 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
25769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25770 if (!SWIG_IsOK(res1)) {
25771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25772 }
25773 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25774 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25775 if (!SWIG_IsOK(ecode2)) {
25776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
25777 }
25778 arg2 = static_cast< bool >(val2);
25779 if (arg1) (arg1)->m_metaDown = arg2;
25780
25781 resultobj = SWIG_Py_Void();
25782 return resultobj;
25783 fail:
25784 return NULL;
25785 }
25786
25787
25788 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25789 PyObject *resultobj = 0;
25790 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25791 bool result;
25792 void *argp1 = 0 ;
25793 int res1 = 0 ;
25794 PyObject *swig_obj[1] ;
25795
25796 if (!args) SWIG_fail;
25797 swig_obj[0] = args;
25798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25799 if (!SWIG_IsOK(res1)) {
25800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25801 }
25802 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25803 result = (bool) ((arg1)->m_metaDown);
25804 {
25805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25806 }
25807 return resultobj;
25808 fail:
25809 return NULL;
25810 }
25811
25812
25813 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25814 PyObject *resultobj = 0;
25815 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25816 bool arg2 ;
25817 void *argp1 = 0 ;
25818 int res1 = 0 ;
25819 bool val2 ;
25820 int ecode2 = 0 ;
25821 PyObject *swig_obj[2] ;
25822
25823 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
25824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25825 if (!SWIG_IsOK(res1)) {
25826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25827 }
25828 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25829 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25830 if (!SWIG_IsOK(ecode2)) {
25831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
25832 }
25833 arg2 = static_cast< bool >(val2);
25834 if (arg1) (arg1)->m_scanCode = arg2;
25835
25836 resultobj = SWIG_Py_Void();
25837 return resultobj;
25838 fail:
25839 return NULL;
25840 }
25841
25842
25843 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25844 PyObject *resultobj = 0;
25845 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25846 bool result;
25847 void *argp1 = 0 ;
25848 int res1 = 0 ;
25849 PyObject *swig_obj[1] ;
25850
25851 if (!args) SWIG_fail;
25852 swig_obj[0] = args;
25853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25854 if (!SWIG_IsOK(res1)) {
25855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25856 }
25857 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25858 result = (bool) ((arg1)->m_scanCode);
25859 {
25860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25861 }
25862 return resultobj;
25863 fail:
25864 return NULL;
25865 }
25866
25867
25868 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25869 PyObject *resultobj = 0;
25870 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25871 unsigned int arg2 ;
25872 void *argp1 = 0 ;
25873 int res1 = 0 ;
25874 unsigned int val2 ;
25875 int ecode2 = 0 ;
25876 PyObject *swig_obj[2] ;
25877
25878 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
25879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25880 if (!SWIG_IsOK(res1)) {
25881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25882 }
25883 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25884 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25885 if (!SWIG_IsOK(ecode2)) {
25886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
25887 }
25888 arg2 = static_cast< unsigned int >(val2);
25889 if (arg1) (arg1)->m_rawCode = arg2;
25890
25891 resultobj = SWIG_Py_Void();
25892 return resultobj;
25893 fail:
25894 return NULL;
25895 }
25896
25897
25898 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25899 PyObject *resultobj = 0;
25900 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25901 unsigned int result;
25902 void *argp1 = 0 ;
25903 int res1 = 0 ;
25904 PyObject *swig_obj[1] ;
25905
25906 if (!args) SWIG_fail;
25907 swig_obj[0] = args;
25908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25909 if (!SWIG_IsOK(res1)) {
25910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25911 }
25912 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25913 result = (unsigned int) ((arg1)->m_rawCode);
25914 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25915 return resultobj;
25916 fail:
25917 return NULL;
25918 }
25919
25920
25921 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25922 PyObject *resultobj = 0;
25923 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25924 unsigned int arg2 ;
25925 void *argp1 = 0 ;
25926 int res1 = 0 ;
25927 unsigned int val2 ;
25928 int ecode2 = 0 ;
25929 PyObject *swig_obj[2] ;
25930
25931 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
25932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25933 if (!SWIG_IsOK(res1)) {
25934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25935 }
25936 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25937 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25938 if (!SWIG_IsOK(ecode2)) {
25939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
25940 }
25941 arg2 = static_cast< unsigned int >(val2);
25942 if (arg1) (arg1)->m_rawFlags = arg2;
25943
25944 resultobj = SWIG_Py_Void();
25945 return resultobj;
25946 fail:
25947 return NULL;
25948 }
25949
25950
25951 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25952 PyObject *resultobj = 0;
25953 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25954 unsigned int result;
25955 void *argp1 = 0 ;
25956 int res1 = 0 ;
25957 PyObject *swig_obj[1] ;
25958
25959 if (!args) SWIG_fail;
25960 swig_obj[0] = args;
25961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25962 if (!SWIG_IsOK(res1)) {
25963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25964 }
25965 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25966 result = (unsigned int) ((arg1)->m_rawFlags);
25967 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25968 return resultobj;
25969 fail:
25970 return NULL;
25971 }
25972
25973
25974 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25975 PyObject *obj;
25976 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25977 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
25978 return SWIG_Py_Void();
25979 }
25980
25981 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25982 return SWIG_Python_InitShadowInstance(args);
25983 }
25984
25985 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25986 PyObject *resultobj = 0;
25987 wxSize const &arg1_defvalue = wxDefaultSize ;
25988 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
25989 int arg2 = (int) 0 ;
25990 wxSizeEvent *result = 0 ;
25991 wxSize temp1 ;
25992 int val2 ;
25993 int ecode2 = 0 ;
25994 PyObject * obj0 = 0 ;
25995 PyObject * obj1 = 0 ;
25996 char * kwnames[] = {
25997 (char *) "sz",(char *) "winid", NULL
25998 };
25999
26000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26001 if (obj0) {
26002 {
26003 arg1 = &temp1;
26004 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
26005 }
26006 }
26007 if (obj1) {
26008 ecode2 = SWIG_AsVal_int(obj1, &val2);
26009 if (!SWIG_IsOK(ecode2)) {
26010 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
26011 }
26012 arg2 = static_cast< int >(val2);
26013 }
26014 {
26015 PyThreadState* __tstate = wxPyBeginAllowThreads();
26016 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
26017 wxPyEndAllowThreads(__tstate);
26018 if (PyErr_Occurred()) SWIG_fail;
26019 }
26020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
26021 return resultobj;
26022 fail:
26023 return NULL;
26024 }
26025
26026
26027 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26028 PyObject *resultobj = 0;
26029 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26030 wxSize result;
26031 void *argp1 = 0 ;
26032 int res1 = 0 ;
26033 PyObject *swig_obj[1] ;
26034
26035 if (!args) SWIG_fail;
26036 swig_obj[0] = args;
26037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26038 if (!SWIG_IsOK(res1)) {
26039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
26040 }
26041 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26042 {
26043 PyThreadState* __tstate = wxPyBeginAllowThreads();
26044 result = ((wxSizeEvent const *)arg1)->GetSize();
26045 wxPyEndAllowThreads(__tstate);
26046 if (PyErr_Occurred()) SWIG_fail;
26047 }
26048 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
26049 return resultobj;
26050 fail:
26051 return NULL;
26052 }
26053
26054
26055 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26056 PyObject *resultobj = 0;
26057 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26058 wxRect result;
26059 void *argp1 = 0 ;
26060 int res1 = 0 ;
26061 PyObject *swig_obj[1] ;
26062
26063 if (!args) SWIG_fail;
26064 swig_obj[0] = args;
26065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26066 if (!SWIG_IsOK(res1)) {
26067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
26068 }
26069 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26070 {
26071 PyThreadState* __tstate = wxPyBeginAllowThreads();
26072 result = ((wxSizeEvent const *)arg1)->GetRect();
26073 wxPyEndAllowThreads(__tstate);
26074 if (PyErr_Occurred()) SWIG_fail;
26075 }
26076 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26077 return resultobj;
26078 fail:
26079 return NULL;
26080 }
26081
26082
26083 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26084 PyObject *resultobj = 0;
26085 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26086 wxRect arg2 ;
26087 void *argp1 = 0 ;
26088 int res1 = 0 ;
26089 void *argp2 ;
26090 int res2 = 0 ;
26091 PyObject * obj0 = 0 ;
26092 PyObject * obj1 = 0 ;
26093 char * kwnames[] = {
26094 (char *) "self",(char *) "rect", NULL
26095 };
26096
26097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26099 if (!SWIG_IsOK(res1)) {
26100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26101 }
26102 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26103 {
26104 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
26105 if (!SWIG_IsOK(res2)) {
26106 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26107 }
26108 if (!argp2) {
26109 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26110 } else {
26111 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
26112 arg2 = *temp;
26113 if (SWIG_IsNewObj(res2)) delete temp;
26114 }
26115 }
26116 {
26117 PyThreadState* __tstate = wxPyBeginAllowThreads();
26118 (arg1)->SetRect(arg2);
26119 wxPyEndAllowThreads(__tstate);
26120 if (PyErr_Occurred()) SWIG_fail;
26121 }
26122 resultobj = SWIG_Py_Void();
26123 return resultobj;
26124 fail:
26125 return NULL;
26126 }
26127
26128
26129 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26130 PyObject *resultobj = 0;
26131 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26132 wxSize arg2 ;
26133 void *argp1 = 0 ;
26134 int res1 = 0 ;
26135 void *argp2 ;
26136 int res2 = 0 ;
26137 PyObject * obj0 = 0 ;
26138 PyObject * obj1 = 0 ;
26139 char * kwnames[] = {
26140 (char *) "self",(char *) "size", NULL
26141 };
26142
26143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
26144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26145 if (!SWIG_IsOK(res1)) {
26146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26147 }
26148 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26149 {
26150 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
26151 if (!SWIG_IsOK(res2)) {
26152 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26153 }
26154 if (!argp2) {
26155 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26156 } else {
26157 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
26158 arg2 = *temp;
26159 if (SWIG_IsNewObj(res2)) delete temp;
26160 }
26161 }
26162 {
26163 PyThreadState* __tstate = wxPyBeginAllowThreads();
26164 wxSizeEvent_SetSize(arg1,arg2);
26165 wxPyEndAllowThreads(__tstate);
26166 if (PyErr_Occurred()) SWIG_fail;
26167 }
26168 resultobj = SWIG_Py_Void();
26169 return resultobj;
26170 fail:
26171 return NULL;
26172 }
26173
26174
26175 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26176 PyObject *resultobj = 0;
26177 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26178 wxSize *arg2 = (wxSize *) 0 ;
26179 void *argp1 = 0 ;
26180 int res1 = 0 ;
26181 void *argp2 = 0 ;
26182 int res2 = 0 ;
26183 PyObject *swig_obj[2] ;
26184
26185 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
26186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26187 if (!SWIG_IsOK(res1)) {
26188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26189 }
26190 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26191 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
26192 if (!SWIG_IsOK(res2)) {
26193 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
26194 }
26195 arg2 = reinterpret_cast< wxSize * >(argp2);
26196 if (arg1) (arg1)->m_size = *arg2;
26197
26198 resultobj = SWIG_Py_Void();
26199 return resultobj;
26200 fail:
26201 return NULL;
26202 }
26203
26204
26205 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26206 PyObject *resultobj = 0;
26207 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26208 wxSize *result = 0 ;
26209 void *argp1 = 0 ;
26210 int res1 = 0 ;
26211 PyObject *swig_obj[1] ;
26212
26213 if (!args) SWIG_fail;
26214 swig_obj[0] = args;
26215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26216 if (!SWIG_IsOK(res1)) {
26217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26218 }
26219 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26220 result = (wxSize *)& ((arg1)->m_size);
26221 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
26222 return resultobj;
26223 fail:
26224 return NULL;
26225 }
26226
26227
26228 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26229 PyObject *resultobj = 0;
26230 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26231 wxRect *arg2 = (wxRect *) 0 ;
26232 void *argp1 = 0 ;
26233 int res1 = 0 ;
26234 void *argp2 = 0 ;
26235 int res2 = 0 ;
26236 PyObject *swig_obj[2] ;
26237
26238 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
26239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26240 if (!SWIG_IsOK(res1)) {
26241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26242 }
26243 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26244 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
26245 if (!SWIG_IsOK(res2)) {
26246 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
26247 }
26248 arg2 = reinterpret_cast< wxRect * >(argp2);
26249 if (arg1) (arg1)->m_rect = *arg2;
26250
26251 resultobj = SWIG_Py_Void();
26252 return resultobj;
26253 fail:
26254 return NULL;
26255 }
26256
26257
26258 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26259 PyObject *resultobj = 0;
26260 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26261 wxRect *result = 0 ;
26262 void *argp1 = 0 ;
26263 int res1 = 0 ;
26264 PyObject *swig_obj[1] ;
26265
26266 if (!args) SWIG_fail;
26267 swig_obj[0] = args;
26268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26269 if (!SWIG_IsOK(res1)) {
26270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26271 }
26272 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26273 result = (wxRect *)& ((arg1)->m_rect);
26274 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
26275 return resultobj;
26276 fail:
26277 return NULL;
26278 }
26279
26280
26281 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26282 PyObject *obj;
26283 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26284 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
26285 return SWIG_Py_Void();
26286 }
26287
26288 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26289 return SWIG_Python_InitShadowInstance(args);
26290 }
26291
26292 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26293 PyObject *resultobj = 0;
26294 wxPoint const &arg1_defvalue = wxDefaultPosition ;
26295 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
26296 int arg2 = (int) 0 ;
26297 wxMoveEvent *result = 0 ;
26298 wxPoint temp1 ;
26299 int val2 ;
26300 int ecode2 = 0 ;
26301 PyObject * obj0 = 0 ;
26302 PyObject * obj1 = 0 ;
26303 char * kwnames[] = {
26304 (char *) "pos",(char *) "winid", NULL
26305 };
26306
26307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26308 if (obj0) {
26309 {
26310 arg1 = &temp1;
26311 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
26312 }
26313 }
26314 if (obj1) {
26315 ecode2 = SWIG_AsVal_int(obj1, &val2);
26316 if (!SWIG_IsOK(ecode2)) {
26317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
26318 }
26319 arg2 = static_cast< int >(val2);
26320 }
26321 {
26322 PyThreadState* __tstate = wxPyBeginAllowThreads();
26323 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
26324 wxPyEndAllowThreads(__tstate);
26325 if (PyErr_Occurred()) SWIG_fail;
26326 }
26327 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
26328 return resultobj;
26329 fail:
26330 return NULL;
26331 }
26332
26333
26334 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26335 PyObject *resultobj = 0;
26336 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26337 wxPoint result;
26338 void *argp1 = 0 ;
26339 int res1 = 0 ;
26340 PyObject *swig_obj[1] ;
26341
26342 if (!args) SWIG_fail;
26343 swig_obj[0] = args;
26344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26345 if (!SWIG_IsOK(res1)) {
26346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26347 }
26348 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26349 {
26350 PyThreadState* __tstate = wxPyBeginAllowThreads();
26351 result = ((wxMoveEvent const *)arg1)->GetPosition();
26352 wxPyEndAllowThreads(__tstate);
26353 if (PyErr_Occurred()) SWIG_fail;
26354 }
26355 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
26356 return resultobj;
26357 fail:
26358 return NULL;
26359 }
26360
26361
26362 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26363 PyObject *resultobj = 0;
26364 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26365 wxRect result;
26366 void *argp1 = 0 ;
26367 int res1 = 0 ;
26368 PyObject *swig_obj[1] ;
26369
26370 if (!args) SWIG_fail;
26371 swig_obj[0] = args;
26372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26373 if (!SWIG_IsOK(res1)) {
26374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26375 }
26376 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26377 {
26378 PyThreadState* __tstate = wxPyBeginAllowThreads();
26379 result = ((wxMoveEvent const *)arg1)->GetRect();
26380 wxPyEndAllowThreads(__tstate);
26381 if (PyErr_Occurred()) SWIG_fail;
26382 }
26383 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26384 return resultobj;
26385 fail:
26386 return NULL;
26387 }
26388
26389
26390 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26391 PyObject *resultobj = 0;
26392 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26393 wxRect *arg2 = 0 ;
26394 void *argp1 = 0 ;
26395 int res1 = 0 ;
26396 wxRect temp2 ;
26397 PyObject * obj0 = 0 ;
26398 PyObject * obj1 = 0 ;
26399 char * kwnames[] = {
26400 (char *) "self",(char *) "rect", NULL
26401 };
26402
26403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26405 if (!SWIG_IsOK(res1)) {
26406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26407 }
26408 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26409 {
26410 arg2 = &temp2;
26411 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26412 }
26413 {
26414 PyThreadState* __tstate = wxPyBeginAllowThreads();
26415 (arg1)->SetRect((wxRect const &)*arg2);
26416 wxPyEndAllowThreads(__tstate);
26417 if (PyErr_Occurred()) SWIG_fail;
26418 }
26419 resultobj = SWIG_Py_Void();
26420 return resultobj;
26421 fail:
26422 return NULL;
26423 }
26424
26425
26426 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26427 PyObject *resultobj = 0;
26428 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26429 wxPoint *arg2 = 0 ;
26430 void *argp1 = 0 ;
26431 int res1 = 0 ;
26432 wxPoint temp2 ;
26433 PyObject * obj0 = 0 ;
26434 PyObject * obj1 = 0 ;
26435 char * kwnames[] = {
26436 (char *) "self",(char *) "pos", NULL
26437 };
26438
26439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26441 if (!SWIG_IsOK(res1)) {
26442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26443 }
26444 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26445 {
26446 arg2 = &temp2;
26447 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26448 }
26449 {
26450 PyThreadState* __tstate = wxPyBeginAllowThreads();
26451 (arg1)->SetPosition((wxPoint const &)*arg2);
26452 wxPyEndAllowThreads(__tstate);
26453 if (PyErr_Occurred()) SWIG_fail;
26454 }
26455 resultobj = SWIG_Py_Void();
26456 return resultobj;
26457 fail:
26458 return NULL;
26459 }
26460
26461
26462 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26463 PyObject *obj;
26464 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26465 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
26466 return SWIG_Py_Void();
26467 }
26468
26469 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26470 return SWIG_Python_InitShadowInstance(args);
26471 }
26472
26473 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26474 PyObject *resultobj = 0;
26475 int arg1 = (int) 0 ;
26476 wxPaintEvent *result = 0 ;
26477 int val1 ;
26478 int ecode1 = 0 ;
26479 PyObject * obj0 = 0 ;
26480 char * kwnames[] = {
26481 (char *) "Id", NULL
26482 };
26483
26484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
26485 if (obj0) {
26486 ecode1 = SWIG_AsVal_int(obj0, &val1);
26487 if (!SWIG_IsOK(ecode1)) {
26488 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
26489 }
26490 arg1 = static_cast< int >(val1);
26491 }
26492 {
26493 PyThreadState* __tstate = wxPyBeginAllowThreads();
26494 result = (wxPaintEvent *)new wxPaintEvent(arg1);
26495 wxPyEndAllowThreads(__tstate);
26496 if (PyErr_Occurred()) SWIG_fail;
26497 }
26498 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
26499 return resultobj;
26500 fail:
26501 return NULL;
26502 }
26503
26504
26505 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26506 PyObject *obj;
26507 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26508 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
26509 return SWIG_Py_Void();
26510 }
26511
26512 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26513 return SWIG_Python_InitShadowInstance(args);
26514 }
26515
26516 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26517 PyObject *resultobj = 0;
26518 int arg1 = (int) 0 ;
26519 wxNcPaintEvent *result = 0 ;
26520 int val1 ;
26521 int ecode1 = 0 ;
26522 PyObject * obj0 = 0 ;
26523 char * kwnames[] = {
26524 (char *) "winid", NULL
26525 };
26526
26527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
26528 if (obj0) {
26529 ecode1 = SWIG_AsVal_int(obj0, &val1);
26530 if (!SWIG_IsOK(ecode1)) {
26531 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
26532 }
26533 arg1 = static_cast< int >(val1);
26534 }
26535 {
26536 PyThreadState* __tstate = wxPyBeginAllowThreads();
26537 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
26538 wxPyEndAllowThreads(__tstate);
26539 if (PyErr_Occurred()) SWIG_fail;
26540 }
26541 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
26542 return resultobj;
26543 fail:
26544 return NULL;
26545 }
26546
26547
26548 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26549 PyObject *obj;
26550 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26551 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
26552 return SWIG_Py_Void();
26553 }
26554
26555 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26556 return SWIG_Python_InitShadowInstance(args);
26557 }
26558
26559 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26560 PyObject *resultobj = 0;
26561 int arg1 = (int) 0 ;
26562 wxDC *arg2 = (wxDC *) NULL ;
26563 wxEraseEvent *result = 0 ;
26564 int val1 ;
26565 int ecode1 = 0 ;
26566 void *argp2 = 0 ;
26567 int res2 = 0 ;
26568 PyObject * obj0 = 0 ;
26569 PyObject * obj1 = 0 ;
26570 char * kwnames[] = {
26571 (char *) "Id",(char *) "dc", NULL
26572 };
26573
26574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26575 if (obj0) {
26576 ecode1 = SWIG_AsVal_int(obj0, &val1);
26577 if (!SWIG_IsOK(ecode1)) {
26578 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
26579 }
26580 arg1 = static_cast< int >(val1);
26581 }
26582 if (obj1) {
26583 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
26584 if (!SWIG_IsOK(res2)) {
26585 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
26586 }
26587 arg2 = reinterpret_cast< wxDC * >(argp2);
26588 }
26589 {
26590 PyThreadState* __tstate = wxPyBeginAllowThreads();
26591 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
26592 wxPyEndAllowThreads(__tstate);
26593 if (PyErr_Occurred()) SWIG_fail;
26594 }
26595 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
26596 return resultobj;
26597 fail:
26598 return NULL;
26599 }
26600
26601
26602 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26603 PyObject *resultobj = 0;
26604 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
26605 wxDC *result = 0 ;
26606 void *argp1 = 0 ;
26607 int res1 = 0 ;
26608 PyObject *swig_obj[1] ;
26609
26610 if (!args) SWIG_fail;
26611 swig_obj[0] = args;
26612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
26613 if (!SWIG_IsOK(res1)) {
26614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
26615 }
26616 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
26617 {
26618 PyThreadState* __tstate = wxPyBeginAllowThreads();
26619 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
26620 wxPyEndAllowThreads(__tstate);
26621 if (PyErr_Occurred()) SWIG_fail;
26622 }
26623 {
26624 resultobj = wxPyMake_wxObject(result, (bool)0);
26625 }
26626 return resultobj;
26627 fail:
26628 return NULL;
26629 }
26630
26631
26632 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26633 PyObject *obj;
26634 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26635 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
26636 return SWIG_Py_Void();
26637 }
26638
26639 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26640 return SWIG_Python_InitShadowInstance(args);
26641 }
26642
26643 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26644 PyObject *resultobj = 0;
26645 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26646 int arg2 = (int) 0 ;
26647 wxFocusEvent *result = 0 ;
26648 int val1 ;
26649 int ecode1 = 0 ;
26650 int val2 ;
26651 int ecode2 = 0 ;
26652 PyObject * obj0 = 0 ;
26653 PyObject * obj1 = 0 ;
26654 char * kwnames[] = {
26655 (char *) "type",(char *) "winid", NULL
26656 };
26657
26658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26659 if (obj0) {
26660 ecode1 = SWIG_AsVal_int(obj0, &val1);
26661 if (!SWIG_IsOK(ecode1)) {
26662 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26663 }
26664 arg1 = static_cast< wxEventType >(val1);
26665 }
26666 if (obj1) {
26667 ecode2 = SWIG_AsVal_int(obj1, &val2);
26668 if (!SWIG_IsOK(ecode2)) {
26669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
26670 }
26671 arg2 = static_cast< int >(val2);
26672 }
26673 {
26674 PyThreadState* __tstate = wxPyBeginAllowThreads();
26675 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
26676 wxPyEndAllowThreads(__tstate);
26677 if (PyErr_Occurred()) SWIG_fail;
26678 }
26679 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
26680 return resultobj;
26681 fail:
26682 return NULL;
26683 }
26684
26685
26686 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26687 PyObject *resultobj = 0;
26688 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26689 wxWindow *result = 0 ;
26690 void *argp1 = 0 ;
26691 int res1 = 0 ;
26692 PyObject *swig_obj[1] ;
26693
26694 if (!args) SWIG_fail;
26695 swig_obj[0] = args;
26696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26697 if (!SWIG_IsOK(res1)) {
26698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
26699 }
26700 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26701 {
26702 PyThreadState* __tstate = wxPyBeginAllowThreads();
26703 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
26704 wxPyEndAllowThreads(__tstate);
26705 if (PyErr_Occurred()) SWIG_fail;
26706 }
26707 {
26708 resultobj = wxPyMake_wxObject(result, (bool)0);
26709 }
26710 return resultobj;
26711 fail:
26712 return NULL;
26713 }
26714
26715
26716 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26717 PyObject *resultobj = 0;
26718 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26719 wxWindow *arg2 = (wxWindow *) 0 ;
26720 void *argp1 = 0 ;
26721 int res1 = 0 ;
26722 void *argp2 = 0 ;
26723 int res2 = 0 ;
26724 PyObject * obj0 = 0 ;
26725 PyObject * obj1 = 0 ;
26726 char * kwnames[] = {
26727 (char *) "self",(char *) "win", NULL
26728 };
26729
26730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
26731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26732 if (!SWIG_IsOK(res1)) {
26733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
26734 }
26735 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26736 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26737 if (!SWIG_IsOK(res2)) {
26738 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
26739 }
26740 arg2 = reinterpret_cast< wxWindow * >(argp2);
26741 {
26742 PyThreadState* __tstate = wxPyBeginAllowThreads();
26743 (arg1)->SetWindow(arg2);
26744 wxPyEndAllowThreads(__tstate);
26745 if (PyErr_Occurred()) SWIG_fail;
26746 }
26747 resultobj = SWIG_Py_Void();
26748 return resultobj;
26749 fail:
26750 return NULL;
26751 }
26752
26753
26754 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26755 PyObject *obj;
26756 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26757 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
26758 return SWIG_Py_Void();
26759 }
26760
26761 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26762 return SWIG_Python_InitShadowInstance(args);
26763 }
26764
26765 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26766 PyObject *resultobj = 0;
26767 wxWindow *arg1 = (wxWindow *) NULL ;
26768 wxChildFocusEvent *result = 0 ;
26769 void *argp1 = 0 ;
26770 int res1 = 0 ;
26771 PyObject * obj0 = 0 ;
26772 char * kwnames[] = {
26773 (char *) "win", NULL
26774 };
26775
26776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
26777 if (obj0) {
26778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26779 if (!SWIG_IsOK(res1)) {
26780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26781 }
26782 arg1 = reinterpret_cast< wxWindow * >(argp1);
26783 }
26784 {
26785 PyThreadState* __tstate = wxPyBeginAllowThreads();
26786 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
26787 wxPyEndAllowThreads(__tstate);
26788 if (PyErr_Occurred()) SWIG_fail;
26789 }
26790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
26791 return resultobj;
26792 fail:
26793 return NULL;
26794 }
26795
26796
26797 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26798 PyObject *resultobj = 0;
26799 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
26800 wxWindow *result = 0 ;
26801 void *argp1 = 0 ;
26802 int res1 = 0 ;
26803 PyObject *swig_obj[1] ;
26804
26805 if (!args) SWIG_fail;
26806 swig_obj[0] = args;
26807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
26808 if (!SWIG_IsOK(res1)) {
26809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
26810 }
26811 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
26812 {
26813 PyThreadState* __tstate = wxPyBeginAllowThreads();
26814 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
26815 wxPyEndAllowThreads(__tstate);
26816 if (PyErr_Occurred()) SWIG_fail;
26817 }
26818 {
26819 resultobj = wxPyMake_wxObject(result, (bool)0);
26820 }
26821 return resultobj;
26822 fail:
26823 return NULL;
26824 }
26825
26826
26827 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26828 PyObject *obj;
26829 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26830 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
26831 return SWIG_Py_Void();
26832 }
26833
26834 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26835 return SWIG_Python_InitShadowInstance(args);
26836 }
26837
26838 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26839 PyObject *resultobj = 0;
26840 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26841 bool arg2 = (bool) true ;
26842 int arg3 = (int) 0 ;
26843 wxActivateEvent *result = 0 ;
26844 int val1 ;
26845 int ecode1 = 0 ;
26846 bool val2 ;
26847 int ecode2 = 0 ;
26848 int val3 ;
26849 int ecode3 = 0 ;
26850 PyObject * obj0 = 0 ;
26851 PyObject * obj1 = 0 ;
26852 PyObject * obj2 = 0 ;
26853 char * kwnames[] = {
26854 (char *) "type",(char *) "active",(char *) "Id", NULL
26855 };
26856
26857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26858 if (obj0) {
26859 ecode1 = SWIG_AsVal_int(obj0, &val1);
26860 if (!SWIG_IsOK(ecode1)) {
26861 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26862 }
26863 arg1 = static_cast< wxEventType >(val1);
26864 }
26865 if (obj1) {
26866 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26867 if (!SWIG_IsOK(ecode2)) {
26868 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
26869 }
26870 arg2 = static_cast< bool >(val2);
26871 }
26872 if (obj2) {
26873 ecode3 = SWIG_AsVal_int(obj2, &val3);
26874 if (!SWIG_IsOK(ecode3)) {
26875 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
26876 }
26877 arg3 = static_cast< int >(val3);
26878 }
26879 {
26880 PyThreadState* __tstate = wxPyBeginAllowThreads();
26881 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
26882 wxPyEndAllowThreads(__tstate);
26883 if (PyErr_Occurred()) SWIG_fail;
26884 }
26885 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
26886 return resultobj;
26887 fail:
26888 return NULL;
26889 }
26890
26891
26892 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26893 PyObject *resultobj = 0;
26894 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
26895 bool result;
26896 void *argp1 = 0 ;
26897 int res1 = 0 ;
26898 PyObject *swig_obj[1] ;
26899
26900 if (!args) SWIG_fail;
26901 swig_obj[0] = args;
26902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
26903 if (!SWIG_IsOK(res1)) {
26904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
26905 }
26906 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
26907 {
26908 PyThreadState* __tstate = wxPyBeginAllowThreads();
26909 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
26910 wxPyEndAllowThreads(__tstate);
26911 if (PyErr_Occurred()) SWIG_fail;
26912 }
26913 {
26914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26915 }
26916 return resultobj;
26917 fail:
26918 return NULL;
26919 }
26920
26921
26922 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26923 PyObject *obj;
26924 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26925 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
26926 return SWIG_Py_Void();
26927 }
26928
26929 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26930 return SWIG_Python_InitShadowInstance(args);
26931 }
26932
26933 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26934 PyObject *resultobj = 0;
26935 int arg1 = (int) 0 ;
26936 wxInitDialogEvent *result = 0 ;
26937 int val1 ;
26938 int ecode1 = 0 ;
26939 PyObject * obj0 = 0 ;
26940 char * kwnames[] = {
26941 (char *) "Id", NULL
26942 };
26943
26944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
26945 if (obj0) {
26946 ecode1 = SWIG_AsVal_int(obj0, &val1);
26947 if (!SWIG_IsOK(ecode1)) {
26948 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
26949 }
26950 arg1 = static_cast< int >(val1);
26951 }
26952 {
26953 PyThreadState* __tstate = wxPyBeginAllowThreads();
26954 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
26955 wxPyEndAllowThreads(__tstate);
26956 if (PyErr_Occurred()) SWIG_fail;
26957 }
26958 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
26959 return resultobj;
26960 fail:
26961 return NULL;
26962 }
26963
26964
26965 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26966 PyObject *obj;
26967 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26968 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
26969 return SWIG_Py_Void();
26970 }
26971
26972 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26973 return SWIG_Python_InitShadowInstance(args);
26974 }
26975
26976 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26977 PyObject *resultobj = 0;
26978 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26979 int arg2 = (int) 0 ;
26980 wxMenu *arg3 = (wxMenu *) NULL ;
26981 wxMenuEvent *result = 0 ;
26982 int val1 ;
26983 int ecode1 = 0 ;
26984 int val2 ;
26985 int ecode2 = 0 ;
26986 void *argp3 = 0 ;
26987 int res3 = 0 ;
26988 PyObject * obj0 = 0 ;
26989 PyObject * obj1 = 0 ;
26990 PyObject * obj2 = 0 ;
26991 char * kwnames[] = {
26992 (char *) "type",(char *) "winid",(char *) "menu", NULL
26993 };
26994
26995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26996 if (obj0) {
26997 ecode1 = SWIG_AsVal_int(obj0, &val1);
26998 if (!SWIG_IsOK(ecode1)) {
26999 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27000 }
27001 arg1 = static_cast< wxEventType >(val1);
27002 }
27003 if (obj1) {
27004 ecode2 = SWIG_AsVal_int(obj1, &val2);
27005 if (!SWIG_IsOK(ecode2)) {
27006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
27007 }
27008 arg2 = static_cast< int >(val2);
27009 }
27010 if (obj2) {
27011 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
27012 if (!SWIG_IsOK(res3)) {
27013 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
27014 }
27015 arg3 = reinterpret_cast< wxMenu * >(argp3);
27016 }
27017 {
27018 PyThreadState* __tstate = wxPyBeginAllowThreads();
27019 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
27020 wxPyEndAllowThreads(__tstate);
27021 if (PyErr_Occurred()) SWIG_fail;
27022 }
27023 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
27024 return resultobj;
27025 fail:
27026 return NULL;
27027 }
27028
27029
27030 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27031 PyObject *resultobj = 0;
27032 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27033 int result;
27034 void *argp1 = 0 ;
27035 int res1 = 0 ;
27036 PyObject *swig_obj[1] ;
27037
27038 if (!args) SWIG_fail;
27039 swig_obj[0] = args;
27040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27041 if (!SWIG_IsOK(res1)) {
27042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27043 }
27044 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27045 {
27046 PyThreadState* __tstate = wxPyBeginAllowThreads();
27047 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
27048 wxPyEndAllowThreads(__tstate);
27049 if (PyErr_Occurred()) SWIG_fail;
27050 }
27051 resultobj = SWIG_From_int(static_cast< int >(result));
27052 return resultobj;
27053 fail:
27054 return NULL;
27055 }
27056
27057
27058 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27059 PyObject *resultobj = 0;
27060 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27061 bool result;
27062 void *argp1 = 0 ;
27063 int res1 = 0 ;
27064 PyObject *swig_obj[1] ;
27065
27066 if (!args) SWIG_fail;
27067 swig_obj[0] = args;
27068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27069 if (!SWIG_IsOK(res1)) {
27070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27071 }
27072 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27073 {
27074 PyThreadState* __tstate = wxPyBeginAllowThreads();
27075 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
27076 wxPyEndAllowThreads(__tstate);
27077 if (PyErr_Occurred()) SWIG_fail;
27078 }
27079 {
27080 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27081 }
27082 return resultobj;
27083 fail:
27084 return NULL;
27085 }
27086
27087
27088 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27089 PyObject *resultobj = 0;
27090 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27091 wxMenu *result = 0 ;
27092 void *argp1 = 0 ;
27093 int res1 = 0 ;
27094 PyObject *swig_obj[1] ;
27095
27096 if (!args) SWIG_fail;
27097 swig_obj[0] = args;
27098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27099 if (!SWIG_IsOK(res1)) {
27100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27101 }
27102 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27103 {
27104 PyThreadState* __tstate = wxPyBeginAllowThreads();
27105 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
27106 wxPyEndAllowThreads(__tstate);
27107 if (PyErr_Occurred()) SWIG_fail;
27108 }
27109 {
27110 resultobj = wxPyMake_wxObject(result, (bool)0);
27111 }
27112 return resultobj;
27113 fail:
27114 return NULL;
27115 }
27116
27117
27118 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27119 PyObject *obj;
27120 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27121 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
27122 return SWIG_Py_Void();
27123 }
27124
27125 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27126 return SWIG_Python_InitShadowInstance(args);
27127 }
27128
27129 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27130 PyObject *resultobj = 0;
27131 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27132 int arg2 = (int) 0 ;
27133 wxCloseEvent *result = 0 ;
27134 int val1 ;
27135 int ecode1 = 0 ;
27136 int val2 ;
27137 int ecode2 = 0 ;
27138 PyObject * obj0 = 0 ;
27139 PyObject * obj1 = 0 ;
27140 char * kwnames[] = {
27141 (char *) "type",(char *) "winid", NULL
27142 };
27143
27144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27145 if (obj0) {
27146 ecode1 = SWIG_AsVal_int(obj0, &val1);
27147 if (!SWIG_IsOK(ecode1)) {
27148 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27149 }
27150 arg1 = static_cast< wxEventType >(val1);
27151 }
27152 if (obj1) {
27153 ecode2 = SWIG_AsVal_int(obj1, &val2);
27154 if (!SWIG_IsOK(ecode2)) {
27155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
27156 }
27157 arg2 = static_cast< int >(val2);
27158 }
27159 {
27160 PyThreadState* __tstate = wxPyBeginAllowThreads();
27161 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
27162 wxPyEndAllowThreads(__tstate);
27163 if (PyErr_Occurred()) SWIG_fail;
27164 }
27165 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
27166 return resultobj;
27167 fail:
27168 return NULL;
27169 }
27170
27171
27172 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27173 PyObject *resultobj = 0;
27174 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27175 bool arg2 ;
27176 void *argp1 = 0 ;
27177 int res1 = 0 ;
27178 bool val2 ;
27179 int ecode2 = 0 ;
27180 PyObject * obj0 = 0 ;
27181 PyObject * obj1 = 0 ;
27182 char * kwnames[] = {
27183 (char *) "self",(char *) "logOff", NULL
27184 };
27185
27186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
27187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27188 if (!SWIG_IsOK(res1)) {
27189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27190 }
27191 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27192 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27193 if (!SWIG_IsOK(ecode2)) {
27194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
27195 }
27196 arg2 = static_cast< bool >(val2);
27197 {
27198 PyThreadState* __tstate = wxPyBeginAllowThreads();
27199 (arg1)->SetLoggingOff(arg2);
27200 wxPyEndAllowThreads(__tstate);
27201 if (PyErr_Occurred()) SWIG_fail;
27202 }
27203 resultobj = SWIG_Py_Void();
27204 return resultobj;
27205 fail:
27206 return NULL;
27207 }
27208
27209
27210 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27211 PyObject *resultobj = 0;
27212 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27213 bool result;
27214 void *argp1 = 0 ;
27215 int res1 = 0 ;
27216 PyObject *swig_obj[1] ;
27217
27218 if (!args) SWIG_fail;
27219 swig_obj[0] = args;
27220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27221 if (!SWIG_IsOK(res1)) {
27222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27223 }
27224 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27225 {
27226 PyThreadState* __tstate = wxPyBeginAllowThreads();
27227 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
27228 wxPyEndAllowThreads(__tstate);
27229 if (PyErr_Occurred()) SWIG_fail;
27230 }
27231 {
27232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27233 }
27234 return resultobj;
27235 fail:
27236 return NULL;
27237 }
27238
27239
27240 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27241 PyObject *resultobj = 0;
27242 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27243 bool arg2 = (bool) true ;
27244 void *argp1 = 0 ;
27245 int res1 = 0 ;
27246 bool val2 ;
27247 int ecode2 = 0 ;
27248 PyObject * obj0 = 0 ;
27249 PyObject * obj1 = 0 ;
27250 char * kwnames[] = {
27251 (char *) "self",(char *) "veto", NULL
27252 };
27253
27254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
27255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27256 if (!SWIG_IsOK(res1)) {
27257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27258 }
27259 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27260 if (obj1) {
27261 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27262 if (!SWIG_IsOK(ecode2)) {
27263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
27264 }
27265 arg2 = static_cast< bool >(val2);
27266 }
27267 {
27268 PyThreadState* __tstate = wxPyBeginAllowThreads();
27269 (arg1)->Veto(arg2);
27270 wxPyEndAllowThreads(__tstate);
27271 if (PyErr_Occurred()) SWIG_fail;
27272 }
27273 resultobj = SWIG_Py_Void();
27274 return resultobj;
27275 fail:
27276 return NULL;
27277 }
27278
27279
27280 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27281 PyObject *resultobj = 0;
27282 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27283 bool result;
27284 void *argp1 = 0 ;
27285 int res1 = 0 ;
27286 PyObject *swig_obj[1] ;
27287
27288 if (!args) SWIG_fail;
27289 swig_obj[0] = args;
27290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27291 if (!SWIG_IsOK(res1)) {
27292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27293 }
27294 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27295 {
27296 PyThreadState* __tstate = wxPyBeginAllowThreads();
27297 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
27298 wxPyEndAllowThreads(__tstate);
27299 if (PyErr_Occurred()) SWIG_fail;
27300 }
27301 {
27302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27303 }
27304 return resultobj;
27305 fail:
27306 return NULL;
27307 }
27308
27309
27310 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27311 PyObject *resultobj = 0;
27312 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27313 bool arg2 ;
27314 void *argp1 = 0 ;
27315 int res1 = 0 ;
27316 bool val2 ;
27317 int ecode2 = 0 ;
27318 PyObject * obj0 = 0 ;
27319 PyObject * obj1 = 0 ;
27320 char * kwnames[] = {
27321 (char *) "self",(char *) "canVeto", NULL
27322 };
27323
27324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
27325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27326 if (!SWIG_IsOK(res1)) {
27327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27328 }
27329 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27330 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27331 if (!SWIG_IsOK(ecode2)) {
27332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
27333 }
27334 arg2 = static_cast< bool >(val2);
27335 {
27336 PyThreadState* __tstate = wxPyBeginAllowThreads();
27337 (arg1)->SetCanVeto(arg2);
27338 wxPyEndAllowThreads(__tstate);
27339 if (PyErr_Occurred()) SWIG_fail;
27340 }
27341 resultobj = SWIG_Py_Void();
27342 return resultobj;
27343 fail:
27344 return NULL;
27345 }
27346
27347
27348 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27349 PyObject *resultobj = 0;
27350 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27351 bool result;
27352 void *argp1 = 0 ;
27353 int res1 = 0 ;
27354 PyObject *swig_obj[1] ;
27355
27356 if (!args) SWIG_fail;
27357 swig_obj[0] = args;
27358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27359 if (!SWIG_IsOK(res1)) {
27360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27361 }
27362 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27363 {
27364 PyThreadState* __tstate = wxPyBeginAllowThreads();
27365 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
27366 wxPyEndAllowThreads(__tstate);
27367 if (PyErr_Occurred()) SWIG_fail;
27368 }
27369 {
27370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27371 }
27372 return resultobj;
27373 fail:
27374 return NULL;
27375 }
27376
27377
27378 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27379 PyObject *obj;
27380 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27381 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
27382 return SWIG_Py_Void();
27383 }
27384
27385 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27386 return SWIG_Python_InitShadowInstance(args);
27387 }
27388
27389 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27390 PyObject *resultobj = 0;
27391 int arg1 = (int) 0 ;
27392 bool arg2 = (bool) false ;
27393 wxShowEvent *result = 0 ;
27394 int val1 ;
27395 int ecode1 = 0 ;
27396 bool val2 ;
27397 int ecode2 = 0 ;
27398 PyObject * obj0 = 0 ;
27399 PyObject * obj1 = 0 ;
27400 char * kwnames[] = {
27401 (char *) "winid",(char *) "show", NULL
27402 };
27403
27404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27405 if (obj0) {
27406 ecode1 = SWIG_AsVal_int(obj0, &val1);
27407 if (!SWIG_IsOK(ecode1)) {
27408 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
27409 }
27410 arg1 = static_cast< int >(val1);
27411 }
27412 if (obj1) {
27413 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27414 if (!SWIG_IsOK(ecode2)) {
27415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
27416 }
27417 arg2 = static_cast< bool >(val2);
27418 }
27419 {
27420 PyThreadState* __tstate = wxPyBeginAllowThreads();
27421 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
27422 wxPyEndAllowThreads(__tstate);
27423 if (PyErr_Occurred()) SWIG_fail;
27424 }
27425 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
27426 return resultobj;
27427 fail:
27428 return NULL;
27429 }
27430
27431
27432 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27433 PyObject *resultobj = 0;
27434 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27435 bool arg2 ;
27436 void *argp1 = 0 ;
27437 int res1 = 0 ;
27438 bool val2 ;
27439 int ecode2 = 0 ;
27440 PyObject * obj0 = 0 ;
27441 PyObject * obj1 = 0 ;
27442 char * kwnames[] = {
27443 (char *) "self",(char *) "show", NULL
27444 };
27445
27446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
27447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27448 if (!SWIG_IsOK(res1)) {
27449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
27450 }
27451 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27452 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27453 if (!SWIG_IsOK(ecode2)) {
27454 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
27455 }
27456 arg2 = static_cast< bool >(val2);
27457 {
27458 PyThreadState* __tstate = wxPyBeginAllowThreads();
27459 (arg1)->SetShow(arg2);
27460 wxPyEndAllowThreads(__tstate);
27461 if (PyErr_Occurred()) SWIG_fail;
27462 }
27463 resultobj = SWIG_Py_Void();
27464 return resultobj;
27465 fail:
27466 return NULL;
27467 }
27468
27469
27470 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27471 PyObject *resultobj = 0;
27472 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27473 bool result;
27474 void *argp1 = 0 ;
27475 int res1 = 0 ;
27476 PyObject *swig_obj[1] ;
27477
27478 if (!args) SWIG_fail;
27479 swig_obj[0] = args;
27480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27481 if (!SWIG_IsOK(res1)) {
27482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
27483 }
27484 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27485 {
27486 PyThreadState* __tstate = wxPyBeginAllowThreads();
27487 result = (bool)((wxShowEvent const *)arg1)->GetShow();
27488 wxPyEndAllowThreads(__tstate);
27489 if (PyErr_Occurred()) SWIG_fail;
27490 }
27491 {
27492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27493 }
27494 return resultobj;
27495 fail:
27496 return NULL;
27497 }
27498
27499
27500 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27501 PyObject *obj;
27502 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27503 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
27504 return SWIG_Py_Void();
27505 }
27506
27507 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27508 return SWIG_Python_InitShadowInstance(args);
27509 }
27510
27511 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27512 PyObject *resultobj = 0;
27513 int arg1 = (int) 0 ;
27514 bool arg2 = (bool) true ;
27515 wxIconizeEvent *result = 0 ;
27516 int val1 ;
27517 int ecode1 = 0 ;
27518 bool val2 ;
27519 int ecode2 = 0 ;
27520 PyObject * obj0 = 0 ;
27521 PyObject * obj1 = 0 ;
27522 char * kwnames[] = {
27523 (char *) "id",(char *) "iconized", NULL
27524 };
27525
27526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27527 if (obj0) {
27528 ecode1 = SWIG_AsVal_int(obj0, &val1);
27529 if (!SWIG_IsOK(ecode1)) {
27530 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
27531 }
27532 arg1 = static_cast< int >(val1);
27533 }
27534 if (obj1) {
27535 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27536 if (!SWIG_IsOK(ecode2)) {
27537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
27538 }
27539 arg2 = static_cast< bool >(val2);
27540 }
27541 {
27542 PyThreadState* __tstate = wxPyBeginAllowThreads();
27543 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
27544 wxPyEndAllowThreads(__tstate);
27545 if (PyErr_Occurred()) SWIG_fail;
27546 }
27547 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
27548 return resultobj;
27549 fail:
27550 return NULL;
27551 }
27552
27553
27554 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27555 PyObject *resultobj = 0;
27556 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
27557 bool result;
27558 void *argp1 = 0 ;
27559 int res1 = 0 ;
27560 PyObject *swig_obj[1] ;
27561
27562 if (!args) SWIG_fail;
27563 swig_obj[0] = args;
27564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
27565 if (!SWIG_IsOK(res1)) {
27566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
27567 }
27568 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
27569 {
27570 PyThreadState* __tstate = wxPyBeginAllowThreads();
27571 result = (bool)(arg1)->Iconized();
27572 wxPyEndAllowThreads(__tstate);
27573 if (PyErr_Occurred()) SWIG_fail;
27574 }
27575 {
27576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27577 }
27578 return resultobj;
27579 fail:
27580 return NULL;
27581 }
27582
27583
27584 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27585 PyObject *obj;
27586 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27587 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
27588 return SWIG_Py_Void();
27589 }
27590
27591 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27592 return SWIG_Python_InitShadowInstance(args);
27593 }
27594
27595 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27596 PyObject *resultobj = 0;
27597 int arg1 = (int) 0 ;
27598 wxMaximizeEvent *result = 0 ;
27599 int val1 ;
27600 int ecode1 = 0 ;
27601 PyObject * obj0 = 0 ;
27602 char * kwnames[] = {
27603 (char *) "id", NULL
27604 };
27605
27606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
27607 if (obj0) {
27608 ecode1 = SWIG_AsVal_int(obj0, &val1);
27609 if (!SWIG_IsOK(ecode1)) {
27610 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
27611 }
27612 arg1 = static_cast< int >(val1);
27613 }
27614 {
27615 PyThreadState* __tstate = wxPyBeginAllowThreads();
27616 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
27617 wxPyEndAllowThreads(__tstate);
27618 if (PyErr_Occurred()) SWIG_fail;
27619 }
27620 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
27621 return resultobj;
27622 fail:
27623 return NULL;
27624 }
27625
27626
27627 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27628 PyObject *obj;
27629 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27630 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
27631 return SWIG_Py_Void();
27632 }
27633
27634 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27635 return SWIG_Python_InitShadowInstance(args);
27636 }
27637
27638 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27639 PyObject *resultobj = 0;
27640 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27641 wxPoint result;
27642 void *argp1 = 0 ;
27643 int res1 = 0 ;
27644 PyObject *swig_obj[1] ;
27645
27646 if (!args) SWIG_fail;
27647 swig_obj[0] = args;
27648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27649 if (!SWIG_IsOK(res1)) {
27650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27651 }
27652 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27653 {
27654 PyThreadState* __tstate = wxPyBeginAllowThreads();
27655 result = (arg1)->GetPosition();
27656 wxPyEndAllowThreads(__tstate);
27657 if (PyErr_Occurred()) SWIG_fail;
27658 }
27659 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
27660 return resultobj;
27661 fail:
27662 return NULL;
27663 }
27664
27665
27666 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27667 PyObject *resultobj = 0;
27668 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27669 int result;
27670 void *argp1 = 0 ;
27671 int res1 = 0 ;
27672 PyObject *swig_obj[1] ;
27673
27674 if (!args) SWIG_fail;
27675 swig_obj[0] = args;
27676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27677 if (!SWIG_IsOK(res1)) {
27678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27679 }
27680 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27681 {
27682 PyThreadState* __tstate = wxPyBeginAllowThreads();
27683 result = (int)(arg1)->GetNumberOfFiles();
27684 wxPyEndAllowThreads(__tstate);
27685 if (PyErr_Occurred()) SWIG_fail;
27686 }
27687 resultobj = SWIG_From_int(static_cast< int >(result));
27688 return resultobj;
27689 fail:
27690 return NULL;
27691 }
27692
27693
27694 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27695 PyObject *resultobj = 0;
27696 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27697 PyObject *result = 0 ;
27698 void *argp1 = 0 ;
27699 int res1 = 0 ;
27700 PyObject *swig_obj[1] ;
27701
27702 if (!args) SWIG_fail;
27703 swig_obj[0] = args;
27704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27705 if (!SWIG_IsOK(res1)) {
27706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27707 }
27708 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27709 {
27710 PyThreadState* __tstate = wxPyBeginAllowThreads();
27711 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
27712 wxPyEndAllowThreads(__tstate);
27713 if (PyErr_Occurred()) SWIG_fail;
27714 }
27715 resultobj = result;
27716 return resultobj;
27717 fail:
27718 return NULL;
27719 }
27720
27721
27722 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27723 PyObject *obj;
27724 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27725 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
27726 return SWIG_Py_Void();
27727 }
27728
27729 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27730 PyObject *resultobj = 0;
27731 int arg1 = (int) 0 ;
27732 wxUpdateUIEvent *result = 0 ;
27733 int val1 ;
27734 int ecode1 = 0 ;
27735 PyObject * obj0 = 0 ;
27736 char * kwnames[] = {
27737 (char *) "commandId", NULL
27738 };
27739
27740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
27741 if (obj0) {
27742 ecode1 = SWIG_AsVal_int(obj0, &val1);
27743 if (!SWIG_IsOK(ecode1)) {
27744 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
27745 }
27746 arg1 = static_cast< int >(val1);
27747 }
27748 {
27749 PyThreadState* __tstate = wxPyBeginAllowThreads();
27750 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
27751 wxPyEndAllowThreads(__tstate);
27752 if (PyErr_Occurred()) SWIG_fail;
27753 }
27754 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
27755 return resultobj;
27756 fail:
27757 return NULL;
27758 }
27759
27760
27761 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27762 PyObject *resultobj = 0;
27763 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27764 bool result;
27765 void *argp1 = 0 ;
27766 int res1 = 0 ;
27767 PyObject *swig_obj[1] ;
27768
27769 if (!args) SWIG_fail;
27770 swig_obj[0] = args;
27771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27772 if (!SWIG_IsOK(res1)) {
27773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27774 }
27775 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27776 {
27777 PyThreadState* __tstate = wxPyBeginAllowThreads();
27778 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
27779 wxPyEndAllowThreads(__tstate);
27780 if (PyErr_Occurred()) SWIG_fail;
27781 }
27782 {
27783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27784 }
27785 return resultobj;
27786 fail:
27787 return NULL;
27788 }
27789
27790
27791 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27792 PyObject *resultobj = 0;
27793 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27794 bool result;
27795 void *argp1 = 0 ;
27796 int res1 = 0 ;
27797 PyObject *swig_obj[1] ;
27798
27799 if (!args) SWIG_fail;
27800 swig_obj[0] = args;
27801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27802 if (!SWIG_IsOK(res1)) {
27803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27804 }
27805 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27806 {
27807 PyThreadState* __tstate = wxPyBeginAllowThreads();
27808 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
27809 wxPyEndAllowThreads(__tstate);
27810 if (PyErr_Occurred()) SWIG_fail;
27811 }
27812 {
27813 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27814 }
27815 return resultobj;
27816 fail:
27817 return NULL;
27818 }
27819
27820
27821 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27822 PyObject *resultobj = 0;
27823 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27824 bool result;
27825 void *argp1 = 0 ;
27826 int res1 = 0 ;
27827 PyObject *swig_obj[1] ;
27828
27829 if (!args) SWIG_fail;
27830 swig_obj[0] = args;
27831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27832 if (!SWIG_IsOK(res1)) {
27833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27834 }
27835 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27836 {
27837 PyThreadState* __tstate = wxPyBeginAllowThreads();
27838 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
27839 wxPyEndAllowThreads(__tstate);
27840 if (PyErr_Occurred()) SWIG_fail;
27841 }
27842 {
27843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27844 }
27845 return resultobj;
27846 fail:
27847 return NULL;
27848 }
27849
27850
27851 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27852 PyObject *resultobj = 0;
27853 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27854 wxString result;
27855 void *argp1 = 0 ;
27856 int res1 = 0 ;
27857 PyObject *swig_obj[1] ;
27858
27859 if (!args) SWIG_fail;
27860 swig_obj[0] = args;
27861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27862 if (!SWIG_IsOK(res1)) {
27863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27864 }
27865 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27866 {
27867 PyThreadState* __tstate = wxPyBeginAllowThreads();
27868 result = ((wxUpdateUIEvent const *)arg1)->GetText();
27869 wxPyEndAllowThreads(__tstate);
27870 if (PyErr_Occurred()) SWIG_fail;
27871 }
27872 {
27873 #if wxUSE_UNICODE
27874 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27875 #else
27876 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27877 #endif
27878 }
27879 return resultobj;
27880 fail:
27881 return NULL;
27882 }
27883
27884
27885 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27886 PyObject *resultobj = 0;
27887 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27888 bool result;
27889 void *argp1 = 0 ;
27890 int res1 = 0 ;
27891 PyObject *swig_obj[1] ;
27892
27893 if (!args) SWIG_fail;
27894 swig_obj[0] = args;
27895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27896 if (!SWIG_IsOK(res1)) {
27897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27898 }
27899 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27900 {
27901 PyThreadState* __tstate = wxPyBeginAllowThreads();
27902 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
27903 wxPyEndAllowThreads(__tstate);
27904 if (PyErr_Occurred()) SWIG_fail;
27905 }
27906 {
27907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27908 }
27909 return resultobj;
27910 fail:
27911 return NULL;
27912 }
27913
27914
27915 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27916 PyObject *resultobj = 0;
27917 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27918 bool result;
27919 void *argp1 = 0 ;
27920 int res1 = 0 ;
27921 PyObject *swig_obj[1] ;
27922
27923 if (!args) SWIG_fail;
27924 swig_obj[0] = args;
27925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27926 if (!SWIG_IsOK(res1)) {
27927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27928 }
27929 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27930 {
27931 PyThreadState* __tstate = wxPyBeginAllowThreads();
27932 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
27933 wxPyEndAllowThreads(__tstate);
27934 if (PyErr_Occurred()) SWIG_fail;
27935 }
27936 {
27937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27938 }
27939 return resultobj;
27940 fail:
27941 return NULL;
27942 }
27943
27944
27945 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27946 PyObject *resultobj = 0;
27947 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27948 bool result;
27949 void *argp1 = 0 ;
27950 int res1 = 0 ;
27951 PyObject *swig_obj[1] ;
27952
27953 if (!args) SWIG_fail;
27954 swig_obj[0] = args;
27955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27956 if (!SWIG_IsOK(res1)) {
27957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27958 }
27959 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27960 {
27961 PyThreadState* __tstate = wxPyBeginAllowThreads();
27962 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
27963 wxPyEndAllowThreads(__tstate);
27964 if (PyErr_Occurred()) SWIG_fail;
27965 }
27966 {
27967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27968 }
27969 return resultobj;
27970 fail:
27971 return NULL;
27972 }
27973
27974
27975 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27976 PyObject *resultobj = 0;
27977 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27978 bool result;
27979 void *argp1 = 0 ;
27980 int res1 = 0 ;
27981 PyObject *swig_obj[1] ;
27982
27983 if (!args) SWIG_fail;
27984 swig_obj[0] = args;
27985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27986 if (!SWIG_IsOK(res1)) {
27987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27988 }
27989 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27990 {
27991 PyThreadState* __tstate = wxPyBeginAllowThreads();
27992 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
27993 wxPyEndAllowThreads(__tstate);
27994 if (PyErr_Occurred()) SWIG_fail;
27995 }
27996 {
27997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27998 }
27999 return resultobj;
28000 fail:
28001 return NULL;
28002 }
28003
28004
28005 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28006 PyObject *resultobj = 0;
28007 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28008 bool arg2 ;
28009 void *argp1 = 0 ;
28010 int res1 = 0 ;
28011 bool val2 ;
28012 int ecode2 = 0 ;
28013 PyObject * obj0 = 0 ;
28014 PyObject * obj1 = 0 ;
28015 char * kwnames[] = {
28016 (char *) "self",(char *) "check", NULL
28017 };
28018
28019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
28020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28021 if (!SWIG_IsOK(res1)) {
28022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28023 }
28024 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28025 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28026 if (!SWIG_IsOK(ecode2)) {
28027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
28028 }
28029 arg2 = static_cast< bool >(val2);
28030 {
28031 PyThreadState* __tstate = wxPyBeginAllowThreads();
28032 (arg1)->Check(arg2);
28033 wxPyEndAllowThreads(__tstate);
28034 if (PyErr_Occurred()) SWIG_fail;
28035 }
28036 resultobj = SWIG_Py_Void();
28037 return resultobj;
28038 fail:
28039 return NULL;
28040 }
28041
28042
28043 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28044 PyObject *resultobj = 0;
28045 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28046 bool arg2 ;
28047 void *argp1 = 0 ;
28048 int res1 = 0 ;
28049 bool val2 ;
28050 int ecode2 = 0 ;
28051 PyObject * obj0 = 0 ;
28052 PyObject * obj1 = 0 ;
28053 char * kwnames[] = {
28054 (char *) "self",(char *) "enable", NULL
28055 };
28056
28057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
28058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28059 if (!SWIG_IsOK(res1)) {
28060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28061 }
28062 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28063 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28064 if (!SWIG_IsOK(ecode2)) {
28065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
28066 }
28067 arg2 = static_cast< bool >(val2);
28068 {
28069 PyThreadState* __tstate = wxPyBeginAllowThreads();
28070 (arg1)->Enable(arg2);
28071 wxPyEndAllowThreads(__tstate);
28072 if (PyErr_Occurred()) SWIG_fail;
28073 }
28074 resultobj = SWIG_Py_Void();
28075 return resultobj;
28076 fail:
28077 return NULL;
28078 }
28079
28080
28081 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28082 PyObject *resultobj = 0;
28083 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28084 bool arg2 ;
28085 void *argp1 = 0 ;
28086 int res1 = 0 ;
28087 bool val2 ;
28088 int ecode2 = 0 ;
28089 PyObject * obj0 = 0 ;
28090 PyObject * obj1 = 0 ;
28091 char * kwnames[] = {
28092 (char *) "self",(char *) "show", NULL
28093 };
28094
28095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
28096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28097 if (!SWIG_IsOK(res1)) {
28098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28099 }
28100 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28101 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28102 if (!SWIG_IsOK(ecode2)) {
28103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
28104 }
28105 arg2 = static_cast< bool >(val2);
28106 {
28107 PyThreadState* __tstate = wxPyBeginAllowThreads();
28108 (arg1)->Show(arg2);
28109 wxPyEndAllowThreads(__tstate);
28110 if (PyErr_Occurred()) SWIG_fail;
28111 }
28112 resultobj = SWIG_Py_Void();
28113 return resultobj;
28114 fail:
28115 return NULL;
28116 }
28117
28118
28119 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28120 PyObject *resultobj = 0;
28121 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28122 wxString *arg2 = 0 ;
28123 void *argp1 = 0 ;
28124 int res1 = 0 ;
28125 bool temp2 = false ;
28126 PyObject * obj0 = 0 ;
28127 PyObject * obj1 = 0 ;
28128 char * kwnames[] = {
28129 (char *) "self",(char *) "text", NULL
28130 };
28131
28132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
28133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28134 if (!SWIG_IsOK(res1)) {
28135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28136 }
28137 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28138 {
28139 arg2 = wxString_in_helper(obj1);
28140 if (arg2 == NULL) SWIG_fail;
28141 temp2 = true;
28142 }
28143 {
28144 PyThreadState* __tstate = wxPyBeginAllowThreads();
28145 (arg1)->SetText((wxString const &)*arg2);
28146 wxPyEndAllowThreads(__tstate);
28147 if (PyErr_Occurred()) SWIG_fail;
28148 }
28149 resultobj = SWIG_Py_Void();
28150 {
28151 if (temp2)
28152 delete arg2;
28153 }
28154 return resultobj;
28155 fail:
28156 {
28157 if (temp2)
28158 delete arg2;
28159 }
28160 return NULL;
28161 }
28162
28163
28164 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28165 PyObject *resultobj = 0;
28166 long arg1 ;
28167 long val1 ;
28168 int ecode1 = 0 ;
28169 PyObject * obj0 = 0 ;
28170 char * kwnames[] = {
28171 (char *) "updateInterval", NULL
28172 };
28173
28174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
28175 ecode1 = SWIG_AsVal_long(obj0, &val1);
28176 if (!SWIG_IsOK(ecode1)) {
28177 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
28178 }
28179 arg1 = static_cast< long >(val1);
28180 {
28181 PyThreadState* __tstate = wxPyBeginAllowThreads();
28182 wxUpdateUIEvent::SetUpdateInterval(arg1);
28183 wxPyEndAllowThreads(__tstate);
28184 if (PyErr_Occurred()) SWIG_fail;
28185 }
28186 resultobj = SWIG_Py_Void();
28187 return resultobj;
28188 fail:
28189 return NULL;
28190 }
28191
28192
28193 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28194 PyObject *resultobj = 0;
28195 long result;
28196
28197 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
28198 {
28199 PyThreadState* __tstate = wxPyBeginAllowThreads();
28200 result = (long)wxUpdateUIEvent::GetUpdateInterval();
28201 wxPyEndAllowThreads(__tstate);
28202 if (PyErr_Occurred()) SWIG_fail;
28203 }
28204 resultobj = SWIG_From_long(static_cast< long >(result));
28205 return resultobj;
28206 fail:
28207 return NULL;
28208 }
28209
28210
28211 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28212 PyObject *resultobj = 0;
28213 wxWindow *arg1 = (wxWindow *) 0 ;
28214 bool result;
28215 void *argp1 = 0 ;
28216 int res1 = 0 ;
28217 PyObject * obj0 = 0 ;
28218 char * kwnames[] = {
28219 (char *) "win", NULL
28220 };
28221
28222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
28223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28224 if (!SWIG_IsOK(res1)) {
28225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
28226 }
28227 arg1 = reinterpret_cast< wxWindow * >(argp1);
28228 {
28229 PyThreadState* __tstate = wxPyBeginAllowThreads();
28230 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
28231 wxPyEndAllowThreads(__tstate);
28232 if (PyErr_Occurred()) SWIG_fail;
28233 }
28234 {
28235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28236 }
28237 return resultobj;
28238 fail:
28239 return NULL;
28240 }
28241
28242
28243 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28244 PyObject *resultobj = 0;
28245
28246 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
28247 {
28248 PyThreadState* __tstate = wxPyBeginAllowThreads();
28249 wxUpdateUIEvent::ResetUpdateTime();
28250 wxPyEndAllowThreads(__tstate);
28251 if (PyErr_Occurred()) SWIG_fail;
28252 }
28253 resultobj = SWIG_Py_Void();
28254 return resultobj;
28255 fail:
28256 return NULL;
28257 }
28258
28259
28260 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28261 PyObject *resultobj = 0;
28262 wxUpdateUIMode arg1 ;
28263 int val1 ;
28264 int ecode1 = 0 ;
28265 PyObject * obj0 = 0 ;
28266 char * kwnames[] = {
28267 (char *) "mode", NULL
28268 };
28269
28270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
28271 ecode1 = SWIG_AsVal_int(obj0, &val1);
28272 if (!SWIG_IsOK(ecode1)) {
28273 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
28274 }
28275 arg1 = static_cast< wxUpdateUIMode >(val1);
28276 {
28277 PyThreadState* __tstate = wxPyBeginAllowThreads();
28278 wxUpdateUIEvent::SetMode(arg1);
28279 wxPyEndAllowThreads(__tstate);
28280 if (PyErr_Occurred()) SWIG_fail;
28281 }
28282 resultobj = SWIG_Py_Void();
28283 return resultobj;
28284 fail:
28285 return NULL;
28286 }
28287
28288
28289 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28290 PyObject *resultobj = 0;
28291 wxUpdateUIMode result;
28292
28293 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
28294 {
28295 PyThreadState* __tstate = wxPyBeginAllowThreads();
28296 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
28297 wxPyEndAllowThreads(__tstate);
28298 if (PyErr_Occurred()) SWIG_fail;
28299 }
28300 resultobj = SWIG_From_int(static_cast< int >(result));
28301 return resultobj;
28302 fail:
28303 return NULL;
28304 }
28305
28306
28307 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28308 PyObject *obj;
28309 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28310 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
28311 return SWIG_Py_Void();
28312 }
28313
28314 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28315 return SWIG_Python_InitShadowInstance(args);
28316 }
28317
28318 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28319 PyObject *resultobj = 0;
28320 wxSysColourChangedEvent *result = 0 ;
28321
28322 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
28323 {
28324 PyThreadState* __tstate = wxPyBeginAllowThreads();
28325 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
28326 wxPyEndAllowThreads(__tstate);
28327 if (PyErr_Occurred()) SWIG_fail;
28328 }
28329 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
28330 return resultobj;
28331 fail:
28332 return NULL;
28333 }
28334
28335
28336 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28337 PyObject *obj;
28338 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28339 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
28340 return SWIG_Py_Void();
28341 }
28342
28343 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28344 return SWIG_Python_InitShadowInstance(args);
28345 }
28346
28347 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28348 PyObject *resultobj = 0;
28349 int arg1 = (int) 0 ;
28350 wxWindow *arg2 = (wxWindow *) NULL ;
28351 wxMouseCaptureChangedEvent *result = 0 ;
28352 int val1 ;
28353 int ecode1 = 0 ;
28354 void *argp2 = 0 ;
28355 int res2 = 0 ;
28356 PyObject * obj0 = 0 ;
28357 PyObject * obj1 = 0 ;
28358 char * kwnames[] = {
28359 (char *) "winid",(char *) "gainedCapture", NULL
28360 };
28361
28362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28363 if (obj0) {
28364 ecode1 = SWIG_AsVal_int(obj0, &val1);
28365 if (!SWIG_IsOK(ecode1)) {
28366 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
28367 }
28368 arg1 = static_cast< int >(val1);
28369 }
28370 if (obj1) {
28371 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28372 if (!SWIG_IsOK(res2)) {
28373 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
28374 }
28375 arg2 = reinterpret_cast< wxWindow * >(argp2);
28376 }
28377 {
28378 PyThreadState* __tstate = wxPyBeginAllowThreads();
28379 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
28380 wxPyEndAllowThreads(__tstate);
28381 if (PyErr_Occurred()) SWIG_fail;
28382 }
28383 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
28384 return resultobj;
28385 fail:
28386 return NULL;
28387 }
28388
28389
28390 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28391 PyObject *resultobj = 0;
28392 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
28393 wxWindow *result = 0 ;
28394 void *argp1 = 0 ;
28395 int res1 = 0 ;
28396 PyObject *swig_obj[1] ;
28397
28398 if (!args) SWIG_fail;
28399 swig_obj[0] = args;
28400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
28401 if (!SWIG_IsOK(res1)) {
28402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
28403 }
28404 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
28405 {
28406 PyThreadState* __tstate = wxPyBeginAllowThreads();
28407 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
28408 wxPyEndAllowThreads(__tstate);
28409 if (PyErr_Occurred()) SWIG_fail;
28410 }
28411 {
28412 resultobj = wxPyMake_wxObject(result, (bool)0);
28413 }
28414 return resultobj;
28415 fail:
28416 return NULL;
28417 }
28418
28419
28420 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28421 PyObject *obj;
28422 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28423 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
28424 return SWIG_Py_Void();
28425 }
28426
28427 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28428 return SWIG_Python_InitShadowInstance(args);
28429 }
28430
28431 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28432 PyObject *resultobj = 0;
28433 int arg1 = (int) 0 ;
28434 wxMouseCaptureLostEvent *result = 0 ;
28435 int val1 ;
28436 int ecode1 = 0 ;
28437 PyObject * obj0 = 0 ;
28438 char * kwnames[] = {
28439 (char *) "winid", NULL
28440 };
28441
28442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
28443 if (obj0) {
28444 ecode1 = SWIG_AsVal_int(obj0, &val1);
28445 if (!SWIG_IsOK(ecode1)) {
28446 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
28447 }
28448 arg1 = static_cast< int >(val1);
28449 }
28450 {
28451 PyThreadState* __tstate = wxPyBeginAllowThreads();
28452 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
28453 wxPyEndAllowThreads(__tstate);
28454 if (PyErr_Occurred()) SWIG_fail;
28455 }
28456 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
28457 return resultobj;
28458 fail:
28459 return NULL;
28460 }
28461
28462
28463 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28464 PyObject *obj;
28465 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28466 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
28467 return SWIG_Py_Void();
28468 }
28469
28470 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28471 return SWIG_Python_InitShadowInstance(args);
28472 }
28473
28474 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28475 PyObject *resultobj = 0;
28476 wxDisplayChangedEvent *result = 0 ;
28477
28478 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
28479 {
28480 PyThreadState* __tstate = wxPyBeginAllowThreads();
28481 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
28482 wxPyEndAllowThreads(__tstate);
28483 if (PyErr_Occurred()) SWIG_fail;
28484 }
28485 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
28486 return resultobj;
28487 fail:
28488 return NULL;
28489 }
28490
28491
28492 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28493 PyObject *obj;
28494 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28495 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
28496 return SWIG_Py_Void();
28497 }
28498
28499 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28500 return SWIG_Python_InitShadowInstance(args);
28501 }
28502
28503 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28504 PyObject *resultobj = 0;
28505 int arg1 = (int) 0 ;
28506 wxPaletteChangedEvent *result = 0 ;
28507 int val1 ;
28508 int ecode1 = 0 ;
28509 PyObject * obj0 = 0 ;
28510 char * kwnames[] = {
28511 (char *) "id", NULL
28512 };
28513
28514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
28515 if (obj0) {
28516 ecode1 = SWIG_AsVal_int(obj0, &val1);
28517 if (!SWIG_IsOK(ecode1)) {
28518 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
28519 }
28520 arg1 = static_cast< int >(val1);
28521 }
28522 {
28523 PyThreadState* __tstate = wxPyBeginAllowThreads();
28524 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
28525 wxPyEndAllowThreads(__tstate);
28526 if (PyErr_Occurred()) SWIG_fail;
28527 }
28528 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
28529 return resultobj;
28530 fail:
28531 return NULL;
28532 }
28533
28534
28535 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28536 PyObject *resultobj = 0;
28537 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28538 wxWindow *arg2 = (wxWindow *) 0 ;
28539 void *argp1 = 0 ;
28540 int res1 = 0 ;
28541 void *argp2 = 0 ;
28542 int res2 = 0 ;
28543 PyObject * obj0 = 0 ;
28544 PyObject * obj1 = 0 ;
28545 char * kwnames[] = {
28546 (char *) "self",(char *) "win", NULL
28547 };
28548
28549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28551 if (!SWIG_IsOK(res1)) {
28552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28553 }
28554 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28555 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28556 if (!SWIG_IsOK(res2)) {
28557 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28558 }
28559 arg2 = reinterpret_cast< wxWindow * >(argp2);
28560 {
28561 PyThreadState* __tstate = wxPyBeginAllowThreads();
28562 (arg1)->SetChangedWindow(arg2);
28563 wxPyEndAllowThreads(__tstate);
28564 if (PyErr_Occurred()) SWIG_fail;
28565 }
28566 resultobj = SWIG_Py_Void();
28567 return resultobj;
28568 fail:
28569 return NULL;
28570 }
28571
28572
28573 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28574 PyObject *resultobj = 0;
28575 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28576 wxWindow *result = 0 ;
28577 void *argp1 = 0 ;
28578 int res1 = 0 ;
28579 PyObject *swig_obj[1] ;
28580
28581 if (!args) SWIG_fail;
28582 swig_obj[0] = args;
28583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28584 if (!SWIG_IsOK(res1)) {
28585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28586 }
28587 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28588 {
28589 PyThreadState* __tstate = wxPyBeginAllowThreads();
28590 result = (wxWindow *)(arg1)->GetChangedWindow();
28591 wxPyEndAllowThreads(__tstate);
28592 if (PyErr_Occurred()) SWIG_fail;
28593 }
28594 {
28595 resultobj = wxPyMake_wxObject(result, (bool)0);
28596 }
28597 return resultobj;
28598 fail:
28599 return NULL;
28600 }
28601
28602
28603 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28604 PyObject *obj;
28605 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28606 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
28607 return SWIG_Py_Void();
28608 }
28609
28610 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28611 return SWIG_Python_InitShadowInstance(args);
28612 }
28613
28614 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28615 PyObject *resultobj = 0;
28616 int arg1 = (int) 0 ;
28617 wxQueryNewPaletteEvent *result = 0 ;
28618 int val1 ;
28619 int ecode1 = 0 ;
28620 PyObject * obj0 = 0 ;
28621 char * kwnames[] = {
28622 (char *) "winid", NULL
28623 };
28624
28625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
28626 if (obj0) {
28627 ecode1 = SWIG_AsVal_int(obj0, &val1);
28628 if (!SWIG_IsOK(ecode1)) {
28629 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
28630 }
28631 arg1 = static_cast< int >(val1);
28632 }
28633 {
28634 PyThreadState* __tstate = wxPyBeginAllowThreads();
28635 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
28636 wxPyEndAllowThreads(__tstate);
28637 if (PyErr_Occurred()) SWIG_fail;
28638 }
28639 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
28640 return resultobj;
28641 fail:
28642 return NULL;
28643 }
28644
28645
28646 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28647 PyObject *resultobj = 0;
28648 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28649 bool arg2 ;
28650 void *argp1 = 0 ;
28651 int res1 = 0 ;
28652 bool val2 ;
28653 int ecode2 = 0 ;
28654 PyObject * obj0 = 0 ;
28655 PyObject * obj1 = 0 ;
28656 char * kwnames[] = {
28657 (char *) "self",(char *) "realized", NULL
28658 };
28659
28660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
28661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28662 if (!SWIG_IsOK(res1)) {
28663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
28664 }
28665 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28666 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28667 if (!SWIG_IsOK(ecode2)) {
28668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
28669 }
28670 arg2 = static_cast< bool >(val2);
28671 {
28672 PyThreadState* __tstate = wxPyBeginAllowThreads();
28673 (arg1)->SetPaletteRealized(arg2);
28674 wxPyEndAllowThreads(__tstate);
28675 if (PyErr_Occurred()) SWIG_fail;
28676 }
28677 resultobj = SWIG_Py_Void();
28678 return resultobj;
28679 fail:
28680 return NULL;
28681 }
28682
28683
28684 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28685 PyObject *resultobj = 0;
28686 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28687 bool result;
28688 void *argp1 = 0 ;
28689 int res1 = 0 ;
28690 PyObject *swig_obj[1] ;
28691
28692 if (!args) SWIG_fail;
28693 swig_obj[0] = args;
28694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28695 if (!SWIG_IsOK(res1)) {
28696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
28697 }
28698 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28699 {
28700 PyThreadState* __tstate = wxPyBeginAllowThreads();
28701 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
28702 wxPyEndAllowThreads(__tstate);
28703 if (PyErr_Occurred()) SWIG_fail;
28704 }
28705 {
28706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28707 }
28708 return resultobj;
28709 fail:
28710 return NULL;
28711 }
28712
28713
28714 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28715 PyObject *obj;
28716 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28717 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
28718 return SWIG_Py_Void();
28719 }
28720
28721 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28722 return SWIG_Python_InitShadowInstance(args);
28723 }
28724
28725 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28726 PyObject *resultobj = 0;
28727 wxNavigationKeyEvent *result = 0 ;
28728
28729 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
28730 {
28731 PyThreadState* __tstate = wxPyBeginAllowThreads();
28732 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
28733 wxPyEndAllowThreads(__tstate);
28734 if (PyErr_Occurred()) SWIG_fail;
28735 }
28736 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
28737 return resultobj;
28738 fail:
28739 return NULL;
28740 }
28741
28742
28743 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28744 PyObject *resultobj = 0;
28745 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28746 bool result;
28747 void *argp1 = 0 ;
28748 int res1 = 0 ;
28749 PyObject *swig_obj[1] ;
28750
28751 if (!args) SWIG_fail;
28752 swig_obj[0] = args;
28753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28754 if (!SWIG_IsOK(res1)) {
28755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28756 }
28757 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28758 {
28759 PyThreadState* __tstate = wxPyBeginAllowThreads();
28760 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
28761 wxPyEndAllowThreads(__tstate);
28762 if (PyErr_Occurred()) SWIG_fail;
28763 }
28764 {
28765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28766 }
28767 return resultobj;
28768 fail:
28769 return NULL;
28770 }
28771
28772
28773 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28774 PyObject *resultobj = 0;
28775 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28776 bool arg2 ;
28777 void *argp1 = 0 ;
28778 int res1 = 0 ;
28779 bool val2 ;
28780 int ecode2 = 0 ;
28781 PyObject * obj0 = 0 ;
28782 PyObject * obj1 = 0 ;
28783 char * kwnames[] = {
28784 (char *) "self",(char *) "forward", NULL
28785 };
28786
28787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
28788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28789 if (!SWIG_IsOK(res1)) {
28790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28791 }
28792 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28793 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28794 if (!SWIG_IsOK(ecode2)) {
28795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
28796 }
28797 arg2 = static_cast< bool >(val2);
28798 {
28799 PyThreadState* __tstate = wxPyBeginAllowThreads();
28800 (arg1)->SetDirection(arg2);
28801 wxPyEndAllowThreads(__tstate);
28802 if (PyErr_Occurred()) SWIG_fail;
28803 }
28804 resultobj = SWIG_Py_Void();
28805 return resultobj;
28806 fail:
28807 return NULL;
28808 }
28809
28810
28811 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28812 PyObject *resultobj = 0;
28813 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28814 bool result;
28815 void *argp1 = 0 ;
28816 int res1 = 0 ;
28817 PyObject *swig_obj[1] ;
28818
28819 if (!args) SWIG_fail;
28820 swig_obj[0] = args;
28821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28822 if (!SWIG_IsOK(res1)) {
28823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28824 }
28825 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28826 {
28827 PyThreadState* __tstate = wxPyBeginAllowThreads();
28828 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
28829 wxPyEndAllowThreads(__tstate);
28830 if (PyErr_Occurred()) SWIG_fail;
28831 }
28832 {
28833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28834 }
28835 return resultobj;
28836 fail:
28837 return NULL;
28838 }
28839
28840
28841 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28842 PyObject *resultobj = 0;
28843 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28844 bool arg2 ;
28845 void *argp1 = 0 ;
28846 int res1 = 0 ;
28847 bool val2 ;
28848 int ecode2 = 0 ;
28849 PyObject * obj0 = 0 ;
28850 PyObject * obj1 = 0 ;
28851 char * kwnames[] = {
28852 (char *) "self",(char *) "ischange", NULL
28853 };
28854
28855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
28856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28857 if (!SWIG_IsOK(res1)) {
28858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28859 }
28860 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28861 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28862 if (!SWIG_IsOK(ecode2)) {
28863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
28864 }
28865 arg2 = static_cast< bool >(val2);
28866 {
28867 PyThreadState* __tstate = wxPyBeginAllowThreads();
28868 (arg1)->SetWindowChange(arg2);
28869 wxPyEndAllowThreads(__tstate);
28870 if (PyErr_Occurred()) SWIG_fail;
28871 }
28872 resultobj = SWIG_Py_Void();
28873 return resultobj;
28874 fail:
28875 return NULL;
28876 }
28877
28878
28879 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28880 PyObject *resultobj = 0;
28881 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28882 bool result;
28883 void *argp1 = 0 ;
28884 int res1 = 0 ;
28885 PyObject *swig_obj[1] ;
28886
28887 if (!args) SWIG_fail;
28888 swig_obj[0] = args;
28889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28890 if (!SWIG_IsOK(res1)) {
28891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28892 }
28893 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28894 {
28895 PyThreadState* __tstate = wxPyBeginAllowThreads();
28896 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
28897 wxPyEndAllowThreads(__tstate);
28898 if (PyErr_Occurred()) SWIG_fail;
28899 }
28900 {
28901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28902 }
28903 return resultobj;
28904 fail:
28905 return NULL;
28906 }
28907
28908
28909 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28910 PyObject *resultobj = 0;
28911 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28912 bool arg2 ;
28913 void *argp1 = 0 ;
28914 int res1 = 0 ;
28915 bool val2 ;
28916 int ecode2 = 0 ;
28917 PyObject * obj0 = 0 ;
28918 PyObject * obj1 = 0 ;
28919 char * kwnames[] = {
28920 (char *) "self",(char *) "bIs", NULL
28921 };
28922
28923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
28924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28925 if (!SWIG_IsOK(res1)) {
28926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28927 }
28928 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28929 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28930 if (!SWIG_IsOK(ecode2)) {
28931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
28932 }
28933 arg2 = static_cast< bool >(val2);
28934 {
28935 PyThreadState* __tstate = wxPyBeginAllowThreads();
28936 (arg1)->SetFromTab(arg2);
28937 wxPyEndAllowThreads(__tstate);
28938 if (PyErr_Occurred()) SWIG_fail;
28939 }
28940 resultobj = SWIG_Py_Void();
28941 return resultobj;
28942 fail:
28943 return NULL;
28944 }
28945
28946
28947 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28948 PyObject *resultobj = 0;
28949 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28950 long arg2 ;
28951 void *argp1 = 0 ;
28952 int res1 = 0 ;
28953 long val2 ;
28954 int ecode2 = 0 ;
28955 PyObject * obj0 = 0 ;
28956 PyObject * obj1 = 0 ;
28957 char * kwnames[] = {
28958 (char *) "self",(char *) "flags", NULL
28959 };
28960
28961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
28962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28963 if (!SWIG_IsOK(res1)) {
28964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28965 }
28966 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28967 ecode2 = SWIG_AsVal_long(obj1, &val2);
28968 if (!SWIG_IsOK(ecode2)) {
28969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
28970 }
28971 arg2 = static_cast< long >(val2);
28972 {
28973 PyThreadState* __tstate = wxPyBeginAllowThreads();
28974 (arg1)->SetFlags(arg2);
28975 wxPyEndAllowThreads(__tstate);
28976 if (PyErr_Occurred()) SWIG_fail;
28977 }
28978 resultobj = SWIG_Py_Void();
28979 return resultobj;
28980 fail:
28981 return NULL;
28982 }
28983
28984
28985 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28986 PyObject *resultobj = 0;
28987 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28988 wxWindow *result = 0 ;
28989 void *argp1 = 0 ;
28990 int res1 = 0 ;
28991 PyObject *swig_obj[1] ;
28992
28993 if (!args) SWIG_fail;
28994 swig_obj[0] = args;
28995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28996 if (!SWIG_IsOK(res1)) {
28997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28998 }
28999 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29000 {
29001 PyThreadState* __tstate = wxPyBeginAllowThreads();
29002 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
29003 wxPyEndAllowThreads(__tstate);
29004 if (PyErr_Occurred()) SWIG_fail;
29005 }
29006 {
29007 resultobj = wxPyMake_wxObject(result, (bool)0);
29008 }
29009 return resultobj;
29010 fail:
29011 return NULL;
29012 }
29013
29014
29015 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29016 PyObject *resultobj = 0;
29017 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29018 wxWindow *arg2 = (wxWindow *) 0 ;
29019 void *argp1 = 0 ;
29020 int res1 = 0 ;
29021 void *argp2 = 0 ;
29022 int res2 = 0 ;
29023 PyObject * obj0 = 0 ;
29024 PyObject * obj1 = 0 ;
29025 char * kwnames[] = {
29026 (char *) "self",(char *) "win", NULL
29027 };
29028
29029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
29030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29031 if (!SWIG_IsOK(res1)) {
29032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
29033 }
29034 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29035 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29036 if (!SWIG_IsOK(res2)) {
29037 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
29038 }
29039 arg2 = reinterpret_cast< wxWindow * >(argp2);
29040 {
29041 PyThreadState* __tstate = wxPyBeginAllowThreads();
29042 (arg1)->SetCurrentFocus(arg2);
29043 wxPyEndAllowThreads(__tstate);
29044 if (PyErr_Occurred()) SWIG_fail;
29045 }
29046 resultobj = SWIG_Py_Void();
29047 return resultobj;
29048 fail:
29049 return NULL;
29050 }
29051
29052
29053 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29054 PyObject *obj;
29055 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29056 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
29057 return SWIG_Py_Void();
29058 }
29059
29060 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29061 return SWIG_Python_InitShadowInstance(args);
29062 }
29063
29064 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29065 PyObject *resultobj = 0;
29066 wxWindow *arg1 = (wxWindow *) NULL ;
29067 wxWindowCreateEvent *result = 0 ;
29068 void *argp1 = 0 ;
29069 int res1 = 0 ;
29070 PyObject * obj0 = 0 ;
29071 char * kwnames[] = {
29072 (char *) "win", NULL
29073 };
29074
29075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
29076 if (obj0) {
29077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29078 if (!SWIG_IsOK(res1)) {
29079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29080 }
29081 arg1 = reinterpret_cast< wxWindow * >(argp1);
29082 }
29083 {
29084 PyThreadState* __tstate = wxPyBeginAllowThreads();
29085 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
29086 wxPyEndAllowThreads(__tstate);
29087 if (PyErr_Occurred()) SWIG_fail;
29088 }
29089 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
29090 return resultobj;
29091 fail:
29092 return NULL;
29093 }
29094
29095
29096 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29097 PyObject *resultobj = 0;
29098 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
29099 wxWindow *result = 0 ;
29100 void *argp1 = 0 ;
29101 int res1 = 0 ;
29102 PyObject *swig_obj[1] ;
29103
29104 if (!args) SWIG_fail;
29105 swig_obj[0] = args;
29106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
29107 if (!SWIG_IsOK(res1)) {
29108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
29109 }
29110 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
29111 {
29112 PyThreadState* __tstate = wxPyBeginAllowThreads();
29113 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
29114 wxPyEndAllowThreads(__tstate);
29115 if (PyErr_Occurred()) SWIG_fail;
29116 }
29117 {
29118 resultobj = wxPyMake_wxObject(result, (bool)0);
29119 }
29120 return resultobj;
29121 fail:
29122 return NULL;
29123 }
29124
29125
29126 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29127 PyObject *obj;
29128 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29129 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
29130 return SWIG_Py_Void();
29131 }
29132
29133 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29134 return SWIG_Python_InitShadowInstance(args);
29135 }
29136
29137 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29138 PyObject *resultobj = 0;
29139 wxWindow *arg1 = (wxWindow *) NULL ;
29140 wxWindowDestroyEvent *result = 0 ;
29141 void *argp1 = 0 ;
29142 int res1 = 0 ;
29143 PyObject * obj0 = 0 ;
29144 char * kwnames[] = {
29145 (char *) "win", NULL
29146 };
29147
29148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
29149 if (obj0) {
29150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29151 if (!SWIG_IsOK(res1)) {
29152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29153 }
29154 arg1 = reinterpret_cast< wxWindow * >(argp1);
29155 }
29156 {
29157 PyThreadState* __tstate = wxPyBeginAllowThreads();
29158 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
29159 wxPyEndAllowThreads(__tstate);
29160 if (PyErr_Occurred()) SWIG_fail;
29161 }
29162 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
29163 return resultobj;
29164 fail:
29165 return NULL;
29166 }
29167
29168
29169 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29170 PyObject *resultobj = 0;
29171 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
29172 wxWindow *result = 0 ;
29173 void *argp1 = 0 ;
29174 int res1 = 0 ;
29175 PyObject *swig_obj[1] ;
29176
29177 if (!args) SWIG_fail;
29178 swig_obj[0] = args;
29179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
29180 if (!SWIG_IsOK(res1)) {
29181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
29182 }
29183 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
29184 {
29185 PyThreadState* __tstate = wxPyBeginAllowThreads();
29186 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
29187 wxPyEndAllowThreads(__tstate);
29188 if (PyErr_Occurred()) SWIG_fail;
29189 }
29190 {
29191 resultobj = wxPyMake_wxObject(result, (bool)0);
29192 }
29193 return resultobj;
29194 fail:
29195 return NULL;
29196 }
29197
29198
29199 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29200 PyObject *obj;
29201 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29202 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
29203 return SWIG_Py_Void();
29204 }
29205
29206 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29207 return SWIG_Python_InitShadowInstance(args);
29208 }
29209
29210 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29211 PyObject *resultobj = 0;
29212 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29213 int arg2 = (int) 0 ;
29214 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29215 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29216 wxContextMenuEvent *result = 0 ;
29217 int val1 ;
29218 int ecode1 = 0 ;
29219 int val2 ;
29220 int ecode2 = 0 ;
29221 wxPoint temp3 ;
29222 PyObject * obj0 = 0 ;
29223 PyObject * obj1 = 0 ;
29224 PyObject * obj2 = 0 ;
29225 char * kwnames[] = {
29226 (char *) "type",(char *) "winid",(char *) "pt", NULL
29227 };
29228
29229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29230 if (obj0) {
29231 ecode1 = SWIG_AsVal_int(obj0, &val1);
29232 if (!SWIG_IsOK(ecode1)) {
29233 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29234 }
29235 arg1 = static_cast< wxEventType >(val1);
29236 }
29237 if (obj1) {
29238 ecode2 = SWIG_AsVal_int(obj1, &val2);
29239 if (!SWIG_IsOK(ecode2)) {
29240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
29241 }
29242 arg2 = static_cast< int >(val2);
29243 }
29244 if (obj2) {
29245 {
29246 arg3 = &temp3;
29247 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29248 }
29249 }
29250 {
29251 PyThreadState* __tstate = wxPyBeginAllowThreads();
29252 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
29253 wxPyEndAllowThreads(__tstate);
29254 if (PyErr_Occurred()) SWIG_fail;
29255 }
29256 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
29257 return resultobj;
29258 fail:
29259 return NULL;
29260 }
29261
29262
29263 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29264 PyObject *resultobj = 0;
29265 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29266 wxPoint *result = 0 ;
29267 void *argp1 = 0 ;
29268 int res1 = 0 ;
29269 PyObject *swig_obj[1] ;
29270
29271 if (!args) SWIG_fail;
29272 swig_obj[0] = args;
29273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29274 if (!SWIG_IsOK(res1)) {
29275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
29276 }
29277 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29278 {
29279 PyThreadState* __tstate = wxPyBeginAllowThreads();
29280 {
29281 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
29282 result = (wxPoint *) &_result_ref;
29283 }
29284 wxPyEndAllowThreads(__tstate);
29285 if (PyErr_Occurred()) SWIG_fail;
29286 }
29287 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
29288 return resultobj;
29289 fail:
29290 return NULL;
29291 }
29292
29293
29294 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29295 PyObject *resultobj = 0;
29296 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29297 wxPoint *arg2 = 0 ;
29298 void *argp1 = 0 ;
29299 int res1 = 0 ;
29300 wxPoint temp2 ;
29301 PyObject * obj0 = 0 ;
29302 PyObject * obj1 = 0 ;
29303 char * kwnames[] = {
29304 (char *) "self",(char *) "pos", NULL
29305 };
29306
29307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
29308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29309 if (!SWIG_IsOK(res1)) {
29310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
29311 }
29312 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29313 {
29314 arg2 = &temp2;
29315 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29316 }
29317 {
29318 PyThreadState* __tstate = wxPyBeginAllowThreads();
29319 (arg1)->SetPosition((wxPoint const &)*arg2);
29320 wxPyEndAllowThreads(__tstate);
29321 if (PyErr_Occurred()) SWIG_fail;
29322 }
29323 resultobj = SWIG_Py_Void();
29324 return resultobj;
29325 fail:
29326 return NULL;
29327 }
29328
29329
29330 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29331 PyObject *obj;
29332 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29333 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
29334 return SWIG_Py_Void();
29335 }
29336
29337 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29338 return SWIG_Python_InitShadowInstance(args);
29339 }
29340
29341 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29342 PyObject *resultobj = 0;
29343 wxIdleEvent *result = 0 ;
29344
29345 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
29346 {
29347 PyThreadState* __tstate = wxPyBeginAllowThreads();
29348 result = (wxIdleEvent *)new wxIdleEvent();
29349 wxPyEndAllowThreads(__tstate);
29350 if (PyErr_Occurred()) SWIG_fail;
29351 }
29352 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
29353 return resultobj;
29354 fail:
29355 return NULL;
29356 }
29357
29358
29359 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29360 PyObject *resultobj = 0;
29361 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29362 bool arg2 = (bool) true ;
29363 void *argp1 = 0 ;
29364 int res1 = 0 ;
29365 bool val2 ;
29366 int ecode2 = 0 ;
29367 PyObject * obj0 = 0 ;
29368 PyObject * obj1 = 0 ;
29369 char * kwnames[] = {
29370 (char *) "self",(char *) "needMore", NULL
29371 };
29372
29373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
29374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29375 if (!SWIG_IsOK(res1)) {
29376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
29377 }
29378 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29379 if (obj1) {
29380 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29381 if (!SWIG_IsOK(ecode2)) {
29382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
29383 }
29384 arg2 = static_cast< bool >(val2);
29385 }
29386 {
29387 PyThreadState* __tstate = wxPyBeginAllowThreads();
29388 (arg1)->RequestMore(arg2);
29389 wxPyEndAllowThreads(__tstate);
29390 if (PyErr_Occurred()) SWIG_fail;
29391 }
29392 resultobj = SWIG_Py_Void();
29393 return resultobj;
29394 fail:
29395 return NULL;
29396 }
29397
29398
29399 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29400 PyObject *resultobj = 0;
29401 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29402 bool result;
29403 void *argp1 = 0 ;
29404 int res1 = 0 ;
29405 PyObject *swig_obj[1] ;
29406
29407 if (!args) SWIG_fail;
29408 swig_obj[0] = args;
29409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29410 if (!SWIG_IsOK(res1)) {
29411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
29412 }
29413 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29414 {
29415 PyThreadState* __tstate = wxPyBeginAllowThreads();
29416 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
29417 wxPyEndAllowThreads(__tstate);
29418 if (PyErr_Occurred()) SWIG_fail;
29419 }
29420 {
29421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29422 }
29423 return resultobj;
29424 fail:
29425 return NULL;
29426 }
29427
29428
29429 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29430 PyObject *resultobj = 0;
29431 wxIdleMode arg1 ;
29432 int val1 ;
29433 int ecode1 = 0 ;
29434 PyObject * obj0 = 0 ;
29435 char * kwnames[] = {
29436 (char *) "mode", NULL
29437 };
29438
29439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
29440 ecode1 = SWIG_AsVal_int(obj0, &val1);
29441 if (!SWIG_IsOK(ecode1)) {
29442 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
29443 }
29444 arg1 = static_cast< wxIdleMode >(val1);
29445 {
29446 PyThreadState* __tstate = wxPyBeginAllowThreads();
29447 wxIdleEvent::SetMode(arg1);
29448 wxPyEndAllowThreads(__tstate);
29449 if (PyErr_Occurred()) SWIG_fail;
29450 }
29451 resultobj = SWIG_Py_Void();
29452 return resultobj;
29453 fail:
29454 return NULL;
29455 }
29456
29457
29458 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29459 PyObject *resultobj = 0;
29460 wxIdleMode result;
29461
29462 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
29463 {
29464 PyThreadState* __tstate = wxPyBeginAllowThreads();
29465 result = (wxIdleMode)wxIdleEvent::GetMode();
29466 wxPyEndAllowThreads(__tstate);
29467 if (PyErr_Occurred()) SWIG_fail;
29468 }
29469 resultobj = SWIG_From_int(static_cast< int >(result));
29470 return resultobj;
29471 fail:
29472 return NULL;
29473 }
29474
29475
29476 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29477 PyObject *resultobj = 0;
29478 wxWindow *arg1 = (wxWindow *) 0 ;
29479 bool result;
29480 void *argp1 = 0 ;
29481 int res1 = 0 ;
29482 PyObject * obj0 = 0 ;
29483 char * kwnames[] = {
29484 (char *) "win", NULL
29485 };
29486
29487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
29488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29489 if (!SWIG_IsOK(res1)) {
29490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
29491 }
29492 arg1 = reinterpret_cast< wxWindow * >(argp1);
29493 {
29494 PyThreadState* __tstate = wxPyBeginAllowThreads();
29495 result = (bool)wxIdleEvent::CanSend(arg1);
29496 wxPyEndAllowThreads(__tstate);
29497 if (PyErr_Occurred()) SWIG_fail;
29498 }
29499 {
29500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29501 }
29502 return resultobj;
29503 fail:
29504 return NULL;
29505 }
29506
29507
29508 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29509 PyObject *obj;
29510 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29511 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
29512 return SWIG_Py_Void();
29513 }
29514
29515 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29516 return SWIG_Python_InitShadowInstance(args);
29517 }
29518
29519 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29520 PyObject *resultobj = 0;
29521 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29522 int arg2 = (int) 0 ;
29523 wxClipboardTextEvent *result = 0 ;
29524 int val1 ;
29525 int ecode1 = 0 ;
29526 int val2 ;
29527 int ecode2 = 0 ;
29528 PyObject * obj0 = 0 ;
29529 PyObject * obj1 = 0 ;
29530 char * kwnames[] = {
29531 (char *) "type",(char *) "winid", NULL
29532 };
29533
29534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29535 if (obj0) {
29536 ecode1 = SWIG_AsVal_int(obj0, &val1);
29537 if (!SWIG_IsOK(ecode1)) {
29538 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29539 }
29540 arg1 = static_cast< wxEventType >(val1);
29541 }
29542 if (obj1) {
29543 ecode2 = SWIG_AsVal_int(obj1, &val2);
29544 if (!SWIG_IsOK(ecode2)) {
29545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
29546 }
29547 arg2 = static_cast< int >(val2);
29548 }
29549 {
29550 PyThreadState* __tstate = wxPyBeginAllowThreads();
29551 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
29552 wxPyEndAllowThreads(__tstate);
29553 if (PyErr_Occurred()) SWIG_fail;
29554 }
29555 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
29556 return resultobj;
29557 fail:
29558 return NULL;
29559 }
29560
29561
29562 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29563 PyObject *obj;
29564 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29565 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
29566 return SWIG_Py_Void();
29567 }
29568
29569 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29570 return SWIG_Python_InitShadowInstance(args);
29571 }
29572
29573 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29574 PyObject *resultobj = 0;
29575 int arg1 = (int) 0 ;
29576 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
29577 wxPyEvent *result = 0 ;
29578 int val1 ;
29579 int ecode1 = 0 ;
29580 int val2 ;
29581 int ecode2 = 0 ;
29582 PyObject * obj0 = 0 ;
29583 PyObject * obj1 = 0 ;
29584 char * kwnames[] = {
29585 (char *) "winid",(char *) "eventType", NULL
29586 };
29587
29588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29589 if (obj0) {
29590 ecode1 = SWIG_AsVal_int(obj0, &val1);
29591 if (!SWIG_IsOK(ecode1)) {
29592 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
29593 }
29594 arg1 = static_cast< int >(val1);
29595 }
29596 if (obj1) {
29597 ecode2 = SWIG_AsVal_int(obj1, &val2);
29598 if (!SWIG_IsOK(ecode2)) {
29599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
29600 }
29601 arg2 = static_cast< wxEventType >(val2);
29602 }
29603 {
29604 PyThreadState* __tstate = wxPyBeginAllowThreads();
29605 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
29606 wxPyEndAllowThreads(__tstate);
29607 if (PyErr_Occurred()) SWIG_fail;
29608 }
29609 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
29610 return resultobj;
29611 fail:
29612 return NULL;
29613 }
29614
29615
29616 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29617 PyObject *resultobj = 0;
29618 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29619 void *argp1 = 0 ;
29620 int res1 = 0 ;
29621 PyObject *swig_obj[1] ;
29622
29623 if (!args) SWIG_fail;
29624 swig_obj[0] = args;
29625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
29626 if (!SWIG_IsOK(res1)) {
29627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29628 }
29629 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29630 {
29631 PyThreadState* __tstate = wxPyBeginAllowThreads();
29632 delete arg1;
29633
29634 wxPyEndAllowThreads(__tstate);
29635 if (PyErr_Occurred()) SWIG_fail;
29636 }
29637 resultobj = SWIG_Py_Void();
29638 return resultobj;
29639 fail:
29640 return NULL;
29641 }
29642
29643
29644 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29645 PyObject *resultobj = 0;
29646 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29647 PyObject *arg2 = (PyObject *) 0 ;
29648 void *argp1 = 0 ;
29649 int res1 = 0 ;
29650 PyObject * obj0 = 0 ;
29651 PyObject * obj1 = 0 ;
29652 char * kwnames[] = {
29653 (char *) "self",(char *) "self", NULL
29654 };
29655
29656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29658 if (!SWIG_IsOK(res1)) {
29659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29660 }
29661 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29662 arg2 = obj1;
29663 {
29664 PyThreadState* __tstate = wxPyBeginAllowThreads();
29665 (arg1)->SetSelf(arg2);
29666 wxPyEndAllowThreads(__tstate);
29667 if (PyErr_Occurred()) SWIG_fail;
29668 }
29669 resultobj = SWIG_Py_Void();
29670 return resultobj;
29671 fail:
29672 return NULL;
29673 }
29674
29675
29676 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29677 PyObject *resultobj = 0;
29678 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29679 PyObject *result = 0 ;
29680 void *argp1 = 0 ;
29681 int res1 = 0 ;
29682 PyObject *swig_obj[1] ;
29683
29684 if (!args) SWIG_fail;
29685 swig_obj[0] = args;
29686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29687 if (!SWIG_IsOK(res1)) {
29688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29689 }
29690 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29691 {
29692 PyThreadState* __tstate = wxPyBeginAllowThreads();
29693 result = (PyObject *)(arg1)->GetSelf();
29694 wxPyEndAllowThreads(__tstate);
29695 if (PyErr_Occurred()) SWIG_fail;
29696 }
29697 resultobj = result;
29698 return resultobj;
29699 fail:
29700 return NULL;
29701 }
29702
29703
29704 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29705 PyObject *obj;
29706 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29707 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
29708 return SWIG_Py_Void();
29709 }
29710
29711 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29712 return SWIG_Python_InitShadowInstance(args);
29713 }
29714
29715 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29716 PyObject *resultobj = 0;
29717 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29718 int arg2 = (int) 0 ;
29719 wxPyCommandEvent *result = 0 ;
29720 int val1 ;
29721 int ecode1 = 0 ;
29722 int val2 ;
29723 int ecode2 = 0 ;
29724 PyObject * obj0 = 0 ;
29725 PyObject * obj1 = 0 ;
29726 char * kwnames[] = {
29727 (char *) "eventType",(char *) "id", NULL
29728 };
29729
29730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29731 if (obj0) {
29732 ecode1 = SWIG_AsVal_int(obj0, &val1);
29733 if (!SWIG_IsOK(ecode1)) {
29734 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29735 }
29736 arg1 = static_cast< wxEventType >(val1);
29737 }
29738 if (obj1) {
29739 ecode2 = SWIG_AsVal_int(obj1, &val2);
29740 if (!SWIG_IsOK(ecode2)) {
29741 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
29742 }
29743 arg2 = static_cast< int >(val2);
29744 }
29745 {
29746 PyThreadState* __tstate = wxPyBeginAllowThreads();
29747 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
29748 wxPyEndAllowThreads(__tstate);
29749 if (PyErr_Occurred()) SWIG_fail;
29750 }
29751 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
29752 return resultobj;
29753 fail:
29754 return NULL;
29755 }
29756
29757
29758 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29759 PyObject *resultobj = 0;
29760 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29761 void *argp1 = 0 ;
29762 int res1 = 0 ;
29763 PyObject *swig_obj[1] ;
29764
29765 if (!args) SWIG_fail;
29766 swig_obj[0] = args;
29767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
29768 if (!SWIG_IsOK(res1)) {
29769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29770 }
29771 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29772 {
29773 PyThreadState* __tstate = wxPyBeginAllowThreads();
29774 delete arg1;
29775
29776 wxPyEndAllowThreads(__tstate);
29777 if (PyErr_Occurred()) SWIG_fail;
29778 }
29779 resultobj = SWIG_Py_Void();
29780 return resultobj;
29781 fail:
29782 return NULL;
29783 }
29784
29785
29786 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29787 PyObject *resultobj = 0;
29788 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29789 PyObject *arg2 = (PyObject *) 0 ;
29790 void *argp1 = 0 ;
29791 int res1 = 0 ;
29792 PyObject * obj0 = 0 ;
29793 PyObject * obj1 = 0 ;
29794 char * kwnames[] = {
29795 (char *) "self",(char *) "self", NULL
29796 };
29797
29798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29800 if (!SWIG_IsOK(res1)) {
29801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29802 }
29803 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29804 arg2 = obj1;
29805 {
29806 PyThreadState* __tstate = wxPyBeginAllowThreads();
29807 (arg1)->SetSelf(arg2);
29808 wxPyEndAllowThreads(__tstate);
29809 if (PyErr_Occurred()) SWIG_fail;
29810 }
29811 resultobj = SWIG_Py_Void();
29812 return resultobj;
29813 fail:
29814 return NULL;
29815 }
29816
29817
29818 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29819 PyObject *resultobj = 0;
29820 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29821 PyObject *result = 0 ;
29822 void *argp1 = 0 ;
29823 int res1 = 0 ;
29824 PyObject *swig_obj[1] ;
29825
29826 if (!args) SWIG_fail;
29827 swig_obj[0] = args;
29828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29829 if (!SWIG_IsOK(res1)) {
29830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29831 }
29832 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29833 {
29834 PyThreadState* __tstate = wxPyBeginAllowThreads();
29835 result = (PyObject *)(arg1)->GetSelf();
29836 wxPyEndAllowThreads(__tstate);
29837 if (PyErr_Occurred()) SWIG_fail;
29838 }
29839 resultobj = result;
29840 return resultobj;
29841 fail:
29842 return NULL;
29843 }
29844
29845
29846 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29847 PyObject *obj;
29848 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29849 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
29850 return SWIG_Py_Void();
29851 }
29852
29853 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29854 return SWIG_Python_InitShadowInstance(args);
29855 }
29856
29857 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29858 PyObject *resultobj = 0;
29859 wxWindow *arg1 = (wxWindow *) 0 ;
29860 wxDateTime *arg2 = 0 ;
29861 wxEventType arg3 ;
29862 wxDateEvent *result = 0 ;
29863 void *argp1 = 0 ;
29864 int res1 = 0 ;
29865 void *argp2 = 0 ;
29866 int res2 = 0 ;
29867 int val3 ;
29868 int ecode3 = 0 ;
29869 PyObject * obj0 = 0 ;
29870 PyObject * obj1 = 0 ;
29871 PyObject * obj2 = 0 ;
29872 char * kwnames[] = {
29873 (char *) "win",(char *) "dt",(char *) "type", NULL
29874 };
29875
29876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29878 if (!SWIG_IsOK(res1)) {
29879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29880 }
29881 arg1 = reinterpret_cast< wxWindow * >(argp1);
29882 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29883 if (!SWIG_IsOK(res2)) {
29884 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29885 }
29886 if (!argp2) {
29887 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29888 }
29889 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29890 ecode3 = SWIG_AsVal_int(obj2, &val3);
29891 if (!SWIG_IsOK(ecode3)) {
29892 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
29893 }
29894 arg3 = static_cast< wxEventType >(val3);
29895 {
29896 PyThreadState* __tstate = wxPyBeginAllowThreads();
29897 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
29898 wxPyEndAllowThreads(__tstate);
29899 if (PyErr_Occurred()) SWIG_fail;
29900 }
29901 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
29902 return resultobj;
29903 fail:
29904 return NULL;
29905 }
29906
29907
29908 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29909 PyObject *resultobj = 0;
29910 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29911 wxDateTime *result = 0 ;
29912 void *argp1 = 0 ;
29913 int res1 = 0 ;
29914 PyObject *swig_obj[1] ;
29915
29916 if (!args) SWIG_fail;
29917 swig_obj[0] = args;
29918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29919 if (!SWIG_IsOK(res1)) {
29920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
29921 }
29922 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29923 {
29924 PyThreadState* __tstate = wxPyBeginAllowThreads();
29925 {
29926 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
29927 result = (wxDateTime *) &_result_ref;
29928 }
29929 wxPyEndAllowThreads(__tstate);
29930 if (PyErr_Occurred()) SWIG_fail;
29931 }
29932 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
29933 return resultobj;
29934 fail:
29935 return NULL;
29936 }
29937
29938
29939 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29940 PyObject *resultobj = 0;
29941 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29942 wxDateTime *arg2 = 0 ;
29943 void *argp1 = 0 ;
29944 int res1 = 0 ;
29945 void *argp2 = 0 ;
29946 int res2 = 0 ;
29947 PyObject * obj0 = 0 ;
29948 PyObject * obj1 = 0 ;
29949 char * kwnames[] = {
29950 (char *) "self",(char *) "date", NULL
29951 };
29952
29953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
29954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29955 if (!SWIG_IsOK(res1)) {
29956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
29957 }
29958 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29959 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29960 if (!SWIG_IsOK(res2)) {
29961 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29962 }
29963 if (!argp2) {
29964 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29965 }
29966 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29967 {
29968 PyThreadState* __tstate = wxPyBeginAllowThreads();
29969 (arg1)->SetDate((wxDateTime const &)*arg2);
29970 wxPyEndAllowThreads(__tstate);
29971 if (PyErr_Occurred()) SWIG_fail;
29972 }
29973 resultobj = SWIG_Py_Void();
29974 return resultobj;
29975 fail:
29976 return NULL;
29977 }
29978
29979
29980 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29981 PyObject *obj;
29982 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29983 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
29984 return SWIG_Py_Void();
29985 }
29986
29987 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29988 return SWIG_Python_InitShadowInstance(args);
29989 }
29990
29991 SWIGINTERN PyObject *_wrap_new_EventBlocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29992 PyObject *resultobj = 0;
29993 wxWindow *arg1 = (wxWindow *) 0 ;
29994 wxEventType arg2 = (wxEventType) wxEVT_ANY ;
29995 wxEventBlocker *result = 0 ;
29996 void *argp1 = 0 ;
29997 int res1 = 0 ;
29998 int val2 ;
29999 int ecode2 = 0 ;
30000 PyObject * obj0 = 0 ;
30001 PyObject * obj1 = 0 ;
30002 char * kwnames[] = {
30003 (char *) "win",(char *) "type", NULL
30004 };
30005
30006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_EventBlocker",kwnames,&obj0,&obj1)) SWIG_fail;
30007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30008 if (!SWIG_IsOK(res1)) {
30009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventBlocker" "', expected argument " "1"" of type '" "wxWindow *""'");
30010 }
30011 arg1 = reinterpret_cast< wxWindow * >(argp1);
30012 if (obj1) {
30013 ecode2 = SWIG_AsVal_int(obj1, &val2);
30014 if (!SWIG_IsOK(ecode2)) {
30015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EventBlocker" "', expected argument " "2"" of type '" "wxEventType""'");
30016 }
30017 arg2 = static_cast< wxEventType >(val2);
30018 }
30019 {
30020 PyThreadState* __tstate = wxPyBeginAllowThreads();
30021 result = (wxEventBlocker *)new wxEventBlocker(arg1,arg2);
30022 wxPyEndAllowThreads(__tstate);
30023 if (PyErr_Occurred()) SWIG_fail;
30024 }
30025 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventBlocker, SWIG_POINTER_NEW | 0 );
30026 return resultobj;
30027 fail:
30028 return NULL;
30029 }
30030
30031
30032 SWIGINTERN PyObject *_wrap_delete_EventBlocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30033 PyObject *resultobj = 0;
30034 wxEventBlocker *arg1 = (wxEventBlocker *) 0 ;
30035 void *argp1 = 0 ;
30036 int res1 = 0 ;
30037 PyObject *swig_obj[1] ;
30038
30039 if (!args) SWIG_fail;
30040 swig_obj[0] = args;
30041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventBlocker, SWIG_POINTER_DISOWN | 0 );
30042 if (!SWIG_IsOK(res1)) {
30043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventBlocker" "', expected argument " "1"" of type '" "wxEventBlocker *""'");
30044 }
30045 arg1 = reinterpret_cast< wxEventBlocker * >(argp1);
30046 {
30047 PyThreadState* __tstate = wxPyBeginAllowThreads();
30048 delete arg1;
30049
30050 wxPyEndAllowThreads(__tstate);
30051 if (PyErr_Occurred()) SWIG_fail;
30052 }
30053 resultobj = SWIG_Py_Void();
30054 return resultobj;
30055 fail:
30056 return NULL;
30057 }
30058
30059
30060 SWIGINTERN PyObject *_wrap_EventBlocker_Block(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30061 PyObject *resultobj = 0;
30062 wxEventBlocker *arg1 = (wxEventBlocker *) 0 ;
30063 wxEventType arg2 ;
30064 void *argp1 = 0 ;
30065 int res1 = 0 ;
30066 int val2 ;
30067 int ecode2 = 0 ;
30068 PyObject * obj0 = 0 ;
30069 PyObject * obj1 = 0 ;
30070 char * kwnames[] = {
30071 (char *) "self",(char *) "type", NULL
30072 };
30073
30074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EventBlocker_Block",kwnames,&obj0,&obj1)) SWIG_fail;
30075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventBlocker, 0 | 0 );
30076 if (!SWIG_IsOK(res1)) {
30077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventBlocker_Block" "', expected argument " "1"" of type '" "wxEventBlocker *""'");
30078 }
30079 arg1 = reinterpret_cast< wxEventBlocker * >(argp1);
30080 ecode2 = SWIG_AsVal_int(obj1, &val2);
30081 if (!SWIG_IsOK(ecode2)) {
30082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventBlocker_Block" "', expected argument " "2"" of type '" "wxEventType""'");
30083 }
30084 arg2 = static_cast< wxEventType >(val2);
30085 {
30086 PyThreadState* __tstate = wxPyBeginAllowThreads();
30087 (arg1)->Block(arg2);
30088 wxPyEndAllowThreads(__tstate);
30089 if (PyErr_Occurred()) SWIG_fail;
30090 }
30091 resultobj = SWIG_Py_Void();
30092 return resultobj;
30093 fail:
30094 return NULL;
30095 }
30096
30097
30098 SWIGINTERN PyObject *EventBlocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30099 PyObject *obj;
30100 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30101 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventBlocker, SWIG_NewClientData(obj));
30102 return SWIG_Py_Void();
30103 }
30104
30105 SWIGINTERN PyObject *EventBlocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30106 return SWIG_Python_InitShadowInstance(args);
30107 }
30108
30109 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30110 PyObject *resultobj = 0;
30111 wxPyApp *result = 0 ;
30112
30113 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
30114 {
30115 PyThreadState* __tstate = wxPyBeginAllowThreads();
30116 result = (wxPyApp *)new_wxPyApp();
30117 wxPyEndAllowThreads(__tstate);
30118 if (PyErr_Occurred()) SWIG_fail;
30119 }
30120 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
30121 return resultobj;
30122 fail:
30123 return NULL;
30124 }
30125
30126
30127 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30128 PyObject *resultobj = 0;
30129 wxPyApp *arg1 = (wxPyApp *) 0 ;
30130 void *argp1 = 0 ;
30131 int res1 = 0 ;
30132 PyObject *swig_obj[1] ;
30133
30134 if (!args) SWIG_fail;
30135 swig_obj[0] = args;
30136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
30137 if (!SWIG_IsOK(res1)) {
30138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
30139 }
30140 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30141 {
30142 PyThreadState* __tstate = wxPyBeginAllowThreads();
30143 delete arg1;
30144
30145 wxPyEndAllowThreads(__tstate);
30146 if (PyErr_Occurred()) SWIG_fail;
30147 }
30148 resultobj = SWIG_Py_Void();
30149 return resultobj;
30150 fail:
30151 return NULL;
30152 }
30153
30154
30155 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30156 PyObject *resultobj = 0;
30157 wxPyApp *arg1 = (wxPyApp *) 0 ;
30158 PyObject *arg2 = (PyObject *) 0 ;
30159 PyObject *arg3 = (PyObject *) 0 ;
30160 bool arg4 = (bool) false ;
30161 void *argp1 = 0 ;
30162 int res1 = 0 ;
30163 bool val4 ;
30164 int ecode4 = 0 ;
30165 PyObject * obj0 = 0 ;
30166 PyObject * obj1 = 0 ;
30167 PyObject * obj2 = 0 ;
30168 PyObject * obj3 = 0 ;
30169 char * kwnames[] = {
30170 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
30171 };
30172
30173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30175 if (!SWIG_IsOK(res1)) {
30176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
30177 }
30178 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30179 arg2 = obj1;
30180 arg3 = obj2;
30181 if (obj3) {
30182 ecode4 = SWIG_AsVal_bool(obj3, &val4);
30183 if (!SWIG_IsOK(ecode4)) {
30184 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
30185 }
30186 arg4 = static_cast< bool >(val4);
30187 }
30188 {
30189 PyThreadState* __tstate = wxPyBeginAllowThreads();
30190 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
30191 wxPyEndAllowThreads(__tstate);
30192 if (PyErr_Occurred()) SWIG_fail;
30193 }
30194 resultobj = SWIG_Py_Void();
30195 return resultobj;
30196 fail:
30197 return NULL;
30198 }
30199
30200
30201 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30202 PyObject *resultobj = 0;
30203 wxPyApp *arg1 = (wxPyApp *) 0 ;
30204 wxString result;
30205 void *argp1 = 0 ;
30206 int res1 = 0 ;
30207 PyObject *swig_obj[1] ;
30208
30209 if (!args) SWIG_fail;
30210 swig_obj[0] = args;
30211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30212 if (!SWIG_IsOK(res1)) {
30213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30214 }
30215 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30216 {
30217 PyThreadState* __tstate = wxPyBeginAllowThreads();
30218 result = ((wxPyApp const *)arg1)->GetAppName();
30219 wxPyEndAllowThreads(__tstate);
30220 if (PyErr_Occurred()) SWIG_fail;
30221 }
30222 {
30223 #if wxUSE_UNICODE
30224 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30225 #else
30226 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30227 #endif
30228 }
30229 return resultobj;
30230 fail:
30231 return NULL;
30232 }
30233
30234
30235 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30236 PyObject *resultobj = 0;
30237 wxPyApp *arg1 = (wxPyApp *) 0 ;
30238 wxString *arg2 = 0 ;
30239 void *argp1 = 0 ;
30240 int res1 = 0 ;
30241 bool temp2 = false ;
30242 PyObject * obj0 = 0 ;
30243 PyObject * obj1 = 0 ;
30244 char * kwnames[] = {
30245 (char *) "self",(char *) "name", NULL
30246 };
30247
30248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
30249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30250 if (!SWIG_IsOK(res1)) {
30251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30252 }
30253 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30254 {
30255 arg2 = wxString_in_helper(obj1);
30256 if (arg2 == NULL) SWIG_fail;
30257 temp2 = true;
30258 }
30259 {
30260 PyThreadState* __tstate = wxPyBeginAllowThreads();
30261 (arg1)->SetAppName((wxString const &)*arg2);
30262 wxPyEndAllowThreads(__tstate);
30263 if (PyErr_Occurred()) SWIG_fail;
30264 }
30265 resultobj = SWIG_Py_Void();
30266 {
30267 if (temp2)
30268 delete arg2;
30269 }
30270 return resultobj;
30271 fail:
30272 {
30273 if (temp2)
30274 delete arg2;
30275 }
30276 return NULL;
30277 }
30278
30279
30280 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30281 PyObject *resultobj = 0;
30282 wxPyApp *arg1 = (wxPyApp *) 0 ;
30283 wxString result;
30284 void *argp1 = 0 ;
30285 int res1 = 0 ;
30286 PyObject *swig_obj[1] ;
30287
30288 if (!args) SWIG_fail;
30289 swig_obj[0] = args;
30290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30291 if (!SWIG_IsOK(res1)) {
30292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30293 }
30294 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30295 {
30296 PyThreadState* __tstate = wxPyBeginAllowThreads();
30297 result = ((wxPyApp const *)arg1)->GetClassName();
30298 wxPyEndAllowThreads(__tstate);
30299 if (PyErr_Occurred()) SWIG_fail;
30300 }
30301 {
30302 #if wxUSE_UNICODE
30303 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30304 #else
30305 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30306 #endif
30307 }
30308 return resultobj;
30309 fail:
30310 return NULL;
30311 }
30312
30313
30314 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30315 PyObject *resultobj = 0;
30316 wxPyApp *arg1 = (wxPyApp *) 0 ;
30317 wxString *arg2 = 0 ;
30318 void *argp1 = 0 ;
30319 int res1 = 0 ;
30320 bool temp2 = false ;
30321 PyObject * obj0 = 0 ;
30322 PyObject * obj1 = 0 ;
30323 char * kwnames[] = {
30324 (char *) "self",(char *) "name", NULL
30325 };
30326
30327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
30328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30329 if (!SWIG_IsOK(res1)) {
30330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30331 }
30332 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30333 {
30334 arg2 = wxString_in_helper(obj1);
30335 if (arg2 == NULL) SWIG_fail;
30336 temp2 = true;
30337 }
30338 {
30339 PyThreadState* __tstate = wxPyBeginAllowThreads();
30340 (arg1)->SetClassName((wxString const &)*arg2);
30341 wxPyEndAllowThreads(__tstate);
30342 if (PyErr_Occurred()) SWIG_fail;
30343 }
30344 resultobj = SWIG_Py_Void();
30345 {
30346 if (temp2)
30347 delete arg2;
30348 }
30349 return resultobj;
30350 fail:
30351 {
30352 if (temp2)
30353 delete arg2;
30354 }
30355 return NULL;
30356 }
30357
30358
30359 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30360 PyObject *resultobj = 0;
30361 wxPyApp *arg1 = (wxPyApp *) 0 ;
30362 wxString *result = 0 ;
30363 void *argp1 = 0 ;
30364 int res1 = 0 ;
30365 PyObject *swig_obj[1] ;
30366
30367 if (!args) SWIG_fail;
30368 swig_obj[0] = args;
30369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30370 if (!SWIG_IsOK(res1)) {
30371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30372 }
30373 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30374 {
30375 PyThreadState* __tstate = wxPyBeginAllowThreads();
30376 {
30377 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
30378 result = (wxString *) &_result_ref;
30379 }
30380 wxPyEndAllowThreads(__tstate);
30381 if (PyErr_Occurred()) SWIG_fail;
30382 }
30383 {
30384 #if wxUSE_UNICODE
30385 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
30386 #else
30387 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
30388 #endif
30389 }
30390 return resultobj;
30391 fail:
30392 return NULL;
30393 }
30394
30395
30396 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30397 PyObject *resultobj = 0;
30398 wxPyApp *arg1 = (wxPyApp *) 0 ;
30399 wxString *arg2 = 0 ;
30400 void *argp1 = 0 ;
30401 int res1 = 0 ;
30402 bool temp2 = false ;
30403 PyObject * obj0 = 0 ;
30404 PyObject * obj1 = 0 ;
30405 char * kwnames[] = {
30406 (char *) "self",(char *) "name", NULL
30407 };
30408
30409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
30410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30411 if (!SWIG_IsOK(res1)) {
30412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30413 }
30414 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30415 {
30416 arg2 = wxString_in_helper(obj1);
30417 if (arg2 == NULL) SWIG_fail;
30418 temp2 = true;
30419 }
30420 {
30421 PyThreadState* __tstate = wxPyBeginAllowThreads();
30422 (arg1)->SetVendorName((wxString const &)*arg2);
30423 wxPyEndAllowThreads(__tstate);
30424 if (PyErr_Occurred()) SWIG_fail;
30425 }
30426 resultobj = SWIG_Py_Void();
30427 {
30428 if (temp2)
30429 delete arg2;
30430 }
30431 return resultobj;
30432 fail:
30433 {
30434 if (temp2)
30435 delete arg2;
30436 }
30437 return NULL;
30438 }
30439
30440
30441 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30442 PyObject *resultobj = 0;
30443 wxPyApp *arg1 = (wxPyApp *) 0 ;
30444 wxAppTraits *result = 0 ;
30445 void *argp1 = 0 ;
30446 int res1 = 0 ;
30447 PyObject *swig_obj[1] ;
30448
30449 if (!args) SWIG_fail;
30450 swig_obj[0] = args;
30451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30452 if (!SWIG_IsOK(res1)) {
30453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
30454 }
30455 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30456 {
30457 PyThreadState* __tstate = wxPyBeginAllowThreads();
30458 result = (wxAppTraits *)(arg1)->GetTraits();
30459 wxPyEndAllowThreads(__tstate);
30460 if (PyErr_Occurred()) SWIG_fail;
30461 }
30462 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
30463 return resultobj;
30464 fail:
30465 return NULL;
30466 }
30467
30468
30469 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30470 PyObject *resultobj = 0;
30471 wxPyApp *arg1 = (wxPyApp *) 0 ;
30472 void *argp1 = 0 ;
30473 int res1 = 0 ;
30474 PyObject *swig_obj[1] ;
30475
30476 if (!args) SWIG_fail;
30477 swig_obj[0] = args;
30478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30479 if (!SWIG_IsOK(res1)) {
30480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30481 }
30482 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30483 {
30484 PyThreadState* __tstate = wxPyBeginAllowThreads();
30485 (arg1)->ProcessPendingEvents();
30486 wxPyEndAllowThreads(__tstate);
30487 if (PyErr_Occurred()) SWIG_fail;
30488 }
30489 resultobj = SWIG_Py_Void();
30490 return resultobj;
30491 fail:
30492 return NULL;
30493 }
30494
30495
30496 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30497 PyObject *resultobj = 0;
30498 wxPyApp *arg1 = (wxPyApp *) 0 ;
30499 bool arg2 = (bool) false ;
30500 bool result;
30501 void *argp1 = 0 ;
30502 int res1 = 0 ;
30503 bool val2 ;
30504 int ecode2 = 0 ;
30505 PyObject * obj0 = 0 ;
30506 PyObject * obj1 = 0 ;
30507 char * kwnames[] = {
30508 (char *) "self",(char *) "onlyIfNeeded", NULL
30509 };
30510
30511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
30512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30513 if (!SWIG_IsOK(res1)) {
30514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
30515 }
30516 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30517 if (obj1) {
30518 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30519 if (!SWIG_IsOK(ecode2)) {
30520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
30521 }
30522 arg2 = static_cast< bool >(val2);
30523 }
30524 {
30525 PyThreadState* __tstate = wxPyBeginAllowThreads();
30526 result = (bool)(arg1)->Yield(arg2);
30527 wxPyEndAllowThreads(__tstate);
30528 if (PyErr_Occurred()) SWIG_fail;
30529 }
30530 {
30531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30532 }
30533 return resultobj;
30534 fail:
30535 return NULL;
30536 }
30537
30538
30539 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30540 PyObject *resultobj = 0;
30541 wxPyApp *arg1 = (wxPyApp *) 0 ;
30542 void *argp1 = 0 ;
30543 int res1 = 0 ;
30544 PyObject *swig_obj[1] ;
30545
30546 if (!args) SWIG_fail;
30547 swig_obj[0] = args;
30548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30549 if (!SWIG_IsOK(res1)) {
30550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30551 }
30552 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30553 {
30554 PyThreadState* __tstate = wxPyBeginAllowThreads();
30555 (arg1)->WakeUpIdle();
30556 wxPyEndAllowThreads(__tstate);
30557 if (PyErr_Occurred()) SWIG_fail;
30558 }
30559 resultobj = SWIG_Py_Void();
30560 return resultobj;
30561 fail:
30562 return NULL;
30563 }
30564
30565
30566 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30567 PyObject *resultobj = 0;
30568 bool result;
30569
30570 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
30571 {
30572 PyThreadState* __tstate = wxPyBeginAllowThreads();
30573 result = (bool)wxPyApp::IsMainLoopRunning();
30574 wxPyEndAllowThreads(__tstate);
30575 if (PyErr_Occurred()) SWIG_fail;
30576 }
30577 {
30578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30579 }
30580 return resultobj;
30581 fail:
30582 return NULL;
30583 }
30584
30585
30586 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30587 PyObject *resultobj = 0;
30588 wxPyApp *arg1 = (wxPyApp *) 0 ;
30589 int result;
30590 void *argp1 = 0 ;
30591 int res1 = 0 ;
30592 PyObject *swig_obj[1] ;
30593
30594 if (!args) SWIG_fail;
30595 swig_obj[0] = args;
30596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30597 if (!SWIG_IsOK(res1)) {
30598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30599 }
30600 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30601 {
30602 PyThreadState* __tstate = wxPyBeginAllowThreads();
30603 result = (int)(arg1)->MainLoop();
30604 wxPyEndAllowThreads(__tstate);
30605 if (PyErr_Occurred()) SWIG_fail;
30606 }
30607 resultobj = SWIG_From_int(static_cast< int >(result));
30608 return resultobj;
30609 fail:
30610 return NULL;
30611 }
30612
30613
30614 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30615 PyObject *resultobj = 0;
30616 wxPyApp *arg1 = (wxPyApp *) 0 ;
30617 void *argp1 = 0 ;
30618 int res1 = 0 ;
30619 PyObject *swig_obj[1] ;
30620
30621 if (!args) SWIG_fail;
30622 swig_obj[0] = args;
30623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30624 if (!SWIG_IsOK(res1)) {
30625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
30626 }
30627 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30628 {
30629 PyThreadState* __tstate = wxPyBeginAllowThreads();
30630 (arg1)->Exit();
30631 wxPyEndAllowThreads(__tstate);
30632 if (PyErr_Occurred()) SWIG_fail;
30633 }
30634 resultobj = SWIG_Py_Void();
30635 return resultobj;
30636 fail:
30637 return NULL;
30638 }
30639
30640
30641 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30642 PyObject *resultobj = 0;
30643 wxPyApp *arg1 = (wxPyApp *) 0 ;
30644 wxLayoutDirection result;
30645 void *argp1 = 0 ;
30646 int res1 = 0 ;
30647 PyObject *swig_obj[1] ;
30648
30649 if (!args) SWIG_fail;
30650 swig_obj[0] = args;
30651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30652 if (!SWIG_IsOK(res1)) {
30653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30654 }
30655 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30656 {
30657 PyThreadState* __tstate = wxPyBeginAllowThreads();
30658 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
30659 wxPyEndAllowThreads(__tstate);
30660 if (PyErr_Occurred()) SWIG_fail;
30661 }
30662 resultobj = SWIG_From_int(static_cast< int >(result));
30663 return resultobj;
30664 fail:
30665 return NULL;
30666 }
30667
30668
30669 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30670 PyObject *resultobj = 0;
30671 wxPyApp *arg1 = (wxPyApp *) 0 ;
30672 void *argp1 = 0 ;
30673 int res1 = 0 ;
30674 PyObject *swig_obj[1] ;
30675
30676 if (!args) SWIG_fail;
30677 swig_obj[0] = args;
30678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30679 if (!SWIG_IsOK(res1)) {
30680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30681 }
30682 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30683 {
30684 PyThreadState* __tstate = wxPyBeginAllowThreads();
30685 (arg1)->ExitMainLoop();
30686 wxPyEndAllowThreads(__tstate);
30687 if (PyErr_Occurred()) SWIG_fail;
30688 }
30689 resultobj = SWIG_Py_Void();
30690 return resultobj;
30691 fail:
30692 return NULL;
30693 }
30694
30695
30696 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30697 PyObject *resultobj = 0;
30698 wxPyApp *arg1 = (wxPyApp *) 0 ;
30699 bool result;
30700 void *argp1 = 0 ;
30701 int res1 = 0 ;
30702 PyObject *swig_obj[1] ;
30703
30704 if (!args) SWIG_fail;
30705 swig_obj[0] = args;
30706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30707 if (!SWIG_IsOK(res1)) {
30708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
30709 }
30710 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30711 {
30712 PyThreadState* __tstate = wxPyBeginAllowThreads();
30713 result = (bool)(arg1)->Pending();
30714 wxPyEndAllowThreads(__tstate);
30715 if (PyErr_Occurred()) SWIG_fail;
30716 }
30717 {
30718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30719 }
30720 return resultobj;
30721 fail:
30722 return NULL;
30723 }
30724
30725
30726 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30727 PyObject *resultobj = 0;
30728 wxPyApp *arg1 = (wxPyApp *) 0 ;
30729 bool result;
30730 void *argp1 = 0 ;
30731 int res1 = 0 ;
30732 PyObject *swig_obj[1] ;
30733
30734 if (!args) SWIG_fail;
30735 swig_obj[0] = args;
30736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30737 if (!SWIG_IsOK(res1)) {
30738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
30739 }
30740 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30741 {
30742 PyThreadState* __tstate = wxPyBeginAllowThreads();
30743 result = (bool)(arg1)->Dispatch();
30744 wxPyEndAllowThreads(__tstate);
30745 if (PyErr_Occurred()) SWIG_fail;
30746 }
30747 {
30748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30749 }
30750 return resultobj;
30751 fail:
30752 return NULL;
30753 }
30754
30755
30756 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30757 PyObject *resultobj = 0;
30758 wxPyApp *arg1 = (wxPyApp *) 0 ;
30759 bool result;
30760 void *argp1 = 0 ;
30761 int res1 = 0 ;
30762 PyObject *swig_obj[1] ;
30763
30764 if (!args) SWIG_fail;
30765 swig_obj[0] = args;
30766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30767 if (!SWIG_IsOK(res1)) {
30768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30769 }
30770 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30771 {
30772 PyThreadState* __tstate = wxPyBeginAllowThreads();
30773 result = (bool)(arg1)->ProcessIdle();
30774 wxPyEndAllowThreads(__tstate);
30775 if (PyErr_Occurred()) SWIG_fail;
30776 }
30777 {
30778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30779 }
30780 return resultobj;
30781 fail:
30782 return NULL;
30783 }
30784
30785
30786 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30787 PyObject *resultobj = 0;
30788 wxPyApp *arg1 = (wxPyApp *) 0 ;
30789 wxWindow *arg2 = (wxWindow *) 0 ;
30790 wxIdleEvent *arg3 = 0 ;
30791 bool result;
30792 void *argp1 = 0 ;
30793 int res1 = 0 ;
30794 void *argp2 = 0 ;
30795 int res2 = 0 ;
30796 void *argp3 = 0 ;
30797 int res3 = 0 ;
30798 PyObject * obj0 = 0 ;
30799 PyObject * obj1 = 0 ;
30800 PyObject * obj2 = 0 ;
30801 char * kwnames[] = {
30802 (char *) "self",(char *) "win",(char *) "event", NULL
30803 };
30804
30805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30807 if (!SWIG_IsOK(res1)) {
30808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30809 }
30810 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30811 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30812 if (!SWIG_IsOK(res2)) {
30813 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
30814 }
30815 arg2 = reinterpret_cast< wxWindow * >(argp2);
30816 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
30817 if (!SWIG_IsOK(res3)) {
30818 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30819 }
30820 if (!argp3) {
30821 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30822 }
30823 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
30824 {
30825 PyThreadState* __tstate = wxPyBeginAllowThreads();
30826 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
30827 wxPyEndAllowThreads(__tstate);
30828 if (PyErr_Occurred()) SWIG_fail;
30829 }
30830 {
30831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30832 }
30833 return resultobj;
30834 fail:
30835 return NULL;
30836 }
30837
30838
30839 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30840 PyObject *resultobj = 0;
30841 wxPyApp *arg1 = (wxPyApp *) 0 ;
30842 bool result;
30843 void *argp1 = 0 ;
30844 int res1 = 0 ;
30845 PyObject *swig_obj[1] ;
30846
30847 if (!args) SWIG_fail;
30848 swig_obj[0] = args;
30849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30850 if (!SWIG_IsOK(res1)) {
30851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30852 }
30853 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30854 {
30855 PyThreadState* __tstate = wxPyBeginAllowThreads();
30856 result = (bool)((wxPyApp const *)arg1)->IsActive();
30857 wxPyEndAllowThreads(__tstate);
30858 if (PyErr_Occurred()) SWIG_fail;
30859 }
30860 {
30861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30862 }
30863 return resultobj;
30864 fail:
30865 return NULL;
30866 }
30867
30868
30869 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30870 PyObject *resultobj = 0;
30871 wxPyApp *arg1 = (wxPyApp *) 0 ;
30872 wxWindow *arg2 = (wxWindow *) 0 ;
30873 void *argp1 = 0 ;
30874 int res1 = 0 ;
30875 void *argp2 = 0 ;
30876 int res2 = 0 ;
30877 PyObject * obj0 = 0 ;
30878 PyObject * obj1 = 0 ;
30879 char * kwnames[] = {
30880 (char *) "self",(char *) "win", NULL
30881 };
30882
30883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
30884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30885 if (!SWIG_IsOK(res1)) {
30886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
30887 }
30888 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30889 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30890 if (!SWIG_IsOK(res2)) {
30891 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
30892 }
30893 arg2 = reinterpret_cast< wxWindow * >(argp2);
30894 {
30895 PyThreadState* __tstate = wxPyBeginAllowThreads();
30896 (arg1)->SetTopWindow(arg2);
30897 wxPyEndAllowThreads(__tstate);
30898 if (PyErr_Occurred()) SWIG_fail;
30899 }
30900 resultobj = SWIG_Py_Void();
30901 return resultobj;
30902 fail:
30903 return NULL;
30904 }
30905
30906
30907 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30908 PyObject *resultobj = 0;
30909 wxPyApp *arg1 = (wxPyApp *) 0 ;
30910 wxWindow *result = 0 ;
30911 void *argp1 = 0 ;
30912 int res1 = 0 ;
30913 PyObject *swig_obj[1] ;
30914
30915 if (!args) SWIG_fail;
30916 swig_obj[0] = args;
30917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30918 if (!SWIG_IsOK(res1)) {
30919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30920 }
30921 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30922 {
30923 PyThreadState* __tstate = wxPyBeginAllowThreads();
30924 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
30925 wxPyEndAllowThreads(__tstate);
30926 if (PyErr_Occurred()) SWIG_fail;
30927 }
30928 {
30929 resultobj = wxPyMake_wxObject(result, (bool)0);
30930 }
30931 return resultobj;
30932 fail:
30933 return NULL;
30934 }
30935
30936
30937 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30938 PyObject *resultobj = 0;
30939 wxPyApp *arg1 = (wxPyApp *) 0 ;
30940 bool arg2 ;
30941 void *argp1 = 0 ;
30942 int res1 = 0 ;
30943 bool val2 ;
30944 int ecode2 = 0 ;
30945 PyObject * obj0 = 0 ;
30946 PyObject * obj1 = 0 ;
30947 char * kwnames[] = {
30948 (char *) "self",(char *) "flag", NULL
30949 };
30950
30951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
30952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30953 if (!SWIG_IsOK(res1)) {
30954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
30955 }
30956 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30957 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30958 if (!SWIG_IsOK(ecode2)) {
30959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
30960 }
30961 arg2 = static_cast< bool >(val2);
30962 {
30963 PyThreadState* __tstate = wxPyBeginAllowThreads();
30964 (arg1)->SetExitOnFrameDelete(arg2);
30965 wxPyEndAllowThreads(__tstate);
30966 if (PyErr_Occurred()) SWIG_fail;
30967 }
30968 resultobj = SWIG_Py_Void();
30969 return resultobj;
30970 fail:
30971 return NULL;
30972 }
30973
30974
30975 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30976 PyObject *resultobj = 0;
30977 wxPyApp *arg1 = (wxPyApp *) 0 ;
30978 bool result;
30979 void *argp1 = 0 ;
30980 int res1 = 0 ;
30981 PyObject *swig_obj[1] ;
30982
30983 if (!args) SWIG_fail;
30984 swig_obj[0] = args;
30985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30986 if (!SWIG_IsOK(res1)) {
30987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30988 }
30989 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30990 {
30991 PyThreadState* __tstate = wxPyBeginAllowThreads();
30992 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
30993 wxPyEndAllowThreads(__tstate);
30994 if (PyErr_Occurred()) SWIG_fail;
30995 }
30996 {
30997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30998 }
30999 return resultobj;
31000 fail:
31001 return NULL;
31002 }
31003
31004
31005 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31006 PyObject *resultobj = 0;
31007 wxPyApp *arg1 = (wxPyApp *) 0 ;
31008 bool arg2 ;
31009 bool arg3 = (bool) false ;
31010 void *argp1 = 0 ;
31011 int res1 = 0 ;
31012 bool val2 ;
31013 int ecode2 = 0 ;
31014 bool val3 ;
31015 int ecode3 = 0 ;
31016 PyObject * obj0 = 0 ;
31017 PyObject * obj1 = 0 ;
31018 PyObject * obj2 = 0 ;
31019 char * kwnames[] = {
31020 (char *) "self",(char *) "flag",(char *) "forceTrueColour", NULL
31021 };
31022
31023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31025 if (!SWIG_IsOK(res1)) {
31026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
31027 }
31028 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31029 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31030 if (!SWIG_IsOK(ecode2)) {
31031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
31032 }
31033 arg2 = static_cast< bool >(val2);
31034 if (obj2) {
31035 ecode3 = SWIG_AsVal_bool(obj2, &val3);
31036 if (!SWIG_IsOK(ecode3)) {
31037 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "3"" of type '" "bool""'");
31038 }
31039 arg3 = static_cast< bool >(val3);
31040 }
31041 {
31042 PyThreadState* __tstate = wxPyBeginAllowThreads();
31043 (arg1)->SetUseBestVisual(arg2,arg3);
31044 wxPyEndAllowThreads(__tstate);
31045 if (PyErr_Occurred()) SWIG_fail;
31046 }
31047 resultobj = SWIG_Py_Void();
31048 return resultobj;
31049 fail:
31050 return NULL;
31051 }
31052
31053
31054 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31055 PyObject *resultobj = 0;
31056 wxPyApp *arg1 = (wxPyApp *) 0 ;
31057 bool result;
31058 void *argp1 = 0 ;
31059 int res1 = 0 ;
31060 PyObject *swig_obj[1] ;
31061
31062 if (!args) SWIG_fail;
31063 swig_obj[0] = args;
31064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31065 if (!SWIG_IsOK(res1)) {
31066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31067 }
31068 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31069 {
31070 PyThreadState* __tstate = wxPyBeginAllowThreads();
31071 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
31072 wxPyEndAllowThreads(__tstate);
31073 if (PyErr_Occurred()) SWIG_fail;
31074 }
31075 {
31076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31077 }
31078 return resultobj;
31079 fail:
31080 return NULL;
31081 }
31082
31083
31084 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31085 PyObject *resultobj = 0;
31086 wxPyApp *arg1 = (wxPyApp *) 0 ;
31087 int arg2 ;
31088 void *argp1 = 0 ;
31089 int res1 = 0 ;
31090 int val2 ;
31091 int ecode2 = 0 ;
31092 PyObject * obj0 = 0 ;
31093 PyObject * obj1 = 0 ;
31094 char * kwnames[] = {
31095 (char *) "self",(char *) "mode", NULL
31096 };
31097
31098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
31099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31100 if (!SWIG_IsOK(res1)) {
31101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31102 }
31103 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31104 ecode2 = SWIG_AsVal_int(obj1, &val2);
31105 if (!SWIG_IsOK(ecode2)) {
31106 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
31107 }
31108 arg2 = static_cast< int >(val2);
31109 {
31110 PyThreadState* __tstate = wxPyBeginAllowThreads();
31111 (arg1)->SetPrintMode(arg2);
31112 wxPyEndAllowThreads(__tstate);
31113 if (PyErr_Occurred()) SWIG_fail;
31114 }
31115 resultobj = SWIG_Py_Void();
31116 return resultobj;
31117 fail:
31118 return NULL;
31119 }
31120
31121
31122 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31123 PyObject *resultobj = 0;
31124 wxPyApp *arg1 = (wxPyApp *) 0 ;
31125 int result;
31126 void *argp1 = 0 ;
31127 int res1 = 0 ;
31128 PyObject *swig_obj[1] ;
31129
31130 if (!args) SWIG_fail;
31131 swig_obj[0] = args;
31132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31133 if (!SWIG_IsOK(res1)) {
31134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31135 }
31136 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31137 {
31138 PyThreadState* __tstate = wxPyBeginAllowThreads();
31139 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
31140 wxPyEndAllowThreads(__tstate);
31141 if (PyErr_Occurred()) SWIG_fail;
31142 }
31143 resultobj = SWIG_From_int(static_cast< int >(result));
31144 return resultobj;
31145 fail:
31146 return NULL;
31147 }
31148
31149
31150 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31151 PyObject *resultobj = 0;
31152 wxPyApp *arg1 = (wxPyApp *) 0 ;
31153 int arg2 ;
31154 void *argp1 = 0 ;
31155 int res1 = 0 ;
31156 int val2 ;
31157 int ecode2 = 0 ;
31158 PyObject * obj0 = 0 ;
31159 PyObject * obj1 = 0 ;
31160 char * kwnames[] = {
31161 (char *) "self",(char *) "mode", NULL
31162 };
31163
31164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
31165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31166 if (!SWIG_IsOK(res1)) {
31167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31168 }
31169 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31170 ecode2 = SWIG_AsVal_int(obj1, &val2);
31171 if (!SWIG_IsOK(ecode2)) {
31172 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
31173 }
31174 arg2 = static_cast< int >(val2);
31175 {
31176 PyThreadState* __tstate = wxPyBeginAllowThreads();
31177 (arg1)->SetAssertMode(arg2);
31178 wxPyEndAllowThreads(__tstate);
31179 if (PyErr_Occurred()) SWIG_fail;
31180 }
31181 resultobj = SWIG_Py_Void();
31182 return resultobj;
31183 fail:
31184 return NULL;
31185 }
31186
31187
31188 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31189 PyObject *resultobj = 0;
31190 wxPyApp *arg1 = (wxPyApp *) 0 ;
31191 int result;
31192 void *argp1 = 0 ;
31193 int res1 = 0 ;
31194 PyObject *swig_obj[1] ;
31195
31196 if (!args) SWIG_fail;
31197 swig_obj[0] = args;
31198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31199 if (!SWIG_IsOK(res1)) {
31200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31201 }
31202 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31203 {
31204 PyThreadState* __tstate = wxPyBeginAllowThreads();
31205 result = (int)(arg1)->GetAssertMode();
31206 wxPyEndAllowThreads(__tstate);
31207 if (PyErr_Occurred()) SWIG_fail;
31208 }
31209 resultobj = SWIG_From_int(static_cast< int >(result));
31210 return resultobj;
31211 fail:
31212 return NULL;
31213 }
31214
31215
31216 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31217 PyObject *resultobj = 0;
31218 bool result;
31219
31220 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
31221 {
31222 PyThreadState* __tstate = wxPyBeginAllowThreads();
31223 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
31224 wxPyEndAllowThreads(__tstate);
31225 if (PyErr_Occurred()) SWIG_fail;
31226 }
31227 {
31228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31229 }
31230 return resultobj;
31231 fail:
31232 return NULL;
31233 }
31234
31235
31236 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31237 PyObject *resultobj = 0;
31238 long result;
31239
31240 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
31241 {
31242 PyThreadState* __tstate = wxPyBeginAllowThreads();
31243 result = (long)wxPyApp::GetMacAboutMenuItemId();
31244 wxPyEndAllowThreads(__tstate);
31245 if (PyErr_Occurred()) SWIG_fail;
31246 }
31247 resultobj = SWIG_From_long(static_cast< long >(result));
31248 return resultobj;
31249 fail:
31250 return NULL;
31251 }
31252
31253
31254 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31255 PyObject *resultobj = 0;
31256 long result;
31257
31258 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
31259 {
31260 PyThreadState* __tstate = wxPyBeginAllowThreads();
31261 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
31262 wxPyEndAllowThreads(__tstate);
31263 if (PyErr_Occurred()) SWIG_fail;
31264 }
31265 resultobj = SWIG_From_long(static_cast< long >(result));
31266 return resultobj;
31267 fail:
31268 return NULL;
31269 }
31270
31271
31272 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31273 PyObject *resultobj = 0;
31274 long result;
31275
31276 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
31277 {
31278 PyThreadState* __tstate = wxPyBeginAllowThreads();
31279 result = (long)wxPyApp::GetMacExitMenuItemId();
31280 wxPyEndAllowThreads(__tstate);
31281 if (PyErr_Occurred()) SWIG_fail;
31282 }
31283 resultobj = SWIG_From_long(static_cast< long >(result));
31284 return resultobj;
31285 fail:
31286 return NULL;
31287 }
31288
31289
31290 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31291 PyObject *resultobj = 0;
31292 wxString result;
31293
31294 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
31295 {
31296 PyThreadState* __tstate = wxPyBeginAllowThreads();
31297 result = wxPyApp::GetMacHelpMenuTitleName();
31298 wxPyEndAllowThreads(__tstate);
31299 if (PyErr_Occurred()) SWIG_fail;
31300 }
31301 {
31302 #if wxUSE_UNICODE
31303 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31304 #else
31305 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31306 #endif
31307 }
31308 return resultobj;
31309 fail:
31310 return NULL;
31311 }
31312
31313
31314 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31315 PyObject *resultobj = 0;
31316 bool arg1 ;
31317 bool val1 ;
31318 int ecode1 = 0 ;
31319 PyObject * obj0 = 0 ;
31320 char * kwnames[] = {
31321 (char *) "val", NULL
31322 };
31323
31324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
31325 ecode1 = SWIG_AsVal_bool(obj0, &val1);
31326 if (!SWIG_IsOK(ecode1)) {
31327 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
31328 }
31329 arg1 = static_cast< bool >(val1);
31330 {
31331 PyThreadState* __tstate = wxPyBeginAllowThreads();
31332 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
31333 wxPyEndAllowThreads(__tstate);
31334 if (PyErr_Occurred()) SWIG_fail;
31335 }
31336 resultobj = SWIG_Py_Void();
31337 return resultobj;
31338 fail:
31339 return NULL;
31340 }
31341
31342
31343 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31344 PyObject *resultobj = 0;
31345 long arg1 ;
31346 long val1 ;
31347 int ecode1 = 0 ;
31348 PyObject * obj0 = 0 ;
31349 char * kwnames[] = {
31350 (char *) "val", NULL
31351 };
31352
31353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
31354 ecode1 = SWIG_AsVal_long(obj0, &val1);
31355 if (!SWIG_IsOK(ecode1)) {
31356 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
31357 }
31358 arg1 = static_cast< long >(val1);
31359 {
31360 PyThreadState* __tstate = wxPyBeginAllowThreads();
31361 wxPyApp::SetMacAboutMenuItemId(arg1);
31362 wxPyEndAllowThreads(__tstate);
31363 if (PyErr_Occurred()) SWIG_fail;
31364 }
31365 resultobj = SWIG_Py_Void();
31366 return resultobj;
31367 fail:
31368 return NULL;
31369 }
31370
31371
31372 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31373 PyObject *resultobj = 0;
31374 long arg1 ;
31375 long val1 ;
31376 int ecode1 = 0 ;
31377 PyObject * obj0 = 0 ;
31378 char * kwnames[] = {
31379 (char *) "val", NULL
31380 };
31381
31382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
31383 ecode1 = SWIG_AsVal_long(obj0, &val1);
31384 if (!SWIG_IsOK(ecode1)) {
31385 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
31386 }
31387 arg1 = static_cast< long >(val1);
31388 {
31389 PyThreadState* __tstate = wxPyBeginAllowThreads();
31390 wxPyApp::SetMacPreferencesMenuItemId(arg1);
31391 wxPyEndAllowThreads(__tstate);
31392 if (PyErr_Occurred()) SWIG_fail;
31393 }
31394 resultobj = SWIG_Py_Void();
31395 return resultobj;
31396 fail:
31397 return NULL;
31398 }
31399
31400
31401 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31402 PyObject *resultobj = 0;
31403 long arg1 ;
31404 long val1 ;
31405 int ecode1 = 0 ;
31406 PyObject * obj0 = 0 ;
31407 char * kwnames[] = {
31408 (char *) "val", NULL
31409 };
31410
31411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
31412 ecode1 = SWIG_AsVal_long(obj0, &val1);
31413 if (!SWIG_IsOK(ecode1)) {
31414 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
31415 }
31416 arg1 = static_cast< long >(val1);
31417 {
31418 PyThreadState* __tstate = wxPyBeginAllowThreads();
31419 wxPyApp::SetMacExitMenuItemId(arg1);
31420 wxPyEndAllowThreads(__tstate);
31421 if (PyErr_Occurred()) SWIG_fail;
31422 }
31423 resultobj = SWIG_Py_Void();
31424 return resultobj;
31425 fail:
31426 return NULL;
31427 }
31428
31429
31430 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31431 PyObject *resultobj = 0;
31432 wxString *arg1 = 0 ;
31433 bool temp1 = false ;
31434 PyObject * obj0 = 0 ;
31435 char * kwnames[] = {
31436 (char *) "val", NULL
31437 };
31438
31439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
31440 {
31441 arg1 = wxString_in_helper(obj0);
31442 if (arg1 == NULL) SWIG_fail;
31443 temp1 = true;
31444 }
31445 {
31446 PyThreadState* __tstate = wxPyBeginAllowThreads();
31447 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
31448 wxPyEndAllowThreads(__tstate);
31449 if (PyErr_Occurred()) SWIG_fail;
31450 }
31451 resultobj = SWIG_Py_Void();
31452 {
31453 if (temp1)
31454 delete arg1;
31455 }
31456 return resultobj;
31457 fail:
31458 {
31459 if (temp1)
31460 delete arg1;
31461 }
31462 return NULL;
31463 }
31464
31465
31466 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31467 PyObject *resultobj = 0;
31468 wxPyApp *arg1 = (wxPyApp *) 0 ;
31469 void *argp1 = 0 ;
31470 int res1 = 0 ;
31471 PyObject *swig_obj[1] ;
31472
31473 if (!args) SWIG_fail;
31474 swig_obj[0] = args;
31475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31476 if (!SWIG_IsOK(res1)) {
31477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
31478 }
31479 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31480 {
31481 PyThreadState* __tstate = wxPyBeginAllowThreads();
31482 (arg1)->_BootstrapApp();
31483 wxPyEndAllowThreads(__tstate);
31484 if (PyErr_Occurred()) SWIG_fail;
31485 }
31486 resultobj = SWIG_Py_Void();
31487 return resultobj;
31488 fail:
31489 return NULL;
31490 }
31491
31492
31493 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31494 PyObject *resultobj = 0;
31495 int result;
31496
31497 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
31498 {
31499 PyThreadState* __tstate = wxPyBeginAllowThreads();
31500 result = (int)wxPyApp::GetComCtl32Version();
31501 wxPyEndAllowThreads(__tstate);
31502 if (PyErr_Occurred()) SWIG_fail;
31503 }
31504 resultobj = SWIG_From_int(static_cast< int >(result));
31505 return resultobj;
31506 fail:
31507 return NULL;
31508 }
31509
31510
31511 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31512 PyObject *resultobj = 0;
31513 bool result;
31514
31515 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
31516 {
31517 PyThreadState* __tstate = wxPyBeginAllowThreads();
31518 result = (bool)wxPyApp_IsDisplayAvailable();
31519 wxPyEndAllowThreads(__tstate);
31520 if (PyErr_Occurred()) SWIG_fail;
31521 }
31522 {
31523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31524 }
31525 return resultobj;
31526 fail:
31527 return NULL;
31528 }
31529
31530
31531 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31532 PyObject *obj;
31533 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31534 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
31535 return SWIG_Py_Void();
31536 }
31537
31538 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31539 return SWIG_Python_InitShadowInstance(args);
31540 }
31541
31542 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31543 PyObject *resultobj = 0;
31544
31545 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
31546 {
31547 PyThreadState* __tstate = wxPyBeginAllowThreads();
31548 wxExit();
31549 wxPyEndAllowThreads(__tstate);
31550 if (PyErr_Occurred()) SWIG_fail;
31551 }
31552 resultobj = SWIG_Py_Void();
31553 return resultobj;
31554 fail:
31555 return NULL;
31556 }
31557
31558
31559 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31560 PyObject *resultobj = 0;
31561 bool result;
31562
31563 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
31564 {
31565 PyThreadState* __tstate = wxPyBeginAllowThreads();
31566 result = (bool)wxYield();
31567 wxPyEndAllowThreads(__tstate);
31568 if (PyErr_Occurred()) SWIG_fail;
31569 }
31570 {
31571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31572 }
31573 return resultobj;
31574 fail:
31575 return NULL;
31576 }
31577
31578
31579 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31580 PyObject *resultobj = 0;
31581 bool result;
31582
31583 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
31584 {
31585 PyThreadState* __tstate = wxPyBeginAllowThreads();
31586 result = (bool)wxYieldIfNeeded();
31587 wxPyEndAllowThreads(__tstate);
31588 if (PyErr_Occurred()) SWIG_fail;
31589 }
31590 {
31591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31592 }
31593 return resultobj;
31594 fail:
31595 return NULL;
31596 }
31597
31598
31599 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31600 PyObject *resultobj = 0;
31601 wxWindow *arg1 = (wxWindow *) NULL ;
31602 bool arg2 = (bool) false ;
31603 bool result;
31604 void *argp1 = 0 ;
31605 int res1 = 0 ;
31606 bool val2 ;
31607 int ecode2 = 0 ;
31608 PyObject * obj0 = 0 ;
31609 PyObject * obj1 = 0 ;
31610 char * kwnames[] = {
31611 (char *) "win",(char *) "onlyIfNeeded", NULL
31612 };
31613
31614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
31615 if (obj0) {
31616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31617 if (!SWIG_IsOK(res1)) {
31618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
31619 }
31620 arg1 = reinterpret_cast< wxWindow * >(argp1);
31621 }
31622 if (obj1) {
31623 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31624 if (!SWIG_IsOK(ecode2)) {
31625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
31626 }
31627 arg2 = static_cast< bool >(val2);
31628 }
31629 {
31630 PyThreadState* __tstate = wxPyBeginAllowThreads();
31631 result = (bool)wxSafeYield(arg1,arg2);
31632 wxPyEndAllowThreads(__tstate);
31633 if (PyErr_Occurred()) SWIG_fail;
31634 }
31635 {
31636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31637 }
31638 return resultobj;
31639 fail:
31640 return NULL;
31641 }
31642
31643
31644 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31645 PyObject *resultobj = 0;
31646
31647 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
31648 {
31649 PyThreadState* __tstate = wxPyBeginAllowThreads();
31650 wxWakeUpIdle();
31651 wxPyEndAllowThreads(__tstate);
31652 if (PyErr_Occurred()) SWIG_fail;
31653 }
31654 resultobj = SWIG_Py_Void();
31655 return resultobj;
31656 fail:
31657 return NULL;
31658 }
31659
31660
31661 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31662 PyObject *resultobj = 0;
31663 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
31664 wxEvent *arg2 = 0 ;
31665 void *argp1 = 0 ;
31666 int res1 = 0 ;
31667 void *argp2 = 0 ;
31668 int res2 = 0 ;
31669 PyObject * obj0 = 0 ;
31670 PyObject * obj1 = 0 ;
31671 char * kwnames[] = {
31672 (char *) "dest",(char *) "event", NULL
31673 };
31674
31675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
31676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
31677 if (!SWIG_IsOK(res1)) {
31678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
31679 }
31680 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
31681 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
31682 if (!SWIG_IsOK(res2)) {
31683 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31684 }
31685 if (!argp2) {
31686 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31687 }
31688 arg2 = reinterpret_cast< wxEvent * >(argp2);
31689 {
31690 PyThreadState* __tstate = wxPyBeginAllowThreads();
31691 wxPostEvent(arg1,*arg2);
31692 wxPyEndAllowThreads(__tstate);
31693 if (PyErr_Occurred()) SWIG_fail;
31694 }
31695 resultobj = SWIG_Py_Void();
31696 return resultobj;
31697 fail:
31698 return NULL;
31699 }
31700
31701
31702 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31703 PyObject *resultobj = 0;
31704
31705 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
31706 {
31707 PyThreadState* __tstate = wxPyBeginAllowThreads();
31708 wxApp_CleanUp();
31709 wxPyEndAllowThreads(__tstate);
31710 if (PyErr_Occurred()) SWIG_fail;
31711 }
31712 resultobj = SWIG_Py_Void();
31713 return resultobj;
31714 fail:
31715 return NULL;
31716 }
31717
31718
31719 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31720 PyObject *resultobj = 0;
31721 wxPyApp *result = 0 ;
31722
31723 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
31724 {
31725 PyThreadState* __tstate = wxPyBeginAllowThreads();
31726 result = (wxPyApp *)wxPyGetApp();
31727 wxPyEndAllowThreads(__tstate);
31728 if (PyErr_Occurred()) SWIG_fail;
31729 }
31730 {
31731 resultobj = wxPyMake_wxObject(result, 0);
31732 }
31733 return resultobj;
31734 fail:
31735 return NULL;
31736 }
31737
31738
31739 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31740 PyObject *resultobj = 0;
31741 char *arg1 = (char *) 0 ;
31742 int res1 ;
31743 char *buf1 = 0 ;
31744 int alloc1 = 0 ;
31745 PyObject * obj0 = 0 ;
31746 char * kwnames[] = {
31747 (char *) "encoding", NULL
31748 };
31749
31750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
31751 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
31752 if (!SWIG_IsOK(res1)) {
31753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
31754 }
31755 arg1 = buf1;
31756 {
31757 PyThreadState* __tstate = wxPyBeginAllowThreads();
31758 wxSetDefaultPyEncoding((char const *)arg1);
31759 wxPyEndAllowThreads(__tstate);
31760 if (PyErr_Occurred()) SWIG_fail;
31761 }
31762 resultobj = SWIG_Py_Void();
31763 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31764 return resultobj;
31765 fail:
31766 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31767 return NULL;
31768 }
31769
31770
31771 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31772 PyObject *resultobj = 0;
31773 char *result = 0 ;
31774
31775 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
31776 {
31777 PyThreadState* __tstate = wxPyBeginAllowThreads();
31778 result = (char *)wxGetDefaultPyEncoding();
31779 wxPyEndAllowThreads(__tstate);
31780 if (PyErr_Occurred()) SWIG_fail;
31781 }
31782 resultobj = SWIG_FromCharPtr(result);
31783 return resultobj;
31784 fail:
31785 return NULL;
31786 }
31787
31788
31789 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31790 PyObject *resultobj = 0;
31791 wxEventLoop *result = 0 ;
31792
31793 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
31794 {
31795 PyThreadState* __tstate = wxPyBeginAllowThreads();
31796 result = (wxEventLoop *)new wxEventLoop();
31797 wxPyEndAllowThreads(__tstate);
31798 if (PyErr_Occurred()) SWIG_fail;
31799 }
31800 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
31801 return resultobj;
31802 fail:
31803 return NULL;
31804 }
31805
31806
31807 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31808 PyObject *resultobj = 0;
31809 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31810 void *argp1 = 0 ;
31811 int res1 = 0 ;
31812 PyObject *swig_obj[1] ;
31813
31814 if (!args) SWIG_fail;
31815 swig_obj[0] = args;
31816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
31817 if (!SWIG_IsOK(res1)) {
31818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31819 }
31820 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31821 {
31822 PyThreadState* __tstate = wxPyBeginAllowThreads();
31823 delete arg1;
31824
31825 wxPyEndAllowThreads(__tstate);
31826 if (PyErr_Occurred()) SWIG_fail;
31827 }
31828 resultobj = SWIG_Py_Void();
31829 return resultobj;
31830 fail:
31831 return NULL;
31832 }
31833
31834
31835 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31836 PyObject *resultobj = 0;
31837 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31838 int result;
31839 void *argp1 = 0 ;
31840 int res1 = 0 ;
31841 PyObject *swig_obj[1] ;
31842
31843 if (!args) SWIG_fail;
31844 swig_obj[0] = args;
31845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31846 if (!SWIG_IsOK(res1)) {
31847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31848 }
31849 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31850 {
31851 PyThreadState* __tstate = wxPyBeginAllowThreads();
31852 result = (int)(arg1)->Run();
31853 wxPyEndAllowThreads(__tstate);
31854 if (PyErr_Occurred()) SWIG_fail;
31855 }
31856 resultobj = SWIG_From_int(static_cast< int >(result));
31857 return resultobj;
31858 fail:
31859 return NULL;
31860 }
31861
31862
31863 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31864 PyObject *resultobj = 0;
31865 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31866 int arg2 = (int) 0 ;
31867 void *argp1 = 0 ;
31868 int res1 = 0 ;
31869 int val2 ;
31870 int ecode2 = 0 ;
31871 PyObject * obj0 = 0 ;
31872 PyObject * obj1 = 0 ;
31873 char * kwnames[] = {
31874 (char *) "self",(char *) "rc", NULL
31875 };
31876
31877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
31878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31879 if (!SWIG_IsOK(res1)) {
31880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31881 }
31882 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31883 if (obj1) {
31884 ecode2 = SWIG_AsVal_int(obj1, &val2);
31885 if (!SWIG_IsOK(ecode2)) {
31886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
31887 }
31888 arg2 = static_cast< int >(val2);
31889 }
31890 {
31891 PyThreadState* __tstate = wxPyBeginAllowThreads();
31892 (arg1)->Exit(arg2);
31893 wxPyEndAllowThreads(__tstate);
31894 if (PyErr_Occurred()) SWIG_fail;
31895 }
31896 resultobj = SWIG_Py_Void();
31897 return resultobj;
31898 fail:
31899 return NULL;
31900 }
31901
31902
31903 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31904 PyObject *resultobj = 0;
31905 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31906 bool result;
31907 void *argp1 = 0 ;
31908 int res1 = 0 ;
31909 PyObject *swig_obj[1] ;
31910
31911 if (!args) SWIG_fail;
31912 swig_obj[0] = args;
31913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31914 if (!SWIG_IsOK(res1)) {
31915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31916 }
31917 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31918 {
31919 PyThreadState* __tstate = wxPyBeginAllowThreads();
31920 result = (bool)((wxEventLoop const *)arg1)->Pending();
31921 wxPyEndAllowThreads(__tstate);
31922 if (PyErr_Occurred()) SWIG_fail;
31923 }
31924 {
31925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31926 }
31927 return resultobj;
31928 fail:
31929 return NULL;
31930 }
31931
31932
31933 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31934 PyObject *resultobj = 0;
31935 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31936 bool result;
31937 void *argp1 = 0 ;
31938 int res1 = 0 ;
31939 PyObject *swig_obj[1] ;
31940
31941 if (!args) SWIG_fail;
31942 swig_obj[0] = args;
31943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31944 if (!SWIG_IsOK(res1)) {
31945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31946 }
31947 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31948 {
31949 PyThreadState* __tstate = wxPyBeginAllowThreads();
31950 result = (bool)(arg1)->Dispatch();
31951 wxPyEndAllowThreads(__tstate);
31952 if (PyErr_Occurred()) SWIG_fail;
31953 }
31954 {
31955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31956 }
31957 return resultobj;
31958 fail:
31959 return NULL;
31960 }
31961
31962
31963 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31964 PyObject *resultobj = 0;
31965 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31966 bool result;
31967 void *argp1 = 0 ;
31968 int res1 = 0 ;
31969 PyObject *swig_obj[1] ;
31970
31971 if (!args) SWIG_fail;
31972 swig_obj[0] = args;
31973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31974 if (!SWIG_IsOK(res1)) {
31975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31976 }
31977 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31978 {
31979 PyThreadState* __tstate = wxPyBeginAllowThreads();
31980 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
31981 wxPyEndAllowThreads(__tstate);
31982 if (PyErr_Occurred()) SWIG_fail;
31983 }
31984 {
31985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31986 }
31987 return resultobj;
31988 fail:
31989 return NULL;
31990 }
31991
31992
31993 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31994 PyObject *resultobj = 0;
31995 wxEventLoop *result = 0 ;
31996
31997 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
31998 {
31999 PyThreadState* __tstate = wxPyBeginAllowThreads();
32000 result = (wxEventLoop *)wxEventLoop::GetActive();
32001 wxPyEndAllowThreads(__tstate);
32002 if (PyErr_Occurred()) SWIG_fail;
32003 }
32004 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
32005 return resultobj;
32006 fail:
32007 return NULL;
32008 }
32009
32010
32011 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32012 PyObject *resultobj = 0;
32013 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32014 void *argp1 = 0 ;
32015 int res1 = 0 ;
32016 PyObject * obj0 = 0 ;
32017 char * kwnames[] = {
32018 (char *) "loop", NULL
32019 };
32020
32021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
32022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32023 if (!SWIG_IsOK(res1)) {
32024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32025 }
32026 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32027 {
32028 PyThreadState* __tstate = wxPyBeginAllowThreads();
32029 wxEventLoop::SetActive(arg1);
32030 wxPyEndAllowThreads(__tstate);
32031 if (PyErr_Occurred()) SWIG_fail;
32032 }
32033 resultobj = SWIG_Py_Void();
32034 return resultobj;
32035 fail:
32036 return NULL;
32037 }
32038
32039
32040 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32041 PyObject *obj;
32042 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32043 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
32044 return SWIG_Py_Void();
32045 }
32046
32047 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32048 return SWIG_Python_InitShadowInstance(args);
32049 }
32050
32051 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32052 PyObject *resultobj = 0;
32053 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32054 wxEventLoopActivator *result = 0 ;
32055 void *argp1 = 0 ;
32056 int res1 = 0 ;
32057 PyObject * obj0 = 0 ;
32058 char * kwnames[] = {
32059 (char *) "evtLoop", NULL
32060 };
32061
32062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
32063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32064 if (!SWIG_IsOK(res1)) {
32065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32066 }
32067 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32068 {
32069 PyThreadState* __tstate = wxPyBeginAllowThreads();
32070 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
32071 wxPyEndAllowThreads(__tstate);
32072 if (PyErr_Occurred()) SWIG_fail;
32073 }
32074 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
32075 return resultobj;
32076 fail:
32077 return NULL;
32078 }
32079
32080
32081 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32082 PyObject *resultobj = 0;
32083 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
32084 void *argp1 = 0 ;
32085 int res1 = 0 ;
32086 PyObject *swig_obj[1] ;
32087
32088 if (!args) SWIG_fail;
32089 swig_obj[0] = args;
32090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
32091 if (!SWIG_IsOK(res1)) {
32092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
32093 }
32094 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
32095 {
32096 PyThreadState* __tstate = wxPyBeginAllowThreads();
32097 delete arg1;
32098
32099 wxPyEndAllowThreads(__tstate);
32100 if (PyErr_Occurred()) SWIG_fail;
32101 }
32102 resultobj = SWIG_Py_Void();
32103 return resultobj;
32104 fail:
32105 return NULL;
32106 }
32107
32108
32109 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32110 PyObject *obj;
32111 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32112 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
32113 return SWIG_Py_Void();
32114 }
32115
32116 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32117 return SWIG_Python_InitShadowInstance(args);
32118 }
32119
32120 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32121 PyObject *resultobj = 0;
32122 int arg1 = (int) 0 ;
32123 int arg2 = (int) 0 ;
32124 int arg3 = (int) 0 ;
32125 wxAcceleratorEntry *result = 0 ;
32126 int val1 ;
32127 int ecode1 = 0 ;
32128 int val2 ;
32129 int ecode2 = 0 ;
32130 int val3 ;
32131 int ecode3 = 0 ;
32132 PyObject * obj0 = 0 ;
32133 PyObject * obj1 = 0 ;
32134 PyObject * obj2 = 0 ;
32135 char * kwnames[] = {
32136 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
32137 };
32138
32139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32140 if (obj0) {
32141 ecode1 = SWIG_AsVal_int(obj0, &val1);
32142 if (!SWIG_IsOK(ecode1)) {
32143 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
32144 }
32145 arg1 = static_cast< int >(val1);
32146 }
32147 if (obj1) {
32148 ecode2 = SWIG_AsVal_int(obj1, &val2);
32149 if (!SWIG_IsOK(ecode2)) {
32150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
32151 }
32152 arg2 = static_cast< int >(val2);
32153 }
32154 if (obj2) {
32155 ecode3 = SWIG_AsVal_int(obj2, &val3);
32156 if (!SWIG_IsOK(ecode3)) {
32157 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
32158 }
32159 arg3 = static_cast< int >(val3);
32160 }
32161 {
32162 PyThreadState* __tstate = wxPyBeginAllowThreads();
32163 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
32164 wxPyEndAllowThreads(__tstate);
32165 if (PyErr_Occurred()) SWIG_fail;
32166 }
32167 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
32168 return resultobj;
32169 fail:
32170 return NULL;
32171 }
32172
32173
32174 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32175 PyObject *resultobj = 0;
32176 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32177 void *argp1 = 0 ;
32178 int res1 = 0 ;
32179 PyObject *swig_obj[1] ;
32180
32181 if (!args) SWIG_fail;
32182 swig_obj[0] = args;
32183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
32184 if (!SWIG_IsOK(res1)) {
32185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32186 }
32187 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32188 {
32189 PyThreadState* __tstate = wxPyBeginAllowThreads();
32190 delete arg1;
32191
32192 wxPyEndAllowThreads(__tstate);
32193 if (PyErr_Occurred()) SWIG_fail;
32194 }
32195 resultobj = SWIG_Py_Void();
32196 return resultobj;
32197 fail:
32198 return NULL;
32199 }
32200
32201
32202 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32203 PyObject *resultobj = 0;
32204 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32205 int arg2 ;
32206 int arg3 ;
32207 int arg4 ;
32208 void *argp1 = 0 ;
32209 int res1 = 0 ;
32210 int val2 ;
32211 int ecode2 = 0 ;
32212 int val3 ;
32213 int ecode3 = 0 ;
32214 int val4 ;
32215 int ecode4 = 0 ;
32216 PyObject * obj0 = 0 ;
32217 PyObject * obj1 = 0 ;
32218 PyObject * obj2 = 0 ;
32219 PyObject * obj3 = 0 ;
32220 char * kwnames[] = {
32221 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
32222 };
32223
32224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32226 if (!SWIG_IsOK(res1)) {
32227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32228 }
32229 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32230 ecode2 = SWIG_AsVal_int(obj1, &val2);
32231 if (!SWIG_IsOK(ecode2)) {
32232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
32233 }
32234 arg2 = static_cast< int >(val2);
32235 ecode3 = SWIG_AsVal_int(obj2, &val3);
32236 if (!SWIG_IsOK(ecode3)) {
32237 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
32238 }
32239 arg3 = static_cast< int >(val3);
32240 ecode4 = SWIG_AsVal_int(obj3, &val4);
32241 if (!SWIG_IsOK(ecode4)) {
32242 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
32243 }
32244 arg4 = static_cast< int >(val4);
32245 {
32246 PyThreadState* __tstate = wxPyBeginAllowThreads();
32247 (arg1)->Set(arg2,arg3,arg4);
32248 wxPyEndAllowThreads(__tstate);
32249 if (PyErr_Occurred()) SWIG_fail;
32250 }
32251 resultobj = SWIG_Py_Void();
32252 return resultobj;
32253 fail:
32254 return NULL;
32255 }
32256
32257
32258 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32259 PyObject *resultobj = 0;
32260 wxString *arg1 = 0 ;
32261 wxAcceleratorEntry *result = 0 ;
32262 bool temp1 = false ;
32263 PyObject * obj0 = 0 ;
32264 char * kwnames[] = {
32265 (char *) "str", NULL
32266 };
32267
32268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
32269 {
32270 arg1 = wxString_in_helper(obj0);
32271 if (arg1 == NULL) SWIG_fail;
32272 temp1 = true;
32273 }
32274 {
32275 PyThreadState* __tstate = wxPyBeginAllowThreads();
32276 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
32277 wxPyEndAllowThreads(__tstate);
32278 if (PyErr_Occurred()) SWIG_fail;
32279 }
32280 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
32281 {
32282 if (temp1)
32283 delete arg1;
32284 }
32285 return resultobj;
32286 fail:
32287 {
32288 if (temp1)
32289 delete arg1;
32290 }
32291 return NULL;
32292 }
32293
32294
32295 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32296 PyObject *resultobj = 0;
32297 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32298 int result;
32299 void *argp1 = 0 ;
32300 int res1 = 0 ;
32301 PyObject *swig_obj[1] ;
32302
32303 if (!args) SWIG_fail;
32304 swig_obj[0] = args;
32305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32306 if (!SWIG_IsOK(res1)) {
32307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32308 }
32309 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32310 {
32311 PyThreadState* __tstate = wxPyBeginAllowThreads();
32312 result = (int)(arg1)->GetFlags();
32313 wxPyEndAllowThreads(__tstate);
32314 if (PyErr_Occurred()) SWIG_fail;
32315 }
32316 resultobj = SWIG_From_int(static_cast< int >(result));
32317 return resultobj;
32318 fail:
32319 return NULL;
32320 }
32321
32322
32323 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32324 PyObject *resultobj = 0;
32325 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32326 int result;
32327 void *argp1 = 0 ;
32328 int res1 = 0 ;
32329 PyObject *swig_obj[1] ;
32330
32331 if (!args) SWIG_fail;
32332 swig_obj[0] = args;
32333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32334 if (!SWIG_IsOK(res1)) {
32335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32336 }
32337 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32338 {
32339 PyThreadState* __tstate = wxPyBeginAllowThreads();
32340 result = (int)(arg1)->GetKeyCode();
32341 wxPyEndAllowThreads(__tstate);
32342 if (PyErr_Occurred()) SWIG_fail;
32343 }
32344 resultobj = SWIG_From_int(static_cast< int >(result));
32345 return resultobj;
32346 fail:
32347 return NULL;
32348 }
32349
32350
32351 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32352 PyObject *resultobj = 0;
32353 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32354 int result;
32355 void *argp1 = 0 ;
32356 int res1 = 0 ;
32357 PyObject *swig_obj[1] ;
32358
32359 if (!args) SWIG_fail;
32360 swig_obj[0] = args;
32361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32362 if (!SWIG_IsOK(res1)) {
32363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32364 }
32365 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32366 {
32367 PyThreadState* __tstate = wxPyBeginAllowThreads();
32368 result = (int)(arg1)->GetCommand();
32369 wxPyEndAllowThreads(__tstate);
32370 if (PyErr_Occurred()) SWIG_fail;
32371 }
32372 resultobj = SWIG_From_int(static_cast< int >(result));
32373 return resultobj;
32374 fail:
32375 return NULL;
32376 }
32377
32378
32379 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32380 PyObject *resultobj = 0;
32381 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32382 bool result;
32383 void *argp1 = 0 ;
32384 int res1 = 0 ;
32385 PyObject *swig_obj[1] ;
32386
32387 if (!args) SWIG_fail;
32388 swig_obj[0] = args;
32389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32390 if (!SWIG_IsOK(res1)) {
32391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32392 }
32393 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32394 {
32395 PyThreadState* __tstate = wxPyBeginAllowThreads();
32396 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
32397 wxPyEndAllowThreads(__tstate);
32398 if (PyErr_Occurred()) SWIG_fail;
32399 }
32400 {
32401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32402 }
32403 return resultobj;
32404 fail:
32405 return NULL;
32406 }
32407
32408
32409 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32410 PyObject *resultobj = 0;
32411 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32412 wxString result;
32413 void *argp1 = 0 ;
32414 int res1 = 0 ;
32415 PyObject *swig_obj[1] ;
32416
32417 if (!args) SWIG_fail;
32418 swig_obj[0] = args;
32419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32420 if (!SWIG_IsOK(res1)) {
32421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32422 }
32423 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32424 {
32425 PyThreadState* __tstate = wxPyBeginAllowThreads();
32426 result = ((wxAcceleratorEntry const *)arg1)->ToString();
32427 wxPyEndAllowThreads(__tstate);
32428 if (PyErr_Occurred()) SWIG_fail;
32429 }
32430 {
32431 #if wxUSE_UNICODE
32432 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32433 #else
32434 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32435 #endif
32436 }
32437 return resultobj;
32438 fail:
32439 return NULL;
32440 }
32441
32442
32443 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32444 PyObject *resultobj = 0;
32445 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32446 wxString *arg2 = 0 ;
32447 bool result;
32448 void *argp1 = 0 ;
32449 int res1 = 0 ;
32450 bool temp2 = false ;
32451 PyObject * obj0 = 0 ;
32452 PyObject * obj1 = 0 ;
32453 char * kwnames[] = {
32454 (char *) "self",(char *) "str", NULL
32455 };
32456
32457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
32458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32459 if (!SWIG_IsOK(res1)) {
32460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32461 }
32462 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32463 {
32464 arg2 = wxString_in_helper(obj1);
32465 if (arg2 == NULL) SWIG_fail;
32466 temp2 = true;
32467 }
32468 {
32469 PyThreadState* __tstate = wxPyBeginAllowThreads();
32470 result = (bool)(arg1)->FromString((wxString const &)*arg2);
32471 wxPyEndAllowThreads(__tstate);
32472 if (PyErr_Occurred()) SWIG_fail;
32473 }
32474 {
32475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32476 }
32477 {
32478 if (temp2)
32479 delete arg2;
32480 }
32481 return resultobj;
32482 fail:
32483 {
32484 if (temp2)
32485 delete arg2;
32486 }
32487 return NULL;
32488 }
32489
32490
32491 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32492 PyObject *obj;
32493 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32494 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
32495 return SWIG_Py_Void();
32496 }
32497
32498 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32499 return SWIG_Python_InitShadowInstance(args);
32500 }
32501
32502 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32503 PyObject *resultobj = 0;
32504 int arg1 ;
32505 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
32506 wxAcceleratorTable *result = 0 ;
32507 PyObject * obj0 = 0 ;
32508 char * kwnames[] = {
32509 (char *) "n", NULL
32510 };
32511
32512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
32513 {
32514 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
32515 if (arg2) arg1 = PyList_Size(obj0);
32516 else arg1 = 0;
32517 }
32518 {
32519 PyThreadState* __tstate = wxPyBeginAllowThreads();
32520 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
32521 wxPyEndAllowThreads(__tstate);
32522 if (PyErr_Occurred()) SWIG_fail;
32523 }
32524 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
32525 return resultobj;
32526 fail:
32527 return NULL;
32528 }
32529
32530
32531 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32532 PyObject *resultobj = 0;
32533 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32534 void *argp1 = 0 ;
32535 int res1 = 0 ;
32536 PyObject *swig_obj[1] ;
32537
32538 if (!args) SWIG_fail;
32539 swig_obj[0] = args;
32540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
32541 if (!SWIG_IsOK(res1)) {
32542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
32543 }
32544 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32545 {
32546 PyThreadState* __tstate = wxPyBeginAllowThreads();
32547 delete arg1;
32548
32549 wxPyEndAllowThreads(__tstate);
32550 if (PyErr_Occurred()) SWIG_fail;
32551 }
32552 resultobj = SWIG_Py_Void();
32553 return resultobj;
32554 fail:
32555 return NULL;
32556 }
32557
32558
32559 SWIGINTERN PyObject *_wrap_AcceleratorTable_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32560 PyObject *resultobj = 0;
32561 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32562 bool result;
32563 void *argp1 = 0 ;
32564 int res1 = 0 ;
32565 PyObject *swig_obj[1] ;
32566
32567 if (!args) SWIG_fail;
32568 swig_obj[0] = args;
32569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
32570 if (!SWIG_IsOK(res1)) {
32571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
32572 }
32573 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32574 {
32575 PyThreadState* __tstate = wxPyBeginAllowThreads();
32576 result = (bool)((wxAcceleratorTable const *)arg1)->IsOk();
32577 wxPyEndAllowThreads(__tstate);
32578 if (PyErr_Occurred()) SWIG_fail;
32579 }
32580 {
32581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32582 }
32583 return resultobj;
32584 fail:
32585 return NULL;
32586 }
32587
32588
32589 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32590 PyObject *obj;
32591 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32592 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
32593 return SWIG_Py_Void();
32594 }
32595
32596 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32597 return SWIG_Python_InitShadowInstance(args);
32598 }
32599
32600 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
32601 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
32602 return 1;
32603 }
32604
32605
32606 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
32607 PyObject *pyobj = 0;
32608
32609 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
32610 return pyobj;
32611 }
32612
32613
32614 SWIGINTERN int PanelNameStr_set(PyObject *) {
32615 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
32616 return 1;
32617 }
32618
32619
32620 SWIGINTERN PyObject *PanelNameStr_get(void) {
32621 PyObject *pyobj = 0;
32622
32623 {
32624 #if wxUSE_UNICODE
32625 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32626 #else
32627 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32628 #endif
32629 }
32630 return pyobj;
32631 }
32632
32633
32634 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32635 PyObject *resultobj = 0;
32636 wxVisualAttributes *result = 0 ;
32637
32638 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
32639 {
32640 PyThreadState* __tstate = wxPyBeginAllowThreads();
32641 result = (wxVisualAttributes *)new_wxVisualAttributes();
32642 wxPyEndAllowThreads(__tstate);
32643 if (PyErr_Occurred()) SWIG_fail;
32644 }
32645 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
32646 return resultobj;
32647 fail:
32648 return NULL;
32649 }
32650
32651
32652 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32653 PyObject *resultobj = 0;
32654 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32655 void *argp1 = 0 ;
32656 int res1 = 0 ;
32657 PyObject *swig_obj[1] ;
32658
32659 if (!args) SWIG_fail;
32660 swig_obj[0] = args;
32661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
32662 if (!SWIG_IsOK(res1)) {
32663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32664 }
32665 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32666 {
32667 PyThreadState* __tstate = wxPyBeginAllowThreads();
32668 delete_wxVisualAttributes(arg1);
32669
32670 wxPyEndAllowThreads(__tstate);
32671 if (PyErr_Occurred()) SWIG_fail;
32672 }
32673 resultobj = SWIG_Py_Void();
32674 return resultobj;
32675 fail:
32676 return NULL;
32677 }
32678
32679
32680 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32681 PyObject *resultobj = 0;
32682 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32683 wxFont *arg2 = (wxFont *) 0 ;
32684 void *argp1 = 0 ;
32685 int res1 = 0 ;
32686 void *argp2 = 0 ;
32687 int res2 = 0 ;
32688 PyObject *swig_obj[2] ;
32689
32690 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
32691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32692 if (!SWIG_IsOK(res1)) {
32693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32694 }
32695 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32696 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
32697 if (!SWIG_IsOK(res2)) {
32698 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
32699 }
32700 arg2 = reinterpret_cast< wxFont * >(argp2);
32701 if (arg1) (arg1)->font = *arg2;
32702
32703 resultobj = SWIG_Py_Void();
32704 return resultobj;
32705 fail:
32706 return NULL;
32707 }
32708
32709
32710 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32711 PyObject *resultobj = 0;
32712 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32713 wxFont *result = 0 ;
32714 void *argp1 = 0 ;
32715 int res1 = 0 ;
32716 PyObject *swig_obj[1] ;
32717
32718 if (!args) SWIG_fail;
32719 swig_obj[0] = args;
32720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32721 if (!SWIG_IsOK(res1)) {
32722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32723 }
32724 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32725 result = (wxFont *)& ((arg1)->font);
32726 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
32727 return resultobj;
32728 fail:
32729 return NULL;
32730 }
32731
32732
32733 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32734 PyObject *resultobj = 0;
32735 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32736 wxColour *arg2 = (wxColour *) 0 ;
32737 void *argp1 = 0 ;
32738 int res1 = 0 ;
32739 void *argp2 = 0 ;
32740 int res2 = 0 ;
32741 PyObject *swig_obj[2] ;
32742
32743 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
32744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32745 if (!SWIG_IsOK(res1)) {
32746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32747 }
32748 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32749 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32750 if (!SWIG_IsOK(res2)) {
32751 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32752 }
32753 arg2 = reinterpret_cast< wxColour * >(argp2);
32754 if (arg1) (arg1)->colFg = *arg2;
32755
32756 resultobj = SWIG_Py_Void();
32757 return resultobj;
32758 fail:
32759 return NULL;
32760 }
32761
32762
32763 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32764 PyObject *resultobj = 0;
32765 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32766 wxColour *result = 0 ;
32767 void *argp1 = 0 ;
32768 int res1 = 0 ;
32769 PyObject *swig_obj[1] ;
32770
32771 if (!args) SWIG_fail;
32772 swig_obj[0] = args;
32773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32774 if (!SWIG_IsOK(res1)) {
32775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32776 }
32777 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32778 result = (wxColour *)& ((arg1)->colFg);
32779 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32780 return resultobj;
32781 fail:
32782 return NULL;
32783 }
32784
32785
32786 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32787 PyObject *resultobj = 0;
32788 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32789 wxColour *arg2 = (wxColour *) 0 ;
32790 void *argp1 = 0 ;
32791 int res1 = 0 ;
32792 void *argp2 = 0 ;
32793 int res2 = 0 ;
32794 PyObject *swig_obj[2] ;
32795
32796 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
32797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32798 if (!SWIG_IsOK(res1)) {
32799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32800 }
32801 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32802 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32803 if (!SWIG_IsOK(res2)) {
32804 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32805 }
32806 arg2 = reinterpret_cast< wxColour * >(argp2);
32807 if (arg1) (arg1)->colBg = *arg2;
32808
32809 resultobj = SWIG_Py_Void();
32810 return resultobj;
32811 fail:
32812 return NULL;
32813 }
32814
32815
32816 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32817 PyObject *resultobj = 0;
32818 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32819 wxColour *result = 0 ;
32820 void *argp1 = 0 ;
32821 int res1 = 0 ;
32822 PyObject *swig_obj[1] ;
32823
32824 if (!args) SWIG_fail;
32825 swig_obj[0] = args;
32826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32827 if (!SWIG_IsOK(res1)) {
32828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32829 }
32830 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32831 result = (wxColour *)& ((arg1)->colBg);
32832 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32833 return resultobj;
32834 fail:
32835 return NULL;
32836 }
32837
32838
32839 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32840 PyObject *obj;
32841 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32842 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
32843 return SWIG_Py_Void();
32844 }
32845
32846 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32847 return SWIG_Python_InitShadowInstance(args);
32848 }
32849
32850 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32851 PyObject *resultobj = 0;
32852 wxWindow *arg1 = (wxWindow *) 0 ;
32853 int arg2 = (int) (int)-1 ;
32854 wxPoint const &arg3_defvalue = wxDefaultPosition ;
32855 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
32856 wxSize const &arg4_defvalue = wxDefaultSize ;
32857 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32858 long arg5 = (long) 0 ;
32859 wxString const &arg6_defvalue = wxPyPanelNameStr ;
32860 wxString *arg6 = (wxString *) &arg6_defvalue ;
32861 wxWindow *result = 0 ;
32862 void *argp1 = 0 ;
32863 int res1 = 0 ;
32864 int val2 ;
32865 int ecode2 = 0 ;
32866 wxPoint temp3 ;
32867 wxSize temp4 ;
32868 long val5 ;
32869 int ecode5 = 0 ;
32870 bool temp6 = false ;
32871 PyObject * obj0 = 0 ;
32872 PyObject * obj1 = 0 ;
32873 PyObject * obj2 = 0 ;
32874 PyObject * obj3 = 0 ;
32875 PyObject * obj4 = 0 ;
32876 PyObject * obj5 = 0 ;
32877 char * kwnames[] = {
32878 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32879 };
32880
32881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
32882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32883 if (!SWIG_IsOK(res1)) {
32884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
32885 }
32886 arg1 = reinterpret_cast< wxWindow * >(argp1);
32887 if (obj1) {
32888 ecode2 = SWIG_AsVal_int(obj1, &val2);
32889 if (!SWIG_IsOK(ecode2)) {
32890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
32891 }
32892 arg2 = static_cast< int >(val2);
32893 }
32894 if (obj2) {
32895 {
32896 arg3 = &temp3;
32897 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
32898 }
32899 }
32900 if (obj3) {
32901 {
32902 arg4 = &temp4;
32903 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32904 }
32905 }
32906 if (obj4) {
32907 ecode5 = SWIG_AsVal_long(obj4, &val5);
32908 if (!SWIG_IsOK(ecode5)) {
32909 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
32910 }
32911 arg5 = static_cast< long >(val5);
32912 }
32913 if (obj5) {
32914 {
32915 arg6 = wxString_in_helper(obj5);
32916 if (arg6 == NULL) SWIG_fail;
32917 temp6 = true;
32918 }
32919 }
32920 {
32921 if (!wxPyCheckForApp()) SWIG_fail;
32922 PyThreadState* __tstate = wxPyBeginAllowThreads();
32923 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
32924 wxPyEndAllowThreads(__tstate);
32925 if (PyErr_Occurred()) SWIG_fail;
32926 }
32927 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
32928 {
32929 if (temp6)
32930 delete arg6;
32931 }
32932 return resultobj;
32933 fail:
32934 {
32935 if (temp6)
32936 delete arg6;
32937 }
32938 return NULL;
32939 }
32940
32941
32942 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32943 PyObject *resultobj = 0;
32944 wxWindow *result = 0 ;
32945
32946 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
32947 {
32948 if (!wxPyCheckForApp()) SWIG_fail;
32949 PyThreadState* __tstate = wxPyBeginAllowThreads();
32950 result = (wxWindow *)new wxWindow();
32951 wxPyEndAllowThreads(__tstate);
32952 if (PyErr_Occurred()) SWIG_fail;
32953 }
32954 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
32955 return resultobj;
32956 fail:
32957 return NULL;
32958 }
32959
32960
32961 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32962 PyObject *resultobj = 0;
32963 wxWindow *arg1 = (wxWindow *) 0 ;
32964 wxWindow *arg2 = (wxWindow *) 0 ;
32965 int arg3 = (int) (int)-1 ;
32966 wxPoint const &arg4_defvalue = wxDefaultPosition ;
32967 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
32968 wxSize const &arg5_defvalue = wxDefaultSize ;
32969 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
32970 long arg6 = (long) 0 ;
32971 wxString const &arg7_defvalue = wxPyPanelNameStr ;
32972 wxString *arg7 = (wxString *) &arg7_defvalue ;
32973 bool result;
32974 void *argp1 = 0 ;
32975 int res1 = 0 ;
32976 void *argp2 = 0 ;
32977 int res2 = 0 ;
32978 int val3 ;
32979 int ecode3 = 0 ;
32980 wxPoint temp4 ;
32981 wxSize temp5 ;
32982 long val6 ;
32983 int ecode6 = 0 ;
32984 bool temp7 = false ;
32985 PyObject * obj0 = 0 ;
32986 PyObject * obj1 = 0 ;
32987 PyObject * obj2 = 0 ;
32988 PyObject * obj3 = 0 ;
32989 PyObject * obj4 = 0 ;
32990 PyObject * obj5 = 0 ;
32991 PyObject * obj6 = 0 ;
32992 char * kwnames[] = {
32993 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32994 };
32995
32996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32998 if (!SWIG_IsOK(res1)) {
32999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
33000 }
33001 arg1 = reinterpret_cast< wxWindow * >(argp1);
33002 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33003 if (!SWIG_IsOK(res2)) {
33004 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
33005 }
33006 arg2 = reinterpret_cast< wxWindow * >(argp2);
33007 if (obj2) {
33008 ecode3 = SWIG_AsVal_int(obj2, &val3);
33009 if (!SWIG_IsOK(ecode3)) {
33010 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
33011 }
33012 arg3 = static_cast< int >(val3);
33013 }
33014 if (obj3) {
33015 {
33016 arg4 = &temp4;
33017 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
33018 }
33019 }
33020 if (obj4) {
33021 {
33022 arg5 = &temp5;
33023 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
33024 }
33025 }
33026 if (obj5) {
33027 ecode6 = SWIG_AsVal_long(obj5, &val6);
33028 if (!SWIG_IsOK(ecode6)) {
33029 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
33030 }
33031 arg6 = static_cast< long >(val6);
33032 }
33033 if (obj6) {
33034 {
33035 arg7 = wxString_in_helper(obj6);
33036 if (arg7 == NULL) SWIG_fail;
33037 temp7 = true;
33038 }
33039 }
33040 {
33041 PyThreadState* __tstate = wxPyBeginAllowThreads();
33042 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
33043 wxPyEndAllowThreads(__tstate);
33044 if (PyErr_Occurred()) SWIG_fail;
33045 }
33046 {
33047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33048 }
33049 {
33050 if (temp7)
33051 delete arg7;
33052 }
33053 return resultobj;
33054 fail:
33055 {
33056 if (temp7)
33057 delete arg7;
33058 }
33059 return NULL;
33060 }
33061
33062
33063 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33064 PyObject *resultobj = 0;
33065 wxWindow *arg1 = (wxWindow *) 0 ;
33066 bool arg2 = (bool) false ;
33067 bool result;
33068 void *argp1 = 0 ;
33069 int res1 = 0 ;
33070 bool val2 ;
33071 int ecode2 = 0 ;
33072 PyObject * obj0 = 0 ;
33073 PyObject * obj1 = 0 ;
33074 char * kwnames[] = {
33075 (char *) "self",(char *) "force", NULL
33076 };
33077
33078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
33079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33080 if (!SWIG_IsOK(res1)) {
33081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
33082 }
33083 arg1 = reinterpret_cast< wxWindow * >(argp1);
33084 if (obj1) {
33085 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33086 if (!SWIG_IsOK(ecode2)) {
33087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
33088 }
33089 arg2 = static_cast< bool >(val2);
33090 }
33091 {
33092 PyThreadState* __tstate = wxPyBeginAllowThreads();
33093 result = (bool)(arg1)->Close(arg2);
33094 wxPyEndAllowThreads(__tstate);
33095 if (PyErr_Occurred()) SWIG_fail;
33096 }
33097 {
33098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33099 }
33100 return resultobj;
33101 fail:
33102 return NULL;
33103 }
33104
33105
33106 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33107 PyObject *resultobj = 0;
33108 wxWindow *arg1 = (wxWindow *) 0 ;
33109 bool result;
33110 void *argp1 = 0 ;
33111 int res1 = 0 ;
33112 PyObject *swig_obj[1] ;
33113
33114 if (!args) SWIG_fail;
33115 swig_obj[0] = args;
33116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33117 if (!SWIG_IsOK(res1)) {
33118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
33119 }
33120 arg1 = reinterpret_cast< wxWindow * >(argp1);
33121 {
33122 PyThreadState* __tstate = wxPyBeginAllowThreads();
33123 result = (bool)(arg1)->Destroy();
33124 wxPyEndAllowThreads(__tstate);
33125 if (PyErr_Occurred()) SWIG_fail;
33126 }
33127 {
33128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33129 }
33130 return resultobj;
33131 fail:
33132 return NULL;
33133 }
33134
33135
33136 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33137 PyObject *resultobj = 0;
33138 wxWindow *arg1 = (wxWindow *) 0 ;
33139 bool result;
33140 void *argp1 = 0 ;
33141 int res1 = 0 ;
33142 PyObject *swig_obj[1] ;
33143
33144 if (!args) SWIG_fail;
33145 swig_obj[0] = args;
33146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33147 if (!SWIG_IsOK(res1)) {
33148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33149 }
33150 arg1 = reinterpret_cast< wxWindow * >(argp1);
33151 {
33152 PyThreadState* __tstate = wxPyBeginAllowThreads();
33153 result = (bool)(arg1)->DestroyChildren();
33154 wxPyEndAllowThreads(__tstate);
33155 if (PyErr_Occurred()) SWIG_fail;
33156 }
33157 {
33158 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33159 }
33160 return resultobj;
33161 fail:
33162 return NULL;
33163 }
33164
33165
33166 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33167 PyObject *resultobj = 0;
33168 wxWindow *arg1 = (wxWindow *) 0 ;
33169 bool result;
33170 void *argp1 = 0 ;
33171 int res1 = 0 ;
33172 PyObject *swig_obj[1] ;
33173
33174 if (!args) SWIG_fail;
33175 swig_obj[0] = args;
33176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33177 if (!SWIG_IsOK(res1)) {
33178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
33179 }
33180 arg1 = reinterpret_cast< wxWindow * >(argp1);
33181 {
33182 PyThreadState* __tstate = wxPyBeginAllowThreads();
33183 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
33184 wxPyEndAllowThreads(__tstate);
33185 if (PyErr_Occurred()) SWIG_fail;
33186 }
33187 {
33188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33189 }
33190 return resultobj;
33191 fail:
33192 return NULL;
33193 }
33194
33195
33196 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33197 PyObject *resultobj = 0;
33198 wxWindow *arg1 = (wxWindow *) 0 ;
33199 wxString *arg2 = 0 ;
33200 void *argp1 = 0 ;
33201 int res1 = 0 ;
33202 bool temp2 = false ;
33203 PyObject * obj0 = 0 ;
33204 PyObject * obj1 = 0 ;
33205 char * kwnames[] = {
33206 (char *) "self",(char *) "label", NULL
33207 };
33208
33209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
33210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33211 if (!SWIG_IsOK(res1)) {
33212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
33213 }
33214 arg1 = reinterpret_cast< wxWindow * >(argp1);
33215 {
33216 arg2 = wxString_in_helper(obj1);
33217 if (arg2 == NULL) SWIG_fail;
33218 temp2 = true;
33219 }
33220 {
33221 PyThreadState* __tstate = wxPyBeginAllowThreads();
33222 (arg1)->SetLabel((wxString const &)*arg2);
33223 wxPyEndAllowThreads(__tstate);
33224 if (PyErr_Occurred()) SWIG_fail;
33225 }
33226 resultobj = SWIG_Py_Void();
33227 {
33228 if (temp2)
33229 delete arg2;
33230 }
33231 return resultobj;
33232 fail:
33233 {
33234 if (temp2)
33235 delete arg2;
33236 }
33237 return NULL;
33238 }
33239
33240
33241 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33242 PyObject *resultobj = 0;
33243 wxWindow *arg1 = (wxWindow *) 0 ;
33244 wxString result;
33245 void *argp1 = 0 ;
33246 int res1 = 0 ;
33247 PyObject *swig_obj[1] ;
33248
33249 if (!args) SWIG_fail;
33250 swig_obj[0] = args;
33251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33252 if (!SWIG_IsOK(res1)) {
33253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33254 }
33255 arg1 = reinterpret_cast< wxWindow * >(argp1);
33256 {
33257 PyThreadState* __tstate = wxPyBeginAllowThreads();
33258 result = ((wxWindow const *)arg1)->GetLabel();
33259 wxPyEndAllowThreads(__tstate);
33260 if (PyErr_Occurred()) SWIG_fail;
33261 }
33262 {
33263 #if wxUSE_UNICODE
33264 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33265 #else
33266 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33267 #endif
33268 }
33269 return resultobj;
33270 fail:
33271 return NULL;
33272 }
33273
33274
33275 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33276 PyObject *resultobj = 0;
33277 wxWindow *arg1 = (wxWindow *) 0 ;
33278 wxString *arg2 = 0 ;
33279 void *argp1 = 0 ;
33280 int res1 = 0 ;
33281 bool temp2 = false ;
33282 PyObject * obj0 = 0 ;
33283 PyObject * obj1 = 0 ;
33284 char * kwnames[] = {
33285 (char *) "self",(char *) "name", NULL
33286 };
33287
33288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
33289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33290 if (!SWIG_IsOK(res1)) {
33291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
33292 }
33293 arg1 = reinterpret_cast< wxWindow * >(argp1);
33294 {
33295 arg2 = wxString_in_helper(obj1);
33296 if (arg2 == NULL) SWIG_fail;
33297 temp2 = true;
33298 }
33299 {
33300 PyThreadState* __tstate = wxPyBeginAllowThreads();
33301 (arg1)->SetName((wxString const &)*arg2);
33302 wxPyEndAllowThreads(__tstate);
33303 if (PyErr_Occurred()) SWIG_fail;
33304 }
33305 resultobj = SWIG_Py_Void();
33306 {
33307 if (temp2)
33308 delete arg2;
33309 }
33310 return resultobj;
33311 fail:
33312 {
33313 if (temp2)
33314 delete arg2;
33315 }
33316 return NULL;
33317 }
33318
33319
33320 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33321 PyObject *resultobj = 0;
33322 wxWindow *arg1 = (wxWindow *) 0 ;
33323 wxString result;
33324 void *argp1 = 0 ;
33325 int res1 = 0 ;
33326 PyObject *swig_obj[1] ;
33327
33328 if (!args) SWIG_fail;
33329 swig_obj[0] = args;
33330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33331 if (!SWIG_IsOK(res1)) {
33332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
33333 }
33334 arg1 = reinterpret_cast< wxWindow * >(argp1);
33335 {
33336 PyThreadState* __tstate = wxPyBeginAllowThreads();
33337 result = ((wxWindow const *)arg1)->GetName();
33338 wxPyEndAllowThreads(__tstate);
33339 if (PyErr_Occurred()) SWIG_fail;
33340 }
33341 {
33342 #if wxUSE_UNICODE
33343 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33344 #else
33345 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33346 #endif
33347 }
33348 return resultobj;
33349 fail:
33350 return NULL;
33351 }
33352
33353
33354 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33355 PyObject *resultobj = 0;
33356 wxWindow *arg1 = (wxWindow *) 0 ;
33357 wxWindowVariant arg2 ;
33358 void *argp1 = 0 ;
33359 int res1 = 0 ;
33360 int val2 ;
33361 int ecode2 = 0 ;
33362 PyObject * obj0 = 0 ;
33363 PyObject * obj1 = 0 ;
33364 char * kwnames[] = {
33365 (char *) "self",(char *) "variant", NULL
33366 };
33367
33368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
33369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33370 if (!SWIG_IsOK(res1)) {
33371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
33372 }
33373 arg1 = reinterpret_cast< wxWindow * >(argp1);
33374 ecode2 = SWIG_AsVal_int(obj1, &val2);
33375 if (!SWIG_IsOK(ecode2)) {
33376 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
33377 }
33378 arg2 = static_cast< wxWindowVariant >(val2);
33379 {
33380 PyThreadState* __tstate = wxPyBeginAllowThreads();
33381 (arg1)->SetWindowVariant(arg2);
33382 wxPyEndAllowThreads(__tstate);
33383 if (PyErr_Occurred()) SWIG_fail;
33384 }
33385 resultobj = SWIG_Py_Void();
33386 return resultobj;
33387 fail:
33388 return NULL;
33389 }
33390
33391
33392 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33393 PyObject *resultobj = 0;
33394 wxWindow *arg1 = (wxWindow *) 0 ;
33395 wxWindowVariant result;
33396 void *argp1 = 0 ;
33397 int res1 = 0 ;
33398 PyObject *swig_obj[1] ;
33399
33400 if (!args) SWIG_fail;
33401 swig_obj[0] = args;
33402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33403 if (!SWIG_IsOK(res1)) {
33404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
33405 }
33406 arg1 = reinterpret_cast< wxWindow * >(argp1);
33407 {
33408 PyThreadState* __tstate = wxPyBeginAllowThreads();
33409 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
33410 wxPyEndAllowThreads(__tstate);
33411 if (PyErr_Occurred()) SWIG_fail;
33412 }
33413 resultobj = SWIG_From_int(static_cast< int >(result));
33414 return resultobj;
33415 fail:
33416 return NULL;
33417 }
33418
33419
33420 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33421 PyObject *resultobj = 0;
33422 wxWindow *arg1 = (wxWindow *) 0 ;
33423 int arg2 ;
33424 void *argp1 = 0 ;
33425 int res1 = 0 ;
33426 int val2 ;
33427 int ecode2 = 0 ;
33428 PyObject * obj0 = 0 ;
33429 PyObject * obj1 = 0 ;
33430 char * kwnames[] = {
33431 (char *) "self",(char *) "winid", NULL
33432 };
33433
33434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
33435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33436 if (!SWIG_IsOK(res1)) {
33437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
33438 }
33439 arg1 = reinterpret_cast< wxWindow * >(argp1);
33440 ecode2 = SWIG_AsVal_int(obj1, &val2);
33441 if (!SWIG_IsOK(ecode2)) {
33442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
33443 }
33444 arg2 = static_cast< int >(val2);
33445 {
33446 PyThreadState* __tstate = wxPyBeginAllowThreads();
33447 (arg1)->SetId(arg2);
33448 wxPyEndAllowThreads(__tstate);
33449 if (PyErr_Occurred()) SWIG_fail;
33450 }
33451 resultobj = SWIG_Py_Void();
33452 return resultobj;
33453 fail:
33454 return NULL;
33455 }
33456
33457
33458 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33459 PyObject *resultobj = 0;
33460 wxWindow *arg1 = (wxWindow *) 0 ;
33461 int result;
33462 void *argp1 = 0 ;
33463 int res1 = 0 ;
33464 PyObject *swig_obj[1] ;
33465
33466 if (!args) SWIG_fail;
33467 swig_obj[0] = args;
33468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33469 if (!SWIG_IsOK(res1)) {
33470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
33471 }
33472 arg1 = reinterpret_cast< wxWindow * >(argp1);
33473 {
33474 PyThreadState* __tstate = wxPyBeginAllowThreads();
33475 result = (int)((wxWindow const *)arg1)->GetId();
33476 wxPyEndAllowThreads(__tstate);
33477 if (PyErr_Occurred()) SWIG_fail;
33478 }
33479 resultobj = SWIG_From_int(static_cast< int >(result));
33480 return resultobj;
33481 fail:
33482 return NULL;
33483 }
33484
33485
33486 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33487 PyObject *resultobj = 0;
33488 int result;
33489
33490 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
33491 {
33492 PyThreadState* __tstate = wxPyBeginAllowThreads();
33493 result = (int)wxWindow::NewControlId();
33494 wxPyEndAllowThreads(__tstate);
33495 if (PyErr_Occurred()) SWIG_fail;
33496 }
33497 resultobj = SWIG_From_int(static_cast< int >(result));
33498 return resultobj;
33499 fail:
33500 return NULL;
33501 }
33502
33503
33504 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33505 PyObject *resultobj = 0;
33506 int arg1 ;
33507 int result;
33508 int val1 ;
33509 int ecode1 = 0 ;
33510 PyObject * obj0 = 0 ;
33511 char * kwnames[] = {
33512 (char *) "winid", NULL
33513 };
33514
33515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
33516 ecode1 = SWIG_AsVal_int(obj0, &val1);
33517 if (!SWIG_IsOK(ecode1)) {
33518 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
33519 }
33520 arg1 = static_cast< int >(val1);
33521 {
33522 PyThreadState* __tstate = wxPyBeginAllowThreads();
33523 result = (int)wxWindow::NextControlId(arg1);
33524 wxPyEndAllowThreads(__tstate);
33525 if (PyErr_Occurred()) SWIG_fail;
33526 }
33527 resultobj = SWIG_From_int(static_cast< int >(result));
33528 return resultobj;
33529 fail:
33530 return NULL;
33531 }
33532
33533
33534 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33535 PyObject *resultobj = 0;
33536 int arg1 ;
33537 int result;
33538 int val1 ;
33539 int ecode1 = 0 ;
33540 PyObject * obj0 = 0 ;
33541 char * kwnames[] = {
33542 (char *) "winid", NULL
33543 };
33544
33545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
33546 ecode1 = SWIG_AsVal_int(obj0, &val1);
33547 if (!SWIG_IsOK(ecode1)) {
33548 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
33549 }
33550 arg1 = static_cast< int >(val1);
33551 {
33552 PyThreadState* __tstate = wxPyBeginAllowThreads();
33553 result = (int)wxWindow::PrevControlId(arg1);
33554 wxPyEndAllowThreads(__tstate);
33555 if (PyErr_Occurred()) SWIG_fail;
33556 }
33557 resultobj = SWIG_From_int(static_cast< int >(result));
33558 return resultobj;
33559 fail:
33560 return NULL;
33561 }
33562
33563
33564 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33565 PyObject *resultobj = 0;
33566 wxWindow *arg1 = (wxWindow *) 0 ;
33567 wxLayoutDirection result;
33568 void *argp1 = 0 ;
33569 int res1 = 0 ;
33570 PyObject *swig_obj[1] ;
33571
33572 if (!args) SWIG_fail;
33573 swig_obj[0] = args;
33574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33575 if (!SWIG_IsOK(res1)) {
33576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33577 }
33578 arg1 = reinterpret_cast< wxWindow * >(argp1);
33579 {
33580 PyThreadState* __tstate = wxPyBeginAllowThreads();
33581 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
33582 wxPyEndAllowThreads(__tstate);
33583 if (PyErr_Occurred()) SWIG_fail;
33584 }
33585 resultobj = SWIG_From_int(static_cast< int >(result));
33586 return resultobj;
33587 fail:
33588 return NULL;
33589 }
33590
33591
33592 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33593 PyObject *resultobj = 0;
33594 wxWindow *arg1 = (wxWindow *) 0 ;
33595 wxLayoutDirection arg2 ;
33596 void *argp1 = 0 ;
33597 int res1 = 0 ;
33598 int val2 ;
33599 int ecode2 = 0 ;
33600 PyObject * obj0 = 0 ;
33601 PyObject * obj1 = 0 ;
33602 char * kwnames[] = {
33603 (char *) "self",(char *) "dir", NULL
33604 };
33605
33606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
33607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33608 if (!SWIG_IsOK(res1)) {
33609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
33610 }
33611 arg1 = reinterpret_cast< wxWindow * >(argp1);
33612 ecode2 = SWIG_AsVal_int(obj1, &val2);
33613 if (!SWIG_IsOK(ecode2)) {
33614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
33615 }
33616 arg2 = static_cast< wxLayoutDirection >(val2);
33617 {
33618 PyThreadState* __tstate = wxPyBeginAllowThreads();
33619 (arg1)->SetLayoutDirection(arg2);
33620 wxPyEndAllowThreads(__tstate);
33621 if (PyErr_Occurred()) SWIG_fail;
33622 }
33623 resultobj = SWIG_Py_Void();
33624 return resultobj;
33625 fail:
33626 return NULL;
33627 }
33628
33629
33630 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33631 PyObject *resultobj = 0;
33632 wxWindow *arg1 = (wxWindow *) 0 ;
33633 int arg2 ;
33634 int arg3 ;
33635 int arg4 ;
33636 int result;
33637 void *argp1 = 0 ;
33638 int res1 = 0 ;
33639 int val2 ;
33640 int ecode2 = 0 ;
33641 int val3 ;
33642 int ecode3 = 0 ;
33643 int val4 ;
33644 int ecode4 = 0 ;
33645 PyObject * obj0 = 0 ;
33646 PyObject * obj1 = 0 ;
33647 PyObject * obj2 = 0 ;
33648 PyObject * obj3 = 0 ;
33649 char * kwnames[] = {
33650 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
33651 };
33652
33653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33655 if (!SWIG_IsOK(res1)) {
33656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33657 }
33658 arg1 = reinterpret_cast< wxWindow * >(argp1);
33659 ecode2 = SWIG_AsVal_int(obj1, &val2);
33660 if (!SWIG_IsOK(ecode2)) {
33661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
33662 }
33663 arg2 = static_cast< int >(val2);
33664 ecode3 = SWIG_AsVal_int(obj2, &val3);
33665 if (!SWIG_IsOK(ecode3)) {
33666 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
33667 }
33668 arg3 = static_cast< int >(val3);
33669 ecode4 = SWIG_AsVal_int(obj3, &val4);
33670 if (!SWIG_IsOK(ecode4)) {
33671 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
33672 }
33673 arg4 = static_cast< int >(val4);
33674 {
33675 PyThreadState* __tstate = wxPyBeginAllowThreads();
33676 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
33677 wxPyEndAllowThreads(__tstate);
33678 if (PyErr_Occurred()) SWIG_fail;
33679 }
33680 resultobj = SWIG_From_int(static_cast< int >(result));
33681 return resultobj;
33682 fail:
33683 return NULL;
33684 }
33685
33686
33687 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33688 PyObject *resultobj = 0;
33689 wxWindow *arg1 = (wxWindow *) 0 ;
33690 wxSize *arg2 = 0 ;
33691 void *argp1 = 0 ;
33692 int res1 = 0 ;
33693 wxSize temp2 ;
33694 PyObject * obj0 = 0 ;
33695 PyObject * obj1 = 0 ;
33696 char * kwnames[] = {
33697 (char *) "self",(char *) "size", NULL
33698 };
33699
33700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
33701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33702 if (!SWIG_IsOK(res1)) {
33703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33704 }
33705 arg1 = reinterpret_cast< wxWindow * >(argp1);
33706 {
33707 arg2 = &temp2;
33708 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33709 }
33710 {
33711 PyThreadState* __tstate = wxPyBeginAllowThreads();
33712 (arg1)->SetSize((wxSize const &)*arg2);
33713 wxPyEndAllowThreads(__tstate);
33714 if (PyErr_Occurred()) SWIG_fail;
33715 }
33716 resultobj = SWIG_Py_Void();
33717 return resultobj;
33718 fail:
33719 return NULL;
33720 }
33721
33722
33723 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33724 PyObject *resultobj = 0;
33725 wxWindow *arg1 = (wxWindow *) 0 ;
33726 int arg2 ;
33727 int arg3 ;
33728 int arg4 ;
33729 int arg5 ;
33730 int arg6 = (int) wxSIZE_AUTO ;
33731 void *argp1 = 0 ;
33732 int res1 = 0 ;
33733 int val2 ;
33734 int ecode2 = 0 ;
33735 int val3 ;
33736 int ecode3 = 0 ;
33737 int val4 ;
33738 int ecode4 = 0 ;
33739 int val5 ;
33740 int ecode5 = 0 ;
33741 int val6 ;
33742 int ecode6 = 0 ;
33743 PyObject * obj0 = 0 ;
33744 PyObject * obj1 = 0 ;
33745 PyObject * obj2 = 0 ;
33746 PyObject * obj3 = 0 ;
33747 PyObject * obj4 = 0 ;
33748 PyObject * obj5 = 0 ;
33749 char * kwnames[] = {
33750 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
33751 };
33752
33753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
33754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33755 if (!SWIG_IsOK(res1)) {
33756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
33757 }
33758 arg1 = reinterpret_cast< wxWindow * >(argp1);
33759 ecode2 = SWIG_AsVal_int(obj1, &val2);
33760 if (!SWIG_IsOK(ecode2)) {
33761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
33762 }
33763 arg2 = static_cast< int >(val2);
33764 ecode3 = SWIG_AsVal_int(obj2, &val3);
33765 if (!SWIG_IsOK(ecode3)) {
33766 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
33767 }
33768 arg3 = static_cast< int >(val3);
33769 ecode4 = SWIG_AsVal_int(obj3, &val4);
33770 if (!SWIG_IsOK(ecode4)) {
33771 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
33772 }
33773 arg4 = static_cast< int >(val4);
33774 ecode5 = SWIG_AsVal_int(obj4, &val5);
33775 if (!SWIG_IsOK(ecode5)) {
33776 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
33777 }
33778 arg5 = static_cast< int >(val5);
33779 if (obj5) {
33780 ecode6 = SWIG_AsVal_int(obj5, &val6);
33781 if (!SWIG_IsOK(ecode6)) {
33782 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
33783 }
33784 arg6 = static_cast< int >(val6);
33785 }
33786 {
33787 PyThreadState* __tstate = wxPyBeginAllowThreads();
33788 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
33789 wxPyEndAllowThreads(__tstate);
33790 if (PyErr_Occurred()) SWIG_fail;
33791 }
33792 resultobj = SWIG_Py_Void();
33793 return resultobj;
33794 fail:
33795 return NULL;
33796 }
33797
33798
33799 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33800 PyObject *resultobj = 0;
33801 wxWindow *arg1 = (wxWindow *) 0 ;
33802 wxRect *arg2 = 0 ;
33803 int arg3 = (int) wxSIZE_AUTO ;
33804 void *argp1 = 0 ;
33805 int res1 = 0 ;
33806 wxRect temp2 ;
33807 int val3 ;
33808 int ecode3 = 0 ;
33809 PyObject * obj0 = 0 ;
33810 PyObject * obj1 = 0 ;
33811 PyObject * obj2 = 0 ;
33812 char * kwnames[] = {
33813 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
33814 };
33815
33816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33818 if (!SWIG_IsOK(res1)) {
33819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
33820 }
33821 arg1 = reinterpret_cast< wxWindow * >(argp1);
33822 {
33823 arg2 = &temp2;
33824 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
33825 }
33826 if (obj2) {
33827 ecode3 = SWIG_AsVal_int(obj2, &val3);
33828 if (!SWIG_IsOK(ecode3)) {
33829 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
33830 }
33831 arg3 = static_cast< int >(val3);
33832 }
33833 {
33834 PyThreadState* __tstate = wxPyBeginAllowThreads();
33835 (arg1)->SetSize((wxRect const &)*arg2,arg3);
33836 wxPyEndAllowThreads(__tstate);
33837 if (PyErr_Occurred()) SWIG_fail;
33838 }
33839 resultobj = SWIG_Py_Void();
33840 return resultobj;
33841 fail:
33842 return NULL;
33843 }
33844
33845
33846 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33847 PyObject *resultobj = 0;
33848 wxWindow *arg1 = (wxWindow *) 0 ;
33849 int arg2 ;
33850 int arg3 ;
33851 void *argp1 = 0 ;
33852 int res1 = 0 ;
33853 int val2 ;
33854 int ecode2 = 0 ;
33855 int val3 ;
33856 int ecode3 = 0 ;
33857 PyObject * obj0 = 0 ;
33858 PyObject * obj1 = 0 ;
33859 PyObject * obj2 = 0 ;
33860 char * kwnames[] = {
33861 (char *) "self",(char *) "width",(char *) "height", NULL
33862 };
33863
33864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33866 if (!SWIG_IsOK(res1)) {
33867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33868 }
33869 arg1 = reinterpret_cast< wxWindow * >(argp1);
33870 ecode2 = SWIG_AsVal_int(obj1, &val2);
33871 if (!SWIG_IsOK(ecode2)) {
33872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
33873 }
33874 arg2 = static_cast< int >(val2);
33875 ecode3 = SWIG_AsVal_int(obj2, &val3);
33876 if (!SWIG_IsOK(ecode3)) {
33877 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
33878 }
33879 arg3 = static_cast< int >(val3);
33880 {
33881 PyThreadState* __tstate = wxPyBeginAllowThreads();
33882 (arg1)->SetSize(arg2,arg3);
33883 wxPyEndAllowThreads(__tstate);
33884 if (PyErr_Occurred()) SWIG_fail;
33885 }
33886 resultobj = SWIG_Py_Void();
33887 return resultobj;
33888 fail:
33889 return NULL;
33890 }
33891
33892
33893 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33894 PyObject *resultobj = 0;
33895 wxWindow *arg1 = (wxWindow *) 0 ;
33896 wxPoint *arg2 = 0 ;
33897 int arg3 = (int) wxSIZE_USE_EXISTING ;
33898 void *argp1 = 0 ;
33899 int res1 = 0 ;
33900 wxPoint temp2 ;
33901 int val3 ;
33902 int ecode3 = 0 ;
33903 PyObject * obj0 = 0 ;
33904 PyObject * obj1 = 0 ;
33905 PyObject * obj2 = 0 ;
33906 char * kwnames[] = {
33907 (char *) "self",(char *) "pt",(char *) "flags", NULL
33908 };
33909
33910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33912 if (!SWIG_IsOK(res1)) {
33913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
33914 }
33915 arg1 = reinterpret_cast< wxWindow * >(argp1);
33916 {
33917 arg2 = &temp2;
33918 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33919 }
33920 if (obj2) {
33921 ecode3 = SWIG_AsVal_int(obj2, &val3);
33922 if (!SWIG_IsOK(ecode3)) {
33923 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
33924 }
33925 arg3 = static_cast< int >(val3);
33926 }
33927 {
33928 PyThreadState* __tstate = wxPyBeginAllowThreads();
33929 (arg1)->Move((wxPoint const &)*arg2,arg3);
33930 wxPyEndAllowThreads(__tstate);
33931 if (PyErr_Occurred()) SWIG_fail;
33932 }
33933 resultobj = SWIG_Py_Void();
33934 return resultobj;
33935 fail:
33936 return NULL;
33937 }
33938
33939
33940 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33941 PyObject *resultobj = 0;
33942 wxWindow *arg1 = (wxWindow *) 0 ;
33943 int arg2 ;
33944 int arg3 ;
33945 int arg4 = (int) wxSIZE_USE_EXISTING ;
33946 void *argp1 = 0 ;
33947 int res1 = 0 ;
33948 int val2 ;
33949 int ecode2 = 0 ;
33950 int val3 ;
33951 int ecode3 = 0 ;
33952 int val4 ;
33953 int ecode4 = 0 ;
33954 PyObject * obj0 = 0 ;
33955 PyObject * obj1 = 0 ;
33956 PyObject * obj2 = 0 ;
33957 PyObject * obj3 = 0 ;
33958 char * kwnames[] = {
33959 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
33960 };
33961
33962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33964 if (!SWIG_IsOK(res1)) {
33965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
33966 }
33967 arg1 = reinterpret_cast< wxWindow * >(argp1);
33968 ecode2 = SWIG_AsVal_int(obj1, &val2);
33969 if (!SWIG_IsOK(ecode2)) {
33970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
33971 }
33972 arg2 = static_cast< int >(val2);
33973 ecode3 = SWIG_AsVal_int(obj2, &val3);
33974 if (!SWIG_IsOK(ecode3)) {
33975 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
33976 }
33977 arg3 = static_cast< int >(val3);
33978 if (obj3) {
33979 ecode4 = SWIG_AsVal_int(obj3, &val4);
33980 if (!SWIG_IsOK(ecode4)) {
33981 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
33982 }
33983 arg4 = static_cast< int >(val4);
33984 }
33985 {
33986 PyThreadState* __tstate = wxPyBeginAllowThreads();
33987 (arg1)->Move(arg2,arg3,arg4);
33988 wxPyEndAllowThreads(__tstate);
33989 if (PyErr_Occurred()) SWIG_fail;
33990 }
33991 resultobj = SWIG_Py_Void();
33992 return resultobj;
33993 fail:
33994 return NULL;
33995 }
33996
33997
33998 SWIGINTERN PyObject *_wrap_Window_SetInitialSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33999 PyObject *resultobj = 0;
34000 wxWindow *arg1 = (wxWindow *) 0 ;
34001 wxSize const &arg2_defvalue = wxDefaultSize ;
34002 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
34003 void *argp1 = 0 ;
34004 int res1 = 0 ;
34005 wxSize temp2 ;
34006 PyObject * obj0 = 0 ;
34007 PyObject * obj1 = 0 ;
34008 char * kwnames[] = {
34009 (char *) "self",(char *) "size", NULL
34010 };
34011
34012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetInitialSize",kwnames,&obj0,&obj1)) SWIG_fail;
34013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34014 if (!SWIG_IsOK(res1)) {
34015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetInitialSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34016 }
34017 arg1 = reinterpret_cast< wxWindow * >(argp1);
34018 if (obj1) {
34019 {
34020 arg2 = &temp2;
34021 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34022 }
34023 }
34024 {
34025 PyThreadState* __tstate = wxPyBeginAllowThreads();
34026 (arg1)->SetInitialSize((wxSize const &)*arg2);
34027 wxPyEndAllowThreads(__tstate);
34028 if (PyErr_Occurred()) SWIG_fail;
34029 }
34030 resultobj = SWIG_Py_Void();
34031 return resultobj;
34032 fail:
34033 return NULL;
34034 }
34035
34036
34037 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34038 PyObject *resultobj = 0;
34039 wxWindow *arg1 = (wxWindow *) 0 ;
34040 void *argp1 = 0 ;
34041 int res1 = 0 ;
34042 PyObject *swig_obj[1] ;
34043
34044 if (!args) SWIG_fail;
34045 swig_obj[0] = args;
34046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34047 if (!SWIG_IsOK(res1)) {
34048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
34049 }
34050 arg1 = reinterpret_cast< wxWindow * >(argp1);
34051 {
34052 PyThreadState* __tstate = wxPyBeginAllowThreads();
34053 (arg1)->Raise();
34054 wxPyEndAllowThreads(__tstate);
34055 if (PyErr_Occurred()) SWIG_fail;
34056 }
34057 resultobj = SWIG_Py_Void();
34058 return resultobj;
34059 fail:
34060 return NULL;
34061 }
34062
34063
34064 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34065 PyObject *resultobj = 0;
34066 wxWindow *arg1 = (wxWindow *) 0 ;
34067 void *argp1 = 0 ;
34068 int res1 = 0 ;
34069 PyObject *swig_obj[1] ;
34070
34071 if (!args) SWIG_fail;
34072 swig_obj[0] = args;
34073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34074 if (!SWIG_IsOK(res1)) {
34075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
34076 }
34077 arg1 = reinterpret_cast< wxWindow * >(argp1);
34078 {
34079 PyThreadState* __tstate = wxPyBeginAllowThreads();
34080 (arg1)->Lower();
34081 wxPyEndAllowThreads(__tstate);
34082 if (PyErr_Occurred()) SWIG_fail;
34083 }
34084 resultobj = SWIG_Py_Void();
34085 return resultobj;
34086 fail:
34087 return NULL;
34088 }
34089
34090
34091 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34092 PyObject *resultobj = 0;
34093 wxWindow *arg1 = (wxWindow *) 0 ;
34094 wxSize *arg2 = 0 ;
34095 void *argp1 = 0 ;
34096 int res1 = 0 ;
34097 wxSize temp2 ;
34098 PyObject * obj0 = 0 ;
34099 PyObject * obj1 = 0 ;
34100 char * kwnames[] = {
34101 (char *) "self",(char *) "size", NULL
34102 };
34103
34104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
34105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34106 if (!SWIG_IsOK(res1)) {
34107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34108 }
34109 arg1 = reinterpret_cast< wxWindow * >(argp1);
34110 {
34111 arg2 = &temp2;
34112 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34113 }
34114 {
34115 PyThreadState* __tstate = wxPyBeginAllowThreads();
34116 (arg1)->SetClientSize((wxSize const &)*arg2);
34117 wxPyEndAllowThreads(__tstate);
34118 if (PyErr_Occurred()) SWIG_fail;
34119 }
34120 resultobj = SWIG_Py_Void();
34121 return resultobj;
34122 fail:
34123 return NULL;
34124 }
34125
34126
34127 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34128 PyObject *resultobj = 0;
34129 wxWindow *arg1 = (wxWindow *) 0 ;
34130 int arg2 ;
34131 int arg3 ;
34132 void *argp1 = 0 ;
34133 int res1 = 0 ;
34134 int val2 ;
34135 int ecode2 = 0 ;
34136 int val3 ;
34137 int ecode3 = 0 ;
34138 PyObject * obj0 = 0 ;
34139 PyObject * obj1 = 0 ;
34140 PyObject * obj2 = 0 ;
34141 char * kwnames[] = {
34142 (char *) "self",(char *) "width",(char *) "height", NULL
34143 };
34144
34145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34147 if (!SWIG_IsOK(res1)) {
34148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
34149 }
34150 arg1 = reinterpret_cast< wxWindow * >(argp1);
34151 ecode2 = SWIG_AsVal_int(obj1, &val2);
34152 if (!SWIG_IsOK(ecode2)) {
34153 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
34154 }
34155 arg2 = static_cast< int >(val2);
34156 ecode3 = SWIG_AsVal_int(obj2, &val3);
34157 if (!SWIG_IsOK(ecode3)) {
34158 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
34159 }
34160 arg3 = static_cast< int >(val3);
34161 {
34162 PyThreadState* __tstate = wxPyBeginAllowThreads();
34163 (arg1)->SetClientSize(arg2,arg3);
34164 wxPyEndAllowThreads(__tstate);
34165 if (PyErr_Occurred()) SWIG_fail;
34166 }
34167 resultobj = SWIG_Py_Void();
34168 return resultobj;
34169 fail:
34170 return NULL;
34171 }
34172
34173
34174 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34175 PyObject *resultobj = 0;
34176 wxWindow *arg1 = (wxWindow *) 0 ;
34177 wxRect *arg2 = 0 ;
34178 void *argp1 = 0 ;
34179 int res1 = 0 ;
34180 wxRect temp2 ;
34181 PyObject * obj0 = 0 ;
34182 PyObject * obj1 = 0 ;
34183 char * kwnames[] = {
34184 (char *) "self",(char *) "rect", NULL
34185 };
34186
34187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
34188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34189 if (!SWIG_IsOK(res1)) {
34190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34191 }
34192 arg1 = reinterpret_cast< wxWindow * >(argp1);
34193 {
34194 arg2 = &temp2;
34195 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34196 }
34197 {
34198 PyThreadState* __tstate = wxPyBeginAllowThreads();
34199 (arg1)->SetClientSize((wxRect const &)*arg2);
34200 wxPyEndAllowThreads(__tstate);
34201 if (PyErr_Occurred()) SWIG_fail;
34202 }
34203 resultobj = SWIG_Py_Void();
34204 return resultobj;
34205 fail:
34206 return NULL;
34207 }
34208
34209
34210 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34211 PyObject *resultobj = 0;
34212 wxWindow *arg1 = (wxWindow *) 0 ;
34213 wxPoint result;
34214 void *argp1 = 0 ;
34215 int res1 = 0 ;
34216 PyObject *swig_obj[1] ;
34217
34218 if (!args) SWIG_fail;
34219 swig_obj[0] = args;
34220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34221 if (!SWIG_IsOK(res1)) {
34222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34223 }
34224 arg1 = reinterpret_cast< wxWindow * >(argp1);
34225 {
34226 PyThreadState* __tstate = wxPyBeginAllowThreads();
34227 result = ((wxWindow const *)arg1)->GetPosition();
34228 wxPyEndAllowThreads(__tstate);
34229 if (PyErr_Occurred()) SWIG_fail;
34230 }
34231 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34232 return resultobj;
34233 fail:
34234 return NULL;
34235 }
34236
34237
34238 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34239 PyObject *resultobj = 0;
34240 wxWindow *arg1 = (wxWindow *) 0 ;
34241 int *arg2 = (int *) 0 ;
34242 int *arg3 = (int *) 0 ;
34243 void *argp1 = 0 ;
34244 int res1 = 0 ;
34245 int temp2 ;
34246 int res2 = SWIG_TMPOBJ ;
34247 int temp3 ;
34248 int res3 = SWIG_TMPOBJ ;
34249 PyObject *swig_obj[1] ;
34250
34251 arg2 = &temp2;
34252 arg3 = &temp3;
34253 if (!args) SWIG_fail;
34254 swig_obj[0] = args;
34255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34256 if (!SWIG_IsOK(res1)) {
34257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34258 }
34259 arg1 = reinterpret_cast< wxWindow * >(argp1);
34260 {
34261 PyThreadState* __tstate = wxPyBeginAllowThreads();
34262 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
34263 wxPyEndAllowThreads(__tstate);
34264 if (PyErr_Occurred()) SWIG_fail;
34265 }
34266 resultobj = SWIG_Py_Void();
34267 if (SWIG_IsTmpObj(res2)) {
34268 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34269 } else {
34270 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34271 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34272 }
34273 if (SWIG_IsTmpObj(res3)) {
34274 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34275 } else {
34276 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34277 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34278 }
34279 return resultobj;
34280 fail:
34281 return NULL;
34282 }
34283
34284
34285 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34286 PyObject *resultobj = 0;
34287 wxWindow *arg1 = (wxWindow *) 0 ;
34288 wxPoint result;
34289 void *argp1 = 0 ;
34290 int res1 = 0 ;
34291 PyObject *swig_obj[1] ;
34292
34293 if (!args) SWIG_fail;
34294 swig_obj[0] = args;
34295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34296 if (!SWIG_IsOK(res1)) {
34297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34298 }
34299 arg1 = reinterpret_cast< wxWindow * >(argp1);
34300 {
34301 PyThreadState* __tstate = wxPyBeginAllowThreads();
34302 result = ((wxWindow const *)arg1)->GetScreenPosition();
34303 wxPyEndAllowThreads(__tstate);
34304 if (PyErr_Occurred()) SWIG_fail;
34305 }
34306 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34307 return resultobj;
34308 fail:
34309 return NULL;
34310 }
34311
34312
34313 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34314 PyObject *resultobj = 0;
34315 wxWindow *arg1 = (wxWindow *) 0 ;
34316 int *arg2 = (int *) 0 ;
34317 int *arg3 = (int *) 0 ;
34318 void *argp1 = 0 ;
34319 int res1 = 0 ;
34320 int temp2 ;
34321 int res2 = SWIG_TMPOBJ ;
34322 int temp3 ;
34323 int res3 = SWIG_TMPOBJ ;
34324 PyObject *swig_obj[1] ;
34325
34326 arg2 = &temp2;
34327 arg3 = &temp3;
34328 if (!args) SWIG_fail;
34329 swig_obj[0] = args;
34330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34331 if (!SWIG_IsOK(res1)) {
34332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34333 }
34334 arg1 = reinterpret_cast< wxWindow * >(argp1);
34335 {
34336 PyThreadState* __tstate = wxPyBeginAllowThreads();
34337 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
34338 wxPyEndAllowThreads(__tstate);
34339 if (PyErr_Occurred()) SWIG_fail;
34340 }
34341 resultobj = SWIG_Py_Void();
34342 if (SWIG_IsTmpObj(res2)) {
34343 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34344 } else {
34345 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34346 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34347 }
34348 if (SWIG_IsTmpObj(res3)) {
34349 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34350 } else {
34351 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34352 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34353 }
34354 return resultobj;
34355 fail:
34356 return NULL;
34357 }
34358
34359
34360 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34361 PyObject *resultobj = 0;
34362 wxWindow *arg1 = (wxWindow *) 0 ;
34363 wxRect result;
34364 void *argp1 = 0 ;
34365 int res1 = 0 ;
34366 PyObject *swig_obj[1] ;
34367
34368 if (!args) SWIG_fail;
34369 swig_obj[0] = args;
34370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34371 if (!SWIG_IsOK(res1)) {
34372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34373 }
34374 arg1 = reinterpret_cast< wxWindow * >(argp1);
34375 {
34376 PyThreadState* __tstate = wxPyBeginAllowThreads();
34377 result = ((wxWindow const *)arg1)->GetScreenRect();
34378 wxPyEndAllowThreads(__tstate);
34379 if (PyErr_Occurred()) SWIG_fail;
34380 }
34381 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34382 return resultobj;
34383 fail:
34384 return NULL;
34385 }
34386
34387
34388 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34389 PyObject *resultobj = 0;
34390 wxWindow *arg1 = (wxWindow *) 0 ;
34391 wxSize result;
34392 void *argp1 = 0 ;
34393 int res1 = 0 ;
34394 PyObject *swig_obj[1] ;
34395
34396 if (!args) SWIG_fail;
34397 swig_obj[0] = args;
34398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34399 if (!SWIG_IsOK(res1)) {
34400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34401 }
34402 arg1 = reinterpret_cast< wxWindow * >(argp1);
34403 {
34404 PyThreadState* __tstate = wxPyBeginAllowThreads();
34405 result = ((wxWindow const *)arg1)->GetSize();
34406 wxPyEndAllowThreads(__tstate);
34407 if (PyErr_Occurred()) SWIG_fail;
34408 }
34409 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34410 return resultobj;
34411 fail:
34412 return NULL;
34413 }
34414
34415
34416 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34417 PyObject *resultobj = 0;
34418 wxWindow *arg1 = (wxWindow *) 0 ;
34419 int *arg2 = (int *) 0 ;
34420 int *arg3 = (int *) 0 ;
34421 void *argp1 = 0 ;
34422 int res1 = 0 ;
34423 int temp2 ;
34424 int res2 = SWIG_TMPOBJ ;
34425 int temp3 ;
34426 int res3 = SWIG_TMPOBJ ;
34427 PyObject *swig_obj[1] ;
34428
34429 arg2 = &temp2;
34430 arg3 = &temp3;
34431 if (!args) SWIG_fail;
34432 swig_obj[0] = args;
34433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34434 if (!SWIG_IsOK(res1)) {
34435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34436 }
34437 arg1 = reinterpret_cast< wxWindow * >(argp1);
34438 {
34439 PyThreadState* __tstate = wxPyBeginAllowThreads();
34440 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
34441 wxPyEndAllowThreads(__tstate);
34442 if (PyErr_Occurred()) SWIG_fail;
34443 }
34444 resultobj = SWIG_Py_Void();
34445 if (SWIG_IsTmpObj(res2)) {
34446 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34447 } else {
34448 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34449 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34450 }
34451 if (SWIG_IsTmpObj(res3)) {
34452 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34453 } else {
34454 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34455 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34456 }
34457 return resultobj;
34458 fail:
34459 return NULL;
34460 }
34461
34462
34463 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34464 PyObject *resultobj = 0;
34465 wxWindow *arg1 = (wxWindow *) 0 ;
34466 wxRect result;
34467 void *argp1 = 0 ;
34468 int res1 = 0 ;
34469 PyObject *swig_obj[1] ;
34470
34471 if (!args) SWIG_fail;
34472 swig_obj[0] = args;
34473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34474 if (!SWIG_IsOK(res1)) {
34475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34476 }
34477 arg1 = reinterpret_cast< wxWindow * >(argp1);
34478 {
34479 PyThreadState* __tstate = wxPyBeginAllowThreads();
34480 result = ((wxWindow const *)arg1)->GetRect();
34481 wxPyEndAllowThreads(__tstate);
34482 if (PyErr_Occurred()) SWIG_fail;
34483 }
34484 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34485 return resultobj;
34486 fail:
34487 return NULL;
34488 }
34489
34490
34491 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34492 PyObject *resultobj = 0;
34493 wxWindow *arg1 = (wxWindow *) 0 ;
34494 wxSize result;
34495 void *argp1 = 0 ;
34496 int res1 = 0 ;
34497 PyObject *swig_obj[1] ;
34498
34499 if (!args) SWIG_fail;
34500 swig_obj[0] = args;
34501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34502 if (!SWIG_IsOK(res1)) {
34503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34504 }
34505 arg1 = reinterpret_cast< wxWindow * >(argp1);
34506 {
34507 PyThreadState* __tstate = wxPyBeginAllowThreads();
34508 result = ((wxWindow const *)arg1)->GetClientSize();
34509 wxPyEndAllowThreads(__tstate);
34510 if (PyErr_Occurred()) SWIG_fail;
34511 }
34512 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34513 return resultobj;
34514 fail:
34515 return NULL;
34516 }
34517
34518
34519 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34520 PyObject *resultobj = 0;
34521 wxWindow *arg1 = (wxWindow *) 0 ;
34522 int *arg2 = (int *) 0 ;
34523 int *arg3 = (int *) 0 ;
34524 void *argp1 = 0 ;
34525 int res1 = 0 ;
34526 int temp2 ;
34527 int res2 = SWIG_TMPOBJ ;
34528 int temp3 ;
34529 int res3 = SWIG_TMPOBJ ;
34530 PyObject *swig_obj[1] ;
34531
34532 arg2 = &temp2;
34533 arg3 = &temp3;
34534 if (!args) SWIG_fail;
34535 swig_obj[0] = args;
34536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34537 if (!SWIG_IsOK(res1)) {
34538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34539 }
34540 arg1 = reinterpret_cast< wxWindow * >(argp1);
34541 {
34542 PyThreadState* __tstate = wxPyBeginAllowThreads();
34543 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
34544 wxPyEndAllowThreads(__tstate);
34545 if (PyErr_Occurred()) SWIG_fail;
34546 }
34547 resultobj = SWIG_Py_Void();
34548 if (SWIG_IsTmpObj(res2)) {
34549 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34550 } else {
34551 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34552 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34553 }
34554 if (SWIG_IsTmpObj(res3)) {
34555 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34556 } else {
34557 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34558 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34559 }
34560 return resultobj;
34561 fail:
34562 return NULL;
34563 }
34564
34565
34566 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34567 PyObject *resultobj = 0;
34568 wxWindow *arg1 = (wxWindow *) 0 ;
34569 wxPoint result;
34570 void *argp1 = 0 ;
34571 int res1 = 0 ;
34572 PyObject *swig_obj[1] ;
34573
34574 if (!args) SWIG_fail;
34575 swig_obj[0] = args;
34576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34577 if (!SWIG_IsOK(res1)) {
34578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
34579 }
34580 arg1 = reinterpret_cast< wxWindow * >(argp1);
34581 {
34582 PyThreadState* __tstate = wxPyBeginAllowThreads();
34583 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
34584 wxPyEndAllowThreads(__tstate);
34585 if (PyErr_Occurred()) SWIG_fail;
34586 }
34587 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34588 return resultobj;
34589 fail:
34590 return NULL;
34591 }
34592
34593
34594 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34595 PyObject *resultobj = 0;
34596 wxWindow *arg1 = (wxWindow *) 0 ;
34597 wxRect result;
34598 void *argp1 = 0 ;
34599 int res1 = 0 ;
34600 PyObject *swig_obj[1] ;
34601
34602 if (!args) SWIG_fail;
34603 swig_obj[0] = args;
34604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34605 if (!SWIG_IsOK(res1)) {
34606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34607 }
34608 arg1 = reinterpret_cast< wxWindow * >(argp1);
34609 {
34610 PyThreadState* __tstate = wxPyBeginAllowThreads();
34611 result = ((wxWindow const *)arg1)->GetClientRect();
34612 wxPyEndAllowThreads(__tstate);
34613 if (PyErr_Occurred()) SWIG_fail;
34614 }
34615 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34616 return resultobj;
34617 fail:
34618 return NULL;
34619 }
34620
34621
34622 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34623 PyObject *resultobj = 0;
34624 wxWindow *arg1 = (wxWindow *) 0 ;
34625 wxSize result;
34626 void *argp1 = 0 ;
34627 int res1 = 0 ;
34628 PyObject *swig_obj[1] ;
34629
34630 if (!args) SWIG_fail;
34631 swig_obj[0] = args;
34632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34633 if (!SWIG_IsOK(res1)) {
34634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34635 }
34636 arg1 = reinterpret_cast< wxWindow * >(argp1);
34637 {
34638 PyThreadState* __tstate = wxPyBeginAllowThreads();
34639 result = ((wxWindow const *)arg1)->GetBestSize();
34640 wxPyEndAllowThreads(__tstate);
34641 if (PyErr_Occurred()) SWIG_fail;
34642 }
34643 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34644 return resultobj;
34645 fail:
34646 return NULL;
34647 }
34648
34649
34650 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34651 PyObject *resultobj = 0;
34652 wxWindow *arg1 = (wxWindow *) 0 ;
34653 int *arg2 = (int *) 0 ;
34654 int *arg3 = (int *) 0 ;
34655 void *argp1 = 0 ;
34656 int res1 = 0 ;
34657 int temp2 ;
34658 int res2 = SWIG_TMPOBJ ;
34659 int temp3 ;
34660 int res3 = SWIG_TMPOBJ ;
34661 PyObject *swig_obj[1] ;
34662
34663 arg2 = &temp2;
34664 arg3 = &temp3;
34665 if (!args) SWIG_fail;
34666 swig_obj[0] = args;
34667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34668 if (!SWIG_IsOK(res1)) {
34669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34670 }
34671 arg1 = reinterpret_cast< wxWindow * >(argp1);
34672 {
34673 PyThreadState* __tstate = wxPyBeginAllowThreads();
34674 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
34675 wxPyEndAllowThreads(__tstate);
34676 if (PyErr_Occurred()) SWIG_fail;
34677 }
34678 resultobj = SWIG_Py_Void();
34679 if (SWIG_IsTmpObj(res2)) {
34680 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34681 } else {
34682 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34683 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34684 }
34685 if (SWIG_IsTmpObj(res3)) {
34686 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34687 } else {
34688 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34689 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34690 }
34691 return resultobj;
34692 fail:
34693 return NULL;
34694 }
34695
34696
34697 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34698 PyObject *resultobj = 0;
34699 wxWindow *arg1 = (wxWindow *) 0 ;
34700 void *argp1 = 0 ;
34701 int res1 = 0 ;
34702 PyObject *swig_obj[1] ;
34703
34704 if (!args) SWIG_fail;
34705 swig_obj[0] = args;
34706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34707 if (!SWIG_IsOK(res1)) {
34708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34709 }
34710 arg1 = reinterpret_cast< wxWindow * >(argp1);
34711 {
34712 PyThreadState* __tstate = wxPyBeginAllowThreads();
34713 (arg1)->InvalidateBestSize();
34714 wxPyEndAllowThreads(__tstate);
34715 if (PyErr_Occurred()) SWIG_fail;
34716 }
34717 resultobj = SWIG_Py_Void();
34718 return resultobj;
34719 fail:
34720 return NULL;
34721 }
34722
34723
34724 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34725 PyObject *resultobj = 0;
34726 wxWindow *arg1 = (wxWindow *) 0 ;
34727 wxSize *arg2 = 0 ;
34728 void *argp1 = 0 ;
34729 int res1 = 0 ;
34730 wxSize temp2 ;
34731 PyObject * obj0 = 0 ;
34732 PyObject * obj1 = 0 ;
34733 char * kwnames[] = {
34734 (char *) "self",(char *) "size", NULL
34735 };
34736
34737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
34738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34739 if (!SWIG_IsOK(res1)) {
34740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34741 }
34742 arg1 = reinterpret_cast< wxWindow * >(argp1);
34743 {
34744 arg2 = &temp2;
34745 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34746 }
34747 {
34748 PyThreadState* __tstate = wxPyBeginAllowThreads();
34749 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
34750 wxPyEndAllowThreads(__tstate);
34751 if (PyErr_Occurred()) SWIG_fail;
34752 }
34753 resultobj = SWIG_Py_Void();
34754 return resultobj;
34755 fail:
34756 return NULL;
34757 }
34758
34759
34760 SWIGINTERN PyObject *_wrap_Window_GetEffectiveMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34761 PyObject *resultobj = 0;
34762 wxWindow *arg1 = (wxWindow *) 0 ;
34763 wxSize result;
34764 void *argp1 = 0 ;
34765 int res1 = 0 ;
34766 PyObject *swig_obj[1] ;
34767
34768 if (!args) SWIG_fail;
34769 swig_obj[0] = args;
34770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34771 if (!SWIG_IsOK(res1)) {
34772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEffectiveMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34773 }
34774 arg1 = reinterpret_cast< wxWindow * >(argp1);
34775 {
34776 PyThreadState* __tstate = wxPyBeginAllowThreads();
34777 result = ((wxWindow const *)arg1)->GetEffectiveMinSize();
34778 wxPyEndAllowThreads(__tstate);
34779 if (PyErr_Occurred()) SWIG_fail;
34780 }
34781 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34782 return resultobj;
34783 fail:
34784 return NULL;
34785 }
34786
34787
34788 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34789 PyObject *resultobj = 0;
34790 wxWindow *arg1 = (wxWindow *) 0 ;
34791 int arg2 = (int) wxBOTH ;
34792 void *argp1 = 0 ;
34793 int res1 = 0 ;
34794 int val2 ;
34795 int ecode2 = 0 ;
34796 PyObject * obj0 = 0 ;
34797 PyObject * obj1 = 0 ;
34798 char * kwnames[] = {
34799 (char *) "self",(char *) "direction", NULL
34800 };
34801
34802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
34803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34804 if (!SWIG_IsOK(res1)) {
34805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
34806 }
34807 arg1 = reinterpret_cast< wxWindow * >(argp1);
34808 if (obj1) {
34809 ecode2 = SWIG_AsVal_int(obj1, &val2);
34810 if (!SWIG_IsOK(ecode2)) {
34811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
34812 }
34813 arg2 = static_cast< int >(val2);
34814 }
34815 {
34816 PyThreadState* __tstate = wxPyBeginAllowThreads();
34817 (arg1)->Center(arg2);
34818 wxPyEndAllowThreads(__tstate);
34819 if (PyErr_Occurred()) SWIG_fail;
34820 }
34821 resultobj = SWIG_Py_Void();
34822 return resultobj;
34823 fail:
34824 return NULL;
34825 }
34826
34827
34828 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34829 PyObject *resultobj = 0;
34830 wxWindow *arg1 = (wxWindow *) 0 ;
34831 int arg2 = (int) wxBOTH ;
34832 void *argp1 = 0 ;
34833 int res1 = 0 ;
34834 int val2 ;
34835 int ecode2 = 0 ;
34836 PyObject * obj0 = 0 ;
34837 PyObject * obj1 = 0 ;
34838 char * kwnames[] = {
34839 (char *) "self",(char *) "dir", NULL
34840 };
34841
34842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
34843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34844 if (!SWIG_IsOK(res1)) {
34845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
34846 }
34847 arg1 = reinterpret_cast< wxWindow * >(argp1);
34848 if (obj1) {
34849 ecode2 = SWIG_AsVal_int(obj1, &val2);
34850 if (!SWIG_IsOK(ecode2)) {
34851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
34852 }
34853 arg2 = static_cast< int >(val2);
34854 }
34855 {
34856 PyThreadState* __tstate = wxPyBeginAllowThreads();
34857 (arg1)->CenterOnParent(arg2);
34858 wxPyEndAllowThreads(__tstate);
34859 if (PyErr_Occurred()) SWIG_fail;
34860 }
34861 resultobj = SWIG_Py_Void();
34862 return resultobj;
34863 fail:
34864 return NULL;
34865 }
34866
34867
34868 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34869 PyObject *resultobj = 0;
34870 wxWindow *arg1 = (wxWindow *) 0 ;
34871 void *argp1 = 0 ;
34872 int res1 = 0 ;
34873 PyObject *swig_obj[1] ;
34874
34875 if (!args) SWIG_fail;
34876 swig_obj[0] = args;
34877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34878 if (!SWIG_IsOK(res1)) {
34879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
34880 }
34881 arg1 = reinterpret_cast< wxWindow * >(argp1);
34882 {
34883 PyThreadState* __tstate = wxPyBeginAllowThreads();
34884 (arg1)->Fit();
34885 wxPyEndAllowThreads(__tstate);
34886 if (PyErr_Occurred()) SWIG_fail;
34887 }
34888 resultobj = SWIG_Py_Void();
34889 return resultobj;
34890 fail:
34891 return NULL;
34892 }
34893
34894
34895 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34896 PyObject *resultobj = 0;
34897 wxWindow *arg1 = (wxWindow *) 0 ;
34898 void *argp1 = 0 ;
34899 int res1 = 0 ;
34900 PyObject *swig_obj[1] ;
34901
34902 if (!args) SWIG_fail;
34903 swig_obj[0] = args;
34904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34905 if (!SWIG_IsOK(res1)) {
34906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
34907 }
34908 arg1 = reinterpret_cast< wxWindow * >(argp1);
34909 {
34910 PyThreadState* __tstate = wxPyBeginAllowThreads();
34911 (arg1)->FitInside();
34912 wxPyEndAllowThreads(__tstate);
34913 if (PyErr_Occurred()) SWIG_fail;
34914 }
34915 resultobj = SWIG_Py_Void();
34916 return resultobj;
34917 fail:
34918 return NULL;
34919 }
34920
34921
34922 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34923 PyObject *resultobj = 0;
34924 wxWindow *arg1 = (wxWindow *) 0 ;
34925 int arg2 ;
34926 int arg3 ;
34927 int arg4 = (int) -1 ;
34928 int arg5 = (int) -1 ;
34929 int arg6 = (int) -1 ;
34930 int arg7 = (int) -1 ;
34931 void *argp1 = 0 ;
34932 int res1 = 0 ;
34933 int val2 ;
34934 int ecode2 = 0 ;
34935 int val3 ;
34936 int ecode3 = 0 ;
34937 int val4 ;
34938 int ecode4 = 0 ;
34939 int val5 ;
34940 int ecode5 = 0 ;
34941 int val6 ;
34942 int ecode6 = 0 ;
34943 int val7 ;
34944 int ecode7 = 0 ;
34945 PyObject * obj0 = 0 ;
34946 PyObject * obj1 = 0 ;
34947 PyObject * obj2 = 0 ;
34948 PyObject * obj3 = 0 ;
34949 PyObject * obj4 = 0 ;
34950 PyObject * obj5 = 0 ;
34951 PyObject * obj6 = 0 ;
34952 char * kwnames[] = {
34953 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
34954 };
34955
34956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
34957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34958 if (!SWIG_IsOK(res1)) {
34959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34960 }
34961 arg1 = reinterpret_cast< wxWindow * >(argp1);
34962 ecode2 = SWIG_AsVal_int(obj1, &val2);
34963 if (!SWIG_IsOK(ecode2)) {
34964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
34965 }
34966 arg2 = static_cast< int >(val2);
34967 ecode3 = SWIG_AsVal_int(obj2, &val3);
34968 if (!SWIG_IsOK(ecode3)) {
34969 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
34970 }
34971 arg3 = static_cast< int >(val3);
34972 if (obj3) {
34973 ecode4 = SWIG_AsVal_int(obj3, &val4);
34974 if (!SWIG_IsOK(ecode4)) {
34975 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
34976 }
34977 arg4 = static_cast< int >(val4);
34978 }
34979 if (obj4) {
34980 ecode5 = SWIG_AsVal_int(obj4, &val5);
34981 if (!SWIG_IsOK(ecode5)) {
34982 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
34983 }
34984 arg5 = static_cast< int >(val5);
34985 }
34986 if (obj5) {
34987 ecode6 = SWIG_AsVal_int(obj5, &val6);
34988 if (!SWIG_IsOK(ecode6)) {
34989 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
34990 }
34991 arg6 = static_cast< int >(val6);
34992 }
34993 if (obj6) {
34994 ecode7 = SWIG_AsVal_int(obj6, &val7);
34995 if (!SWIG_IsOK(ecode7)) {
34996 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
34997 }
34998 arg7 = static_cast< int >(val7);
34999 }
35000 {
35001 PyThreadState* __tstate = wxPyBeginAllowThreads();
35002 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
35003 wxPyEndAllowThreads(__tstate);
35004 if (PyErr_Occurred()) SWIG_fail;
35005 }
35006 resultobj = SWIG_Py_Void();
35007 return resultobj;
35008 fail:
35009 return NULL;
35010 }
35011
35012
35013 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35014 PyObject *resultobj = 0;
35015 wxWindow *arg1 = (wxWindow *) 0 ;
35016 wxSize *arg2 = 0 ;
35017 wxSize const &arg3_defvalue = wxDefaultSize ;
35018 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
35019 wxSize const &arg4_defvalue = wxDefaultSize ;
35020 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
35021 void *argp1 = 0 ;
35022 int res1 = 0 ;
35023 wxSize temp2 ;
35024 wxSize temp3 ;
35025 wxSize temp4 ;
35026 PyObject * obj0 = 0 ;
35027 PyObject * obj1 = 0 ;
35028 PyObject * obj2 = 0 ;
35029 PyObject * obj3 = 0 ;
35030 char * kwnames[] = {
35031 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
35032 };
35033
35034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35036 if (!SWIG_IsOK(res1)) {
35037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
35038 }
35039 arg1 = reinterpret_cast< wxWindow * >(argp1);
35040 {
35041 arg2 = &temp2;
35042 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35043 }
35044 if (obj2) {
35045 {
35046 arg3 = &temp3;
35047 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
35048 }
35049 }
35050 if (obj3) {
35051 {
35052 arg4 = &temp4;
35053 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
35054 }
35055 }
35056 {
35057 PyThreadState* __tstate = wxPyBeginAllowThreads();
35058 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
35059 wxPyEndAllowThreads(__tstate);
35060 if (PyErr_Occurred()) SWIG_fail;
35061 }
35062 resultobj = SWIG_Py_Void();
35063 return resultobj;
35064 fail:
35065 return NULL;
35066 }
35067
35068
35069 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35070 PyObject *resultobj = 0;
35071 wxWindow *arg1 = (wxWindow *) 0 ;
35072 int arg2 ;
35073 int arg3 ;
35074 int arg4 = (int) -1 ;
35075 int arg5 = (int) -1 ;
35076 void *argp1 = 0 ;
35077 int res1 = 0 ;
35078 int val2 ;
35079 int ecode2 = 0 ;
35080 int val3 ;
35081 int ecode3 = 0 ;
35082 int val4 ;
35083 int ecode4 = 0 ;
35084 int val5 ;
35085 int ecode5 = 0 ;
35086 PyObject * obj0 = 0 ;
35087 PyObject * obj1 = 0 ;
35088 PyObject * obj2 = 0 ;
35089 PyObject * obj3 = 0 ;
35090 PyObject * obj4 = 0 ;
35091 char * kwnames[] = {
35092 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
35093 };
35094
35095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
35096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35097 if (!SWIG_IsOK(res1)) {
35098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
35099 }
35100 arg1 = reinterpret_cast< wxWindow * >(argp1);
35101 ecode2 = SWIG_AsVal_int(obj1, &val2);
35102 if (!SWIG_IsOK(ecode2)) {
35103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
35104 }
35105 arg2 = static_cast< int >(val2);
35106 ecode3 = SWIG_AsVal_int(obj2, &val3);
35107 if (!SWIG_IsOK(ecode3)) {
35108 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
35109 }
35110 arg3 = static_cast< int >(val3);
35111 if (obj3) {
35112 ecode4 = SWIG_AsVal_int(obj3, &val4);
35113 if (!SWIG_IsOK(ecode4)) {
35114 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
35115 }
35116 arg4 = static_cast< int >(val4);
35117 }
35118 if (obj4) {
35119 ecode5 = SWIG_AsVal_int(obj4, &val5);
35120 if (!SWIG_IsOK(ecode5)) {
35121 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
35122 }
35123 arg5 = static_cast< int >(val5);
35124 }
35125 {
35126 PyThreadState* __tstate = wxPyBeginAllowThreads();
35127 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
35128 wxPyEndAllowThreads(__tstate);
35129 if (PyErr_Occurred()) SWIG_fail;
35130 }
35131 resultobj = SWIG_Py_Void();
35132 return resultobj;
35133 fail:
35134 return NULL;
35135 }
35136
35137
35138 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35139 PyObject *resultobj = 0;
35140 wxWindow *arg1 = (wxWindow *) 0 ;
35141 wxSize *arg2 = 0 ;
35142 wxSize const &arg3_defvalue = wxDefaultSize ;
35143 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
35144 void *argp1 = 0 ;
35145 int res1 = 0 ;
35146 wxSize temp2 ;
35147 wxSize temp3 ;
35148 PyObject * obj0 = 0 ;
35149 PyObject * obj1 = 0 ;
35150 PyObject * obj2 = 0 ;
35151 char * kwnames[] = {
35152 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
35153 };
35154
35155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35157 if (!SWIG_IsOK(res1)) {
35158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
35159 }
35160 arg1 = reinterpret_cast< wxWindow * >(argp1);
35161 {
35162 arg2 = &temp2;
35163 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35164 }
35165 if (obj2) {
35166 {
35167 arg3 = &temp3;
35168 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
35169 }
35170 }
35171 {
35172 PyThreadState* __tstate = wxPyBeginAllowThreads();
35173 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
35174 wxPyEndAllowThreads(__tstate);
35175 if (PyErr_Occurred()) SWIG_fail;
35176 }
35177 resultobj = SWIG_Py_Void();
35178 return resultobj;
35179 fail:
35180 return NULL;
35181 }
35182
35183
35184 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35185 PyObject *resultobj = 0;
35186 wxWindow *arg1 = (wxWindow *) 0 ;
35187 wxSize result;
35188 void *argp1 = 0 ;
35189 int res1 = 0 ;
35190 PyObject *swig_obj[1] ;
35191
35192 if (!args) SWIG_fail;
35193 swig_obj[0] = args;
35194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35195 if (!SWIG_IsOK(res1)) {
35196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35197 }
35198 arg1 = reinterpret_cast< wxWindow * >(argp1);
35199 {
35200 PyThreadState* __tstate = wxPyBeginAllowThreads();
35201 result = ((wxWindow const *)arg1)->GetMaxSize();
35202 wxPyEndAllowThreads(__tstate);
35203 if (PyErr_Occurred()) SWIG_fail;
35204 }
35205 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35206 return resultobj;
35207 fail:
35208 return NULL;
35209 }
35210
35211
35212 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35213 PyObject *resultobj = 0;
35214 wxWindow *arg1 = (wxWindow *) 0 ;
35215 wxSize result;
35216 void *argp1 = 0 ;
35217 int res1 = 0 ;
35218 PyObject *swig_obj[1] ;
35219
35220 if (!args) SWIG_fail;
35221 swig_obj[0] = args;
35222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35223 if (!SWIG_IsOK(res1)) {
35224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35225 }
35226 arg1 = reinterpret_cast< wxWindow * >(argp1);
35227 {
35228 PyThreadState* __tstate = wxPyBeginAllowThreads();
35229 result = ((wxWindow const *)arg1)->GetMinSize();
35230 wxPyEndAllowThreads(__tstate);
35231 if (PyErr_Occurred()) SWIG_fail;
35232 }
35233 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35234 return resultobj;
35235 fail:
35236 return NULL;
35237 }
35238
35239
35240 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35241 PyObject *resultobj = 0;
35242 wxWindow *arg1 = (wxWindow *) 0 ;
35243 wxSize *arg2 = 0 ;
35244 void *argp1 = 0 ;
35245 int res1 = 0 ;
35246 wxSize temp2 ;
35247 PyObject * obj0 = 0 ;
35248 PyObject * obj1 = 0 ;
35249 char * kwnames[] = {
35250 (char *) "self",(char *) "minSize", NULL
35251 };
35252
35253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
35254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35255 if (!SWIG_IsOK(res1)) {
35256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35257 }
35258 arg1 = reinterpret_cast< wxWindow * >(argp1);
35259 {
35260 arg2 = &temp2;
35261 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35262 }
35263 {
35264 PyThreadState* __tstate = wxPyBeginAllowThreads();
35265 (arg1)->SetMinSize((wxSize const &)*arg2);
35266 wxPyEndAllowThreads(__tstate);
35267 if (PyErr_Occurred()) SWIG_fail;
35268 }
35269 resultobj = SWIG_Py_Void();
35270 return resultobj;
35271 fail:
35272 return NULL;
35273 }
35274
35275
35276 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35277 PyObject *resultobj = 0;
35278 wxWindow *arg1 = (wxWindow *) 0 ;
35279 wxSize *arg2 = 0 ;
35280 void *argp1 = 0 ;
35281 int res1 = 0 ;
35282 wxSize temp2 ;
35283 PyObject * obj0 = 0 ;
35284 PyObject * obj1 = 0 ;
35285 char * kwnames[] = {
35286 (char *) "self",(char *) "maxSize", NULL
35287 };
35288
35289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
35290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35291 if (!SWIG_IsOK(res1)) {
35292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35293 }
35294 arg1 = reinterpret_cast< wxWindow * >(argp1);
35295 {
35296 arg2 = &temp2;
35297 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35298 }
35299 {
35300 PyThreadState* __tstate = wxPyBeginAllowThreads();
35301 (arg1)->SetMaxSize((wxSize const &)*arg2);
35302 wxPyEndAllowThreads(__tstate);
35303 if (PyErr_Occurred()) SWIG_fail;
35304 }
35305 resultobj = SWIG_Py_Void();
35306 return resultobj;
35307 fail:
35308 return NULL;
35309 }
35310
35311
35312 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35313 PyObject *resultobj = 0;
35314 wxWindow *arg1 = (wxWindow *) 0 ;
35315 int result;
35316 void *argp1 = 0 ;
35317 int res1 = 0 ;
35318 PyObject *swig_obj[1] ;
35319
35320 if (!args) SWIG_fail;
35321 swig_obj[0] = args;
35322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35323 if (!SWIG_IsOK(res1)) {
35324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35325 }
35326 arg1 = reinterpret_cast< wxWindow * >(argp1);
35327 {
35328 PyThreadState* __tstate = wxPyBeginAllowThreads();
35329 result = (int)((wxWindow const *)arg1)->GetMinWidth();
35330 wxPyEndAllowThreads(__tstate);
35331 if (PyErr_Occurred()) SWIG_fail;
35332 }
35333 resultobj = SWIG_From_int(static_cast< int >(result));
35334 return resultobj;
35335 fail:
35336 return NULL;
35337 }
35338
35339
35340 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35341 PyObject *resultobj = 0;
35342 wxWindow *arg1 = (wxWindow *) 0 ;
35343 int result;
35344 void *argp1 = 0 ;
35345 int res1 = 0 ;
35346 PyObject *swig_obj[1] ;
35347
35348 if (!args) SWIG_fail;
35349 swig_obj[0] = args;
35350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35351 if (!SWIG_IsOK(res1)) {
35352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35353 }
35354 arg1 = reinterpret_cast< wxWindow * >(argp1);
35355 {
35356 PyThreadState* __tstate = wxPyBeginAllowThreads();
35357 result = (int)((wxWindow const *)arg1)->GetMinHeight();
35358 wxPyEndAllowThreads(__tstate);
35359 if (PyErr_Occurred()) SWIG_fail;
35360 }
35361 resultobj = SWIG_From_int(static_cast< int >(result));
35362 return resultobj;
35363 fail:
35364 return NULL;
35365 }
35366
35367
35368 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35369 PyObject *resultobj = 0;
35370 wxWindow *arg1 = (wxWindow *) 0 ;
35371 int result;
35372 void *argp1 = 0 ;
35373 int res1 = 0 ;
35374 PyObject *swig_obj[1] ;
35375
35376 if (!args) SWIG_fail;
35377 swig_obj[0] = args;
35378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35379 if (!SWIG_IsOK(res1)) {
35380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35381 }
35382 arg1 = reinterpret_cast< wxWindow * >(argp1);
35383 {
35384 PyThreadState* __tstate = wxPyBeginAllowThreads();
35385 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
35386 wxPyEndAllowThreads(__tstate);
35387 if (PyErr_Occurred()) SWIG_fail;
35388 }
35389 resultobj = SWIG_From_int(static_cast< int >(result));
35390 return resultobj;
35391 fail:
35392 return NULL;
35393 }
35394
35395
35396 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35397 PyObject *resultobj = 0;
35398 wxWindow *arg1 = (wxWindow *) 0 ;
35399 int result;
35400 void *argp1 = 0 ;
35401 int res1 = 0 ;
35402 PyObject *swig_obj[1] ;
35403
35404 if (!args) SWIG_fail;
35405 swig_obj[0] = args;
35406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35407 if (!SWIG_IsOK(res1)) {
35408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35409 }
35410 arg1 = reinterpret_cast< wxWindow * >(argp1);
35411 {
35412 PyThreadState* __tstate = wxPyBeginAllowThreads();
35413 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
35414 wxPyEndAllowThreads(__tstate);
35415 if (PyErr_Occurred()) SWIG_fail;
35416 }
35417 resultobj = SWIG_From_int(static_cast< int >(result));
35418 return resultobj;
35419 fail:
35420 return NULL;
35421 }
35422
35423
35424 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35425 PyObject *resultobj = 0;
35426 wxWindow *arg1 = (wxWindow *) 0 ;
35427 wxSize *arg2 = 0 ;
35428 void *argp1 = 0 ;
35429 int res1 = 0 ;
35430 wxSize temp2 ;
35431 PyObject * obj0 = 0 ;
35432 PyObject * obj1 = 0 ;
35433 char * kwnames[] = {
35434 (char *) "self",(char *) "size", NULL
35435 };
35436
35437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
35438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35439 if (!SWIG_IsOK(res1)) {
35440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35441 }
35442 arg1 = reinterpret_cast< wxWindow * >(argp1);
35443 {
35444 arg2 = &temp2;
35445 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35446 }
35447 {
35448 PyThreadState* __tstate = wxPyBeginAllowThreads();
35449 (arg1)->SetVirtualSize((wxSize const &)*arg2);
35450 wxPyEndAllowThreads(__tstate);
35451 if (PyErr_Occurred()) SWIG_fail;
35452 }
35453 resultobj = SWIG_Py_Void();
35454 return resultobj;
35455 fail:
35456 return NULL;
35457 }
35458
35459
35460 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35461 PyObject *resultobj = 0;
35462 wxWindow *arg1 = (wxWindow *) 0 ;
35463 int arg2 ;
35464 int arg3 ;
35465 void *argp1 = 0 ;
35466 int res1 = 0 ;
35467 int val2 ;
35468 int ecode2 = 0 ;
35469 int val3 ;
35470 int ecode3 = 0 ;
35471 PyObject * obj0 = 0 ;
35472 PyObject * obj1 = 0 ;
35473 PyObject * obj2 = 0 ;
35474 char * kwnames[] = {
35475 (char *) "self",(char *) "w",(char *) "h", NULL
35476 };
35477
35478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35480 if (!SWIG_IsOK(res1)) {
35481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
35482 }
35483 arg1 = reinterpret_cast< wxWindow * >(argp1);
35484 ecode2 = SWIG_AsVal_int(obj1, &val2);
35485 if (!SWIG_IsOK(ecode2)) {
35486 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
35487 }
35488 arg2 = static_cast< int >(val2);
35489 ecode3 = SWIG_AsVal_int(obj2, &val3);
35490 if (!SWIG_IsOK(ecode3)) {
35491 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
35492 }
35493 arg3 = static_cast< int >(val3);
35494 {
35495 PyThreadState* __tstate = wxPyBeginAllowThreads();
35496 (arg1)->SetVirtualSize(arg2,arg3);
35497 wxPyEndAllowThreads(__tstate);
35498 if (PyErr_Occurred()) SWIG_fail;
35499 }
35500 resultobj = SWIG_Py_Void();
35501 return resultobj;
35502 fail:
35503 return NULL;
35504 }
35505
35506
35507 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35508 PyObject *resultobj = 0;
35509 wxWindow *arg1 = (wxWindow *) 0 ;
35510 wxSize result;
35511 void *argp1 = 0 ;
35512 int res1 = 0 ;
35513 PyObject *swig_obj[1] ;
35514
35515 if (!args) SWIG_fail;
35516 swig_obj[0] = args;
35517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35518 if (!SWIG_IsOK(res1)) {
35519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35520 }
35521 arg1 = reinterpret_cast< wxWindow * >(argp1);
35522 {
35523 PyThreadState* __tstate = wxPyBeginAllowThreads();
35524 result = ((wxWindow const *)arg1)->GetVirtualSize();
35525 wxPyEndAllowThreads(__tstate);
35526 if (PyErr_Occurred()) SWIG_fail;
35527 }
35528 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35529 return resultobj;
35530 fail:
35531 return NULL;
35532 }
35533
35534
35535 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35536 PyObject *resultobj = 0;
35537 wxWindow *arg1 = (wxWindow *) 0 ;
35538 int *arg2 = (int *) 0 ;
35539 int *arg3 = (int *) 0 ;
35540 void *argp1 = 0 ;
35541 int res1 = 0 ;
35542 int temp2 ;
35543 int res2 = SWIG_TMPOBJ ;
35544 int temp3 ;
35545 int res3 = SWIG_TMPOBJ ;
35546 PyObject *swig_obj[1] ;
35547
35548 arg2 = &temp2;
35549 arg3 = &temp3;
35550 if (!args) SWIG_fail;
35551 swig_obj[0] = args;
35552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35553 if (!SWIG_IsOK(res1)) {
35554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
35555 }
35556 arg1 = reinterpret_cast< wxWindow * >(argp1);
35557 {
35558 PyThreadState* __tstate = wxPyBeginAllowThreads();
35559 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
35560 wxPyEndAllowThreads(__tstate);
35561 if (PyErr_Occurred()) SWIG_fail;
35562 }
35563 resultobj = SWIG_Py_Void();
35564 if (SWIG_IsTmpObj(res2)) {
35565 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35566 } else {
35567 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35568 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35569 }
35570 if (SWIG_IsTmpObj(res3)) {
35571 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35572 } else {
35573 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35574 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35575 }
35576 return resultobj;
35577 fail:
35578 return NULL;
35579 }
35580
35581
35582 SWIGINTERN PyObject *_wrap_Window_GetWindowBorderSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35583 PyObject *resultobj = 0;
35584 wxWindow *arg1 = (wxWindow *) 0 ;
35585 wxSize result;
35586 void *argp1 = 0 ;
35587 int res1 = 0 ;
35588 PyObject *swig_obj[1] ;
35589
35590 if (!args) SWIG_fail;
35591 swig_obj[0] = args;
35592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35593 if (!SWIG_IsOK(res1)) {
35594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowBorderSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35595 }
35596 arg1 = reinterpret_cast< wxWindow * >(argp1);
35597 {
35598 PyThreadState* __tstate = wxPyBeginAllowThreads();
35599 result = ((wxWindow const *)arg1)->GetWindowBorderSize();
35600 wxPyEndAllowThreads(__tstate);
35601 if (PyErr_Occurred()) SWIG_fail;
35602 }
35603 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35604 return resultobj;
35605 fail:
35606 return NULL;
35607 }
35608
35609
35610 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35611 PyObject *resultobj = 0;
35612 wxWindow *arg1 = (wxWindow *) 0 ;
35613 wxSize result;
35614 void *argp1 = 0 ;
35615 int res1 = 0 ;
35616 PyObject *swig_obj[1] ;
35617
35618 if (!args) SWIG_fail;
35619 swig_obj[0] = args;
35620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35621 if (!SWIG_IsOK(res1)) {
35622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35623 }
35624 arg1 = reinterpret_cast< wxWindow * >(argp1);
35625 {
35626 PyThreadState* __tstate = wxPyBeginAllowThreads();
35627 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
35628 wxPyEndAllowThreads(__tstate);
35629 if (PyErr_Occurred()) SWIG_fail;
35630 }
35631 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35632 return resultobj;
35633 fail:
35634 return NULL;
35635 }
35636
35637
35638 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35639 PyObject *resultobj = 0;
35640 wxWindow *arg1 = (wxWindow *) 0 ;
35641 bool arg2 = (bool) true ;
35642 bool result;
35643 void *argp1 = 0 ;
35644 int res1 = 0 ;
35645 bool val2 ;
35646 int ecode2 = 0 ;
35647 PyObject * obj0 = 0 ;
35648 PyObject * obj1 = 0 ;
35649 char * kwnames[] = {
35650 (char *) "self",(char *) "show", NULL
35651 };
35652
35653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
35654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35655 if (!SWIG_IsOK(res1)) {
35656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
35657 }
35658 arg1 = reinterpret_cast< wxWindow * >(argp1);
35659 if (obj1) {
35660 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35661 if (!SWIG_IsOK(ecode2)) {
35662 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
35663 }
35664 arg2 = static_cast< bool >(val2);
35665 }
35666 {
35667 PyThreadState* __tstate = wxPyBeginAllowThreads();
35668 result = (bool)(arg1)->Show(arg2);
35669 wxPyEndAllowThreads(__tstate);
35670 if (PyErr_Occurred()) SWIG_fail;
35671 }
35672 {
35673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35674 }
35675 return resultobj;
35676 fail:
35677 return NULL;
35678 }
35679
35680
35681 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35682 PyObject *resultobj = 0;
35683 wxWindow *arg1 = (wxWindow *) 0 ;
35684 bool result;
35685 void *argp1 = 0 ;
35686 int res1 = 0 ;
35687 PyObject *swig_obj[1] ;
35688
35689 if (!args) SWIG_fail;
35690 swig_obj[0] = args;
35691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35692 if (!SWIG_IsOK(res1)) {
35693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
35694 }
35695 arg1 = reinterpret_cast< wxWindow * >(argp1);
35696 {
35697 PyThreadState* __tstate = wxPyBeginAllowThreads();
35698 result = (bool)(arg1)->Hide();
35699 wxPyEndAllowThreads(__tstate);
35700 if (PyErr_Occurred()) SWIG_fail;
35701 }
35702 {
35703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35704 }
35705 return resultobj;
35706 fail:
35707 return NULL;
35708 }
35709
35710
35711 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35712 PyObject *resultobj = 0;
35713 wxWindow *arg1 = (wxWindow *) 0 ;
35714 bool arg2 = (bool) true ;
35715 bool result;
35716 void *argp1 = 0 ;
35717 int res1 = 0 ;
35718 bool val2 ;
35719 int ecode2 = 0 ;
35720 PyObject * obj0 = 0 ;
35721 PyObject * obj1 = 0 ;
35722 char * kwnames[] = {
35723 (char *) "self",(char *) "enable", NULL
35724 };
35725
35726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
35727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35728 if (!SWIG_IsOK(res1)) {
35729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
35730 }
35731 arg1 = reinterpret_cast< wxWindow * >(argp1);
35732 if (obj1) {
35733 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35734 if (!SWIG_IsOK(ecode2)) {
35735 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
35736 }
35737 arg2 = static_cast< bool >(val2);
35738 }
35739 {
35740 PyThreadState* __tstate = wxPyBeginAllowThreads();
35741 result = (bool)(arg1)->Enable(arg2);
35742 wxPyEndAllowThreads(__tstate);
35743 if (PyErr_Occurred()) SWIG_fail;
35744 }
35745 {
35746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35747 }
35748 return resultobj;
35749 fail:
35750 return NULL;
35751 }
35752
35753
35754 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35755 PyObject *resultobj = 0;
35756 wxWindow *arg1 = (wxWindow *) 0 ;
35757 bool result;
35758 void *argp1 = 0 ;
35759 int res1 = 0 ;
35760 PyObject *swig_obj[1] ;
35761
35762 if (!args) SWIG_fail;
35763 swig_obj[0] = args;
35764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35765 if (!SWIG_IsOK(res1)) {
35766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
35767 }
35768 arg1 = reinterpret_cast< wxWindow * >(argp1);
35769 {
35770 PyThreadState* __tstate = wxPyBeginAllowThreads();
35771 result = (bool)(arg1)->Disable();
35772 wxPyEndAllowThreads(__tstate);
35773 if (PyErr_Occurred()) SWIG_fail;
35774 }
35775 {
35776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35777 }
35778 return resultobj;
35779 fail:
35780 return NULL;
35781 }
35782
35783
35784 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35785 PyObject *resultobj = 0;
35786 wxWindow *arg1 = (wxWindow *) 0 ;
35787 bool result;
35788 void *argp1 = 0 ;
35789 int res1 = 0 ;
35790 PyObject *swig_obj[1] ;
35791
35792 if (!args) SWIG_fail;
35793 swig_obj[0] = args;
35794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35795 if (!SWIG_IsOK(res1)) {
35796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
35797 }
35798 arg1 = reinterpret_cast< wxWindow * >(argp1);
35799 {
35800 PyThreadState* __tstate = wxPyBeginAllowThreads();
35801 result = (bool)((wxWindow const *)arg1)->IsShown();
35802 wxPyEndAllowThreads(__tstate);
35803 if (PyErr_Occurred()) SWIG_fail;
35804 }
35805 {
35806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35807 }
35808 return resultobj;
35809 fail:
35810 return NULL;
35811 }
35812
35813
35814 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35815 PyObject *resultobj = 0;
35816 wxWindow *arg1 = (wxWindow *) 0 ;
35817 bool result;
35818 void *argp1 = 0 ;
35819 int res1 = 0 ;
35820 PyObject *swig_obj[1] ;
35821
35822 if (!args) SWIG_fail;
35823 swig_obj[0] = args;
35824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35825 if (!SWIG_IsOK(res1)) {
35826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
35827 }
35828 arg1 = reinterpret_cast< wxWindow * >(argp1);
35829 {
35830 PyThreadState* __tstate = wxPyBeginAllowThreads();
35831 result = (bool)((wxWindow const *)arg1)->IsEnabled();
35832 wxPyEndAllowThreads(__tstate);
35833 if (PyErr_Occurred()) SWIG_fail;
35834 }
35835 {
35836 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35837 }
35838 return resultobj;
35839 fail:
35840 return NULL;
35841 }
35842
35843
35844 SWIGINTERN PyObject *_wrap_Window_IsThisEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35845 PyObject *resultobj = 0;
35846 wxWindow *arg1 = (wxWindow *) 0 ;
35847 bool result;
35848 void *argp1 = 0 ;
35849 int res1 = 0 ;
35850 PyObject *swig_obj[1] ;
35851
35852 if (!args) SWIG_fail;
35853 swig_obj[0] = args;
35854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35855 if (!SWIG_IsOK(res1)) {
35856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsThisEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
35857 }
35858 arg1 = reinterpret_cast< wxWindow * >(argp1);
35859 {
35860 PyThreadState* __tstate = wxPyBeginAllowThreads();
35861 result = (bool)((wxWindow const *)arg1)->IsThisEnabled();
35862 wxPyEndAllowThreads(__tstate);
35863 if (PyErr_Occurred()) SWIG_fail;
35864 }
35865 {
35866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35867 }
35868 return resultobj;
35869 fail:
35870 return NULL;
35871 }
35872
35873
35874 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35875 PyObject *resultobj = 0;
35876 wxWindow *arg1 = (wxWindow *) 0 ;
35877 bool result;
35878 void *argp1 = 0 ;
35879 int res1 = 0 ;
35880 PyObject *swig_obj[1] ;
35881
35882 if (!args) SWIG_fail;
35883 swig_obj[0] = args;
35884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35885 if (!SWIG_IsOK(res1)) {
35886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35887 }
35888 arg1 = reinterpret_cast< wxWindow * >(argp1);
35889 {
35890 PyThreadState* __tstate = wxPyBeginAllowThreads();
35891 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
35892 wxPyEndAllowThreads(__tstate);
35893 if (PyErr_Occurred()) SWIG_fail;
35894 }
35895 {
35896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35897 }
35898 return resultobj;
35899 fail:
35900 return NULL;
35901 }
35902
35903
35904 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35905 PyObject *resultobj = 0;
35906 wxWindow *arg1 = (wxWindow *) 0 ;
35907 long arg2 ;
35908 void *argp1 = 0 ;
35909 int res1 = 0 ;
35910 long val2 ;
35911 int ecode2 = 0 ;
35912 PyObject * obj0 = 0 ;
35913 PyObject * obj1 = 0 ;
35914 char * kwnames[] = {
35915 (char *) "self",(char *) "style", NULL
35916 };
35917
35918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35920 if (!SWIG_IsOK(res1)) {
35921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
35922 }
35923 arg1 = reinterpret_cast< wxWindow * >(argp1);
35924 ecode2 = SWIG_AsVal_long(obj1, &val2);
35925 if (!SWIG_IsOK(ecode2)) {
35926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
35927 }
35928 arg2 = static_cast< long >(val2);
35929 {
35930 PyThreadState* __tstate = wxPyBeginAllowThreads();
35931 (arg1)->SetWindowStyleFlag(arg2);
35932 wxPyEndAllowThreads(__tstate);
35933 if (PyErr_Occurred()) SWIG_fail;
35934 }
35935 resultobj = SWIG_Py_Void();
35936 return resultobj;
35937 fail:
35938 return NULL;
35939 }
35940
35941
35942 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35943 PyObject *resultobj = 0;
35944 wxWindow *arg1 = (wxWindow *) 0 ;
35945 long result;
35946 void *argp1 = 0 ;
35947 int res1 = 0 ;
35948 PyObject *swig_obj[1] ;
35949
35950 if (!args) SWIG_fail;
35951 swig_obj[0] = args;
35952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35953 if (!SWIG_IsOK(res1)) {
35954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35955 }
35956 arg1 = reinterpret_cast< wxWindow * >(argp1);
35957 {
35958 PyThreadState* __tstate = wxPyBeginAllowThreads();
35959 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
35960 wxPyEndAllowThreads(__tstate);
35961 if (PyErr_Occurred()) SWIG_fail;
35962 }
35963 resultobj = SWIG_From_long(static_cast< long >(result));
35964 return resultobj;
35965 fail:
35966 return NULL;
35967 }
35968
35969
35970 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35971 PyObject *resultobj = 0;
35972 wxWindow *arg1 = (wxWindow *) 0 ;
35973 int arg2 ;
35974 bool result;
35975 void *argp1 = 0 ;
35976 int res1 = 0 ;
35977 int val2 ;
35978 int ecode2 = 0 ;
35979 PyObject * obj0 = 0 ;
35980 PyObject * obj1 = 0 ;
35981 char * kwnames[] = {
35982 (char *) "self",(char *) "flag", NULL
35983 };
35984
35985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35987 if (!SWIG_IsOK(res1)) {
35988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35989 }
35990 arg1 = reinterpret_cast< wxWindow * >(argp1);
35991 ecode2 = SWIG_AsVal_int(obj1, &val2);
35992 if (!SWIG_IsOK(ecode2)) {
35993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
35994 }
35995 arg2 = static_cast< int >(val2);
35996 {
35997 PyThreadState* __tstate = wxPyBeginAllowThreads();
35998 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
35999 wxPyEndAllowThreads(__tstate);
36000 if (PyErr_Occurred()) SWIG_fail;
36001 }
36002 {
36003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36004 }
36005 return resultobj;
36006 fail:
36007 return NULL;
36008 }
36009
36010
36011 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36012 PyObject *resultobj = 0;
36013 wxWindow *arg1 = (wxWindow *) 0 ;
36014 bool result;
36015 void *argp1 = 0 ;
36016 int res1 = 0 ;
36017 PyObject *swig_obj[1] ;
36018
36019 if (!args) SWIG_fail;
36020 swig_obj[0] = args;
36021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36022 if (!SWIG_IsOK(res1)) {
36023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
36024 }
36025 arg1 = reinterpret_cast< wxWindow * >(argp1);
36026 {
36027 PyThreadState* __tstate = wxPyBeginAllowThreads();
36028 result = (bool)((wxWindow const *)arg1)->IsRetained();
36029 wxPyEndAllowThreads(__tstate);
36030 if (PyErr_Occurred()) SWIG_fail;
36031 }
36032 {
36033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36034 }
36035 return resultobj;
36036 fail:
36037 return NULL;
36038 }
36039
36040
36041 SWIGINTERN PyObject *_wrap_Window_ToggleWindowStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36042 PyObject *resultobj = 0;
36043 wxWindow *arg1 = (wxWindow *) 0 ;
36044 int arg2 ;
36045 bool result;
36046 void *argp1 = 0 ;
36047 int res1 = 0 ;
36048 int val2 ;
36049 int ecode2 = 0 ;
36050 PyObject * obj0 = 0 ;
36051 PyObject * obj1 = 0 ;
36052 char * kwnames[] = {
36053 (char *) "self",(char *) "flag", NULL
36054 };
36055
36056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ToggleWindowStyle",kwnames,&obj0,&obj1)) SWIG_fail;
36057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36058 if (!SWIG_IsOK(res1)) {
36059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ToggleWindowStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
36060 }
36061 arg1 = reinterpret_cast< wxWindow * >(argp1);
36062 ecode2 = SWIG_AsVal_int(obj1, &val2);
36063 if (!SWIG_IsOK(ecode2)) {
36064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ToggleWindowStyle" "', expected argument " "2"" of type '" "int""'");
36065 }
36066 arg2 = static_cast< int >(val2);
36067 {
36068 PyThreadState* __tstate = wxPyBeginAllowThreads();
36069 result = (bool)(arg1)->ToggleWindowStyle(arg2);
36070 wxPyEndAllowThreads(__tstate);
36071 if (PyErr_Occurred()) SWIG_fail;
36072 }
36073 {
36074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36075 }
36076 return resultobj;
36077 fail:
36078 return NULL;
36079 }
36080
36081
36082 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36083 PyObject *resultobj = 0;
36084 wxWindow *arg1 = (wxWindow *) 0 ;
36085 long arg2 ;
36086 void *argp1 = 0 ;
36087 int res1 = 0 ;
36088 long val2 ;
36089 int ecode2 = 0 ;
36090 PyObject * obj0 = 0 ;
36091 PyObject * obj1 = 0 ;
36092 char * kwnames[] = {
36093 (char *) "self",(char *) "exStyle", NULL
36094 };
36095
36096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
36097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36098 if (!SWIG_IsOK(res1)) {
36099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
36100 }
36101 arg1 = reinterpret_cast< wxWindow * >(argp1);
36102 ecode2 = SWIG_AsVal_long(obj1, &val2);
36103 if (!SWIG_IsOK(ecode2)) {
36104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
36105 }
36106 arg2 = static_cast< long >(val2);
36107 {
36108 PyThreadState* __tstate = wxPyBeginAllowThreads();
36109 (arg1)->SetExtraStyle(arg2);
36110 wxPyEndAllowThreads(__tstate);
36111 if (PyErr_Occurred()) SWIG_fail;
36112 }
36113 resultobj = SWIG_Py_Void();
36114 return resultobj;
36115 fail:
36116 return NULL;
36117 }
36118
36119
36120 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36121 PyObject *resultobj = 0;
36122 wxWindow *arg1 = (wxWindow *) 0 ;
36123 long result;
36124 void *argp1 = 0 ;
36125 int res1 = 0 ;
36126 PyObject *swig_obj[1] ;
36127
36128 if (!args) SWIG_fail;
36129 swig_obj[0] = args;
36130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36131 if (!SWIG_IsOK(res1)) {
36132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
36133 }
36134 arg1 = reinterpret_cast< wxWindow * >(argp1);
36135 {
36136 PyThreadState* __tstate = wxPyBeginAllowThreads();
36137 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
36138 wxPyEndAllowThreads(__tstate);
36139 if (PyErr_Occurred()) SWIG_fail;
36140 }
36141 resultobj = SWIG_From_long(static_cast< long >(result));
36142 return resultobj;
36143 fail:
36144 return NULL;
36145 }
36146
36147
36148 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36149 PyObject *resultobj = 0;
36150 wxWindow *arg1 = (wxWindow *) 0 ;
36151 bool arg2 = (bool) true ;
36152 void *argp1 = 0 ;
36153 int res1 = 0 ;
36154 bool val2 ;
36155 int ecode2 = 0 ;
36156 PyObject * obj0 = 0 ;
36157 PyObject * obj1 = 0 ;
36158 char * kwnames[] = {
36159 (char *) "self",(char *) "modal", NULL
36160 };
36161
36162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
36163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36164 if (!SWIG_IsOK(res1)) {
36165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
36166 }
36167 arg1 = reinterpret_cast< wxWindow * >(argp1);
36168 if (obj1) {
36169 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36170 if (!SWIG_IsOK(ecode2)) {
36171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
36172 }
36173 arg2 = static_cast< bool >(val2);
36174 }
36175 {
36176 PyThreadState* __tstate = wxPyBeginAllowThreads();
36177 (arg1)->MakeModal(arg2);
36178 wxPyEndAllowThreads(__tstate);
36179 if (PyErr_Occurred()) SWIG_fail;
36180 }
36181 resultobj = SWIG_Py_Void();
36182 return resultobj;
36183 fail:
36184 return NULL;
36185 }
36186
36187
36188 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36189 PyObject *resultobj = 0;
36190 wxWindow *arg1 = (wxWindow *) 0 ;
36191 bool arg2 ;
36192 void *argp1 = 0 ;
36193 int res1 = 0 ;
36194 bool val2 ;
36195 int ecode2 = 0 ;
36196 PyObject * obj0 = 0 ;
36197 PyObject * obj1 = 0 ;
36198 char * kwnames[] = {
36199 (char *) "self",(char *) "enableTheme", NULL
36200 };
36201
36202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
36203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36204 if (!SWIG_IsOK(res1)) {
36205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
36206 }
36207 arg1 = reinterpret_cast< wxWindow * >(argp1);
36208 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36209 if (!SWIG_IsOK(ecode2)) {
36210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
36211 }
36212 arg2 = static_cast< bool >(val2);
36213 {
36214 PyThreadState* __tstate = wxPyBeginAllowThreads();
36215 (arg1)->SetThemeEnabled(arg2);
36216 wxPyEndAllowThreads(__tstate);
36217 if (PyErr_Occurred()) SWIG_fail;
36218 }
36219 resultobj = SWIG_Py_Void();
36220 return resultobj;
36221 fail:
36222 return NULL;
36223 }
36224
36225
36226 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36227 PyObject *resultobj = 0;
36228 wxWindow *arg1 = (wxWindow *) 0 ;
36229 bool result;
36230 void *argp1 = 0 ;
36231 int res1 = 0 ;
36232 PyObject *swig_obj[1] ;
36233
36234 if (!args) SWIG_fail;
36235 swig_obj[0] = args;
36236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36237 if (!SWIG_IsOK(res1)) {
36238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
36239 }
36240 arg1 = reinterpret_cast< wxWindow * >(argp1);
36241 {
36242 PyThreadState* __tstate = wxPyBeginAllowThreads();
36243 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
36244 wxPyEndAllowThreads(__tstate);
36245 if (PyErr_Occurred()) SWIG_fail;
36246 }
36247 {
36248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36249 }
36250 return resultobj;
36251 fail:
36252 return NULL;
36253 }
36254
36255
36256 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36257 PyObject *resultobj = 0;
36258 wxWindow *arg1 = (wxWindow *) 0 ;
36259 void *argp1 = 0 ;
36260 int res1 = 0 ;
36261 PyObject *swig_obj[1] ;
36262
36263 if (!args) SWIG_fail;
36264 swig_obj[0] = args;
36265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36266 if (!SWIG_IsOK(res1)) {
36267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
36268 }
36269 arg1 = reinterpret_cast< wxWindow * >(argp1);
36270 {
36271 PyThreadState* __tstate = wxPyBeginAllowThreads();
36272 (arg1)->SetFocus();
36273 wxPyEndAllowThreads(__tstate);
36274 if (PyErr_Occurred()) SWIG_fail;
36275 }
36276 resultobj = SWIG_Py_Void();
36277 return resultobj;
36278 fail:
36279 return NULL;
36280 }
36281
36282
36283 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36284 PyObject *resultobj = 0;
36285 wxWindow *arg1 = (wxWindow *) 0 ;
36286 void *argp1 = 0 ;
36287 int res1 = 0 ;
36288 PyObject *swig_obj[1] ;
36289
36290 if (!args) SWIG_fail;
36291 swig_obj[0] = args;
36292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36293 if (!SWIG_IsOK(res1)) {
36294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
36295 }
36296 arg1 = reinterpret_cast< wxWindow * >(argp1);
36297 {
36298 PyThreadState* __tstate = wxPyBeginAllowThreads();
36299 (arg1)->SetFocusFromKbd();
36300 wxPyEndAllowThreads(__tstate);
36301 if (PyErr_Occurred()) SWIG_fail;
36302 }
36303 resultobj = SWIG_Py_Void();
36304 return resultobj;
36305 fail:
36306 return NULL;
36307 }
36308
36309
36310 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36311 PyObject *resultobj = 0;
36312 wxWindow *result = 0 ;
36313
36314 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
36315 {
36316 if (!wxPyCheckForApp()) SWIG_fail;
36317 PyThreadState* __tstate = wxPyBeginAllowThreads();
36318 result = (wxWindow *)wxWindow::FindFocus();
36319 wxPyEndAllowThreads(__tstate);
36320 if (PyErr_Occurred()) SWIG_fail;
36321 }
36322 {
36323 resultobj = wxPyMake_wxObject(result, 0);
36324 }
36325 return resultobj;
36326 fail:
36327 return NULL;
36328 }
36329
36330
36331 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36332 PyObject *resultobj = 0;
36333 wxWindow *arg1 = (wxWindow *) 0 ;
36334 bool result;
36335 void *argp1 = 0 ;
36336 int res1 = 0 ;
36337 PyObject *swig_obj[1] ;
36338
36339 if (!args) SWIG_fail;
36340 swig_obj[0] = args;
36341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36342 if (!SWIG_IsOK(res1)) {
36343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36344 }
36345 arg1 = reinterpret_cast< wxWindow * >(argp1);
36346 {
36347 PyThreadState* __tstate = wxPyBeginAllowThreads();
36348 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
36349 wxPyEndAllowThreads(__tstate);
36350 if (PyErr_Occurred()) SWIG_fail;
36351 }
36352 {
36353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36354 }
36355 return resultobj;
36356 fail:
36357 return NULL;
36358 }
36359
36360
36361 SWIGINTERN PyObject *_wrap_Window_CanAcceptFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36362 PyObject *resultobj = 0;
36363 wxWindow *arg1 = (wxWindow *) 0 ;
36364 bool result;
36365 void *argp1 = 0 ;
36366 int res1 = 0 ;
36367 PyObject *swig_obj[1] ;
36368
36369 if (!args) SWIG_fail;
36370 swig_obj[0] = args;
36371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36372 if (!SWIG_IsOK(res1)) {
36373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanAcceptFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36374 }
36375 arg1 = reinterpret_cast< wxWindow * >(argp1);
36376 {
36377 PyThreadState* __tstate = wxPyBeginAllowThreads();
36378 result = (bool)((wxWindow const *)arg1)->CanAcceptFocus();
36379 wxPyEndAllowThreads(__tstate);
36380 if (PyErr_Occurred()) SWIG_fail;
36381 }
36382 {
36383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36384 }
36385 return resultobj;
36386 fail:
36387 return NULL;
36388 }
36389
36390
36391 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36392 PyObject *resultobj = 0;
36393 wxWindow *arg1 = (wxWindow *) 0 ;
36394 bool result;
36395 void *argp1 = 0 ;
36396 int res1 = 0 ;
36397 PyObject *swig_obj[1] ;
36398
36399 if (!args) SWIG_fail;
36400 swig_obj[0] = args;
36401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36402 if (!SWIG_IsOK(res1)) {
36403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36404 }
36405 arg1 = reinterpret_cast< wxWindow * >(argp1);
36406 {
36407 PyThreadState* __tstate = wxPyBeginAllowThreads();
36408 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
36409 wxPyEndAllowThreads(__tstate);
36410 if (PyErr_Occurred()) SWIG_fail;
36411 }
36412 {
36413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36414 }
36415 return resultobj;
36416 fail:
36417 return NULL;
36418 }
36419
36420
36421 SWIGINTERN PyObject *_wrap_Window_CanAcceptFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36422 PyObject *resultobj = 0;
36423 wxWindow *arg1 = (wxWindow *) 0 ;
36424 bool result;
36425 void *argp1 = 0 ;
36426 int res1 = 0 ;
36427 PyObject *swig_obj[1] ;
36428
36429 if (!args) SWIG_fail;
36430 swig_obj[0] = args;
36431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36432 if (!SWIG_IsOK(res1)) {
36433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanAcceptFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36434 }
36435 arg1 = reinterpret_cast< wxWindow * >(argp1);
36436 {
36437 PyThreadState* __tstate = wxPyBeginAllowThreads();
36438 result = (bool)((wxWindow const *)arg1)->CanAcceptFocusFromKeyboard();
36439 wxPyEndAllowThreads(__tstate);
36440 if (PyErr_Occurred()) SWIG_fail;
36441 }
36442 {
36443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36444 }
36445 return resultobj;
36446 fail:
36447 return NULL;
36448 }
36449
36450
36451 SWIGINTERN PyObject *_wrap_Window_NavigateIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36452 PyObject *resultobj = 0;
36453 wxWindow *arg1 = (wxWindow *) 0 ;
36454 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
36455 bool result;
36456 void *argp1 = 0 ;
36457 int res1 = 0 ;
36458 int val2 ;
36459 int ecode2 = 0 ;
36460 PyObject * obj0 = 0 ;
36461 PyObject * obj1 = 0 ;
36462 char * kwnames[] = {
36463 (char *) "self",(char *) "flags", NULL
36464 };
36465
36466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_NavigateIn",kwnames,&obj0,&obj1)) SWIG_fail;
36467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36468 if (!SWIG_IsOK(res1)) {
36469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_NavigateIn" "', expected argument " "1"" of type '" "wxWindow *""'");
36470 }
36471 arg1 = reinterpret_cast< wxWindow * >(argp1);
36472 if (obj1) {
36473 ecode2 = SWIG_AsVal_int(obj1, &val2);
36474 if (!SWIG_IsOK(ecode2)) {
36475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_NavigateIn" "', expected argument " "2"" of type '" "int""'");
36476 }
36477 arg2 = static_cast< int >(val2);
36478 }
36479 {
36480 PyThreadState* __tstate = wxPyBeginAllowThreads();
36481 result = (bool)(arg1)->NavigateIn(arg2);
36482 wxPyEndAllowThreads(__tstate);
36483 if (PyErr_Occurred()) SWIG_fail;
36484 }
36485 {
36486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36487 }
36488 return resultobj;
36489 fail:
36490 return NULL;
36491 }
36492
36493
36494 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36495 PyObject *resultobj = 0;
36496 wxWindow *arg1 = (wxWindow *) 0 ;
36497 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
36498 bool result;
36499 void *argp1 = 0 ;
36500 int res1 = 0 ;
36501 int val2 ;
36502 int ecode2 = 0 ;
36503 PyObject * obj0 = 0 ;
36504 PyObject * obj1 = 0 ;
36505 char * kwnames[] = {
36506 (char *) "self",(char *) "flags", NULL
36507 };
36508
36509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
36510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36511 if (!SWIG_IsOK(res1)) {
36512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
36513 }
36514 arg1 = reinterpret_cast< wxWindow * >(argp1);
36515 if (obj1) {
36516 ecode2 = SWIG_AsVal_int(obj1, &val2);
36517 if (!SWIG_IsOK(ecode2)) {
36518 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
36519 }
36520 arg2 = static_cast< int >(val2);
36521 }
36522 {
36523 PyThreadState* __tstate = wxPyBeginAllowThreads();
36524 result = (bool)(arg1)->Navigate(arg2);
36525 wxPyEndAllowThreads(__tstate);
36526 if (PyErr_Occurred()) SWIG_fail;
36527 }
36528 {
36529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36530 }
36531 return resultobj;
36532 fail:
36533 return NULL;
36534 }
36535
36536
36537 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36538 PyObject *resultobj = 0;
36539 wxWindow *arg1 = (wxWindow *) 0 ;
36540 wxWindow *arg2 = (wxWindow *) 0 ;
36541 void *argp1 = 0 ;
36542 int res1 = 0 ;
36543 void *argp2 = 0 ;
36544 int res2 = 0 ;
36545 PyObject * obj0 = 0 ;
36546 PyObject * obj1 = 0 ;
36547 char * kwnames[] = {
36548 (char *) "self",(char *) "win", NULL
36549 };
36550
36551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36553 if (!SWIG_IsOK(res1)) {
36554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36555 }
36556 arg1 = reinterpret_cast< wxWindow * >(argp1);
36557 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36558 if (!SWIG_IsOK(res2)) {
36559 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36560 }
36561 arg2 = reinterpret_cast< wxWindow * >(argp2);
36562 {
36563 PyThreadState* __tstate = wxPyBeginAllowThreads();
36564 (arg1)->MoveAfterInTabOrder(arg2);
36565 wxPyEndAllowThreads(__tstate);
36566 if (PyErr_Occurred()) SWIG_fail;
36567 }
36568 resultobj = SWIG_Py_Void();
36569 return resultobj;
36570 fail:
36571 return NULL;
36572 }
36573
36574
36575 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36576 PyObject *resultobj = 0;
36577 wxWindow *arg1 = (wxWindow *) 0 ;
36578 wxWindow *arg2 = (wxWindow *) 0 ;
36579 void *argp1 = 0 ;
36580 int res1 = 0 ;
36581 void *argp2 = 0 ;
36582 int res2 = 0 ;
36583 PyObject * obj0 = 0 ;
36584 PyObject * obj1 = 0 ;
36585 char * kwnames[] = {
36586 (char *) "self",(char *) "win", NULL
36587 };
36588
36589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36591 if (!SWIG_IsOK(res1)) {
36592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36593 }
36594 arg1 = reinterpret_cast< wxWindow * >(argp1);
36595 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36596 if (!SWIG_IsOK(res2)) {
36597 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36598 }
36599 arg2 = reinterpret_cast< wxWindow * >(argp2);
36600 {
36601 PyThreadState* __tstate = wxPyBeginAllowThreads();
36602 (arg1)->MoveBeforeInTabOrder(arg2);
36603 wxPyEndAllowThreads(__tstate);
36604 if (PyErr_Occurred()) SWIG_fail;
36605 }
36606 resultobj = SWIG_Py_Void();
36607 return resultobj;
36608 fail:
36609 return NULL;
36610 }
36611
36612
36613 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36614 PyObject *resultobj = 0;
36615 wxWindow *arg1 = (wxWindow *) 0 ;
36616 PyObject *result = 0 ;
36617 void *argp1 = 0 ;
36618 int res1 = 0 ;
36619 PyObject *swig_obj[1] ;
36620
36621 if (!args) SWIG_fail;
36622 swig_obj[0] = args;
36623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36624 if (!SWIG_IsOK(res1)) {
36625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
36626 }
36627 arg1 = reinterpret_cast< wxWindow * >(argp1);
36628 {
36629 PyThreadState* __tstate = wxPyBeginAllowThreads();
36630 result = (PyObject *)wxWindow_GetChildren(arg1);
36631 wxPyEndAllowThreads(__tstate);
36632 if (PyErr_Occurred()) SWIG_fail;
36633 }
36634 resultobj = result;
36635 return resultobj;
36636 fail:
36637 return NULL;
36638 }
36639
36640
36641 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36642 PyObject *resultobj = 0;
36643 wxWindow *arg1 = (wxWindow *) 0 ;
36644 wxWindow *result = 0 ;
36645 void *argp1 = 0 ;
36646 int res1 = 0 ;
36647 PyObject *swig_obj[1] ;
36648
36649 if (!args) SWIG_fail;
36650 swig_obj[0] = args;
36651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36652 if (!SWIG_IsOK(res1)) {
36653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36654 }
36655 arg1 = reinterpret_cast< wxWindow * >(argp1);
36656 {
36657 PyThreadState* __tstate = wxPyBeginAllowThreads();
36658 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
36659 wxPyEndAllowThreads(__tstate);
36660 if (PyErr_Occurred()) SWIG_fail;
36661 }
36662 {
36663 resultobj = wxPyMake_wxObject(result, 0);
36664 }
36665 return resultobj;
36666 fail:
36667 return NULL;
36668 }
36669
36670
36671 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36672 PyObject *resultobj = 0;
36673 wxWindow *arg1 = (wxWindow *) 0 ;
36674 wxWindow *result = 0 ;
36675 void *argp1 = 0 ;
36676 int res1 = 0 ;
36677 PyObject *swig_obj[1] ;
36678
36679 if (!args) SWIG_fail;
36680 swig_obj[0] = args;
36681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36682 if (!SWIG_IsOK(res1)) {
36683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36684 }
36685 arg1 = reinterpret_cast< wxWindow * >(argp1);
36686 {
36687 PyThreadState* __tstate = wxPyBeginAllowThreads();
36688 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
36689 wxPyEndAllowThreads(__tstate);
36690 if (PyErr_Occurred()) SWIG_fail;
36691 }
36692 {
36693 resultobj = wxPyMake_wxObject(result, 0);
36694 }
36695 return resultobj;
36696 fail:
36697 return NULL;
36698 }
36699
36700
36701 SWIGINTERN PyObject *_wrap_Window_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36702 PyObject *resultobj = 0;
36703 wxWindow *arg1 = (wxWindow *) 0 ;
36704 wxWindow *result = 0 ;
36705 void *argp1 = 0 ;
36706 int res1 = 0 ;
36707 PyObject *swig_obj[1] ;
36708
36709 if (!args) SWIG_fail;
36710 swig_obj[0] = args;
36711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36712 if (!SWIG_IsOK(res1)) {
36713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
36714 }
36715 arg1 = reinterpret_cast< wxWindow * >(argp1);
36716 {
36717 PyThreadState* __tstate = wxPyBeginAllowThreads();
36718 result = (wxWindow *)wxWindow_GetTopLevelParent(arg1);
36719 wxPyEndAllowThreads(__tstate);
36720 if (PyErr_Occurred()) SWIG_fail;
36721 }
36722 {
36723 resultobj = wxPyMake_wxObject(result, 0);
36724 }
36725 return resultobj;
36726 fail:
36727 return NULL;
36728 }
36729
36730
36731 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36732 PyObject *resultobj = 0;
36733 wxWindow *arg1 = (wxWindow *) 0 ;
36734 bool result;
36735 void *argp1 = 0 ;
36736 int res1 = 0 ;
36737 PyObject *swig_obj[1] ;
36738
36739 if (!args) SWIG_fail;
36740 swig_obj[0] = args;
36741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36742 if (!SWIG_IsOK(res1)) {
36743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
36744 }
36745 arg1 = reinterpret_cast< wxWindow * >(argp1);
36746 {
36747 PyThreadState* __tstate = wxPyBeginAllowThreads();
36748 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
36749 wxPyEndAllowThreads(__tstate);
36750 if (PyErr_Occurred()) SWIG_fail;
36751 }
36752 {
36753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36754 }
36755 return resultobj;
36756 fail:
36757 return NULL;
36758 }
36759
36760
36761 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36762 PyObject *resultobj = 0;
36763 wxWindow *arg1 = (wxWindow *) 0 ;
36764 wxWindow *arg2 = (wxWindow *) 0 ;
36765 bool result;
36766 void *argp1 = 0 ;
36767 int res1 = 0 ;
36768 void *argp2 = 0 ;
36769 int res2 = 0 ;
36770 PyObject * obj0 = 0 ;
36771 PyObject * obj1 = 0 ;
36772 char * kwnames[] = {
36773 (char *) "self",(char *) "newParent", NULL
36774 };
36775
36776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
36777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36778 if (!SWIG_IsOK(res1)) {
36779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
36780 }
36781 arg1 = reinterpret_cast< wxWindow * >(argp1);
36782 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36783 if (!SWIG_IsOK(res2)) {
36784 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
36785 }
36786 arg2 = reinterpret_cast< wxWindow * >(argp2);
36787 {
36788 PyThreadState* __tstate = wxPyBeginAllowThreads();
36789 result = (bool)(arg1)->Reparent(arg2);
36790 wxPyEndAllowThreads(__tstate);
36791 if (PyErr_Occurred()) SWIG_fail;
36792 }
36793 {
36794 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36795 }
36796 return resultobj;
36797 fail:
36798 return NULL;
36799 }
36800
36801
36802 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36803 PyObject *resultobj = 0;
36804 wxWindow *arg1 = (wxWindow *) 0 ;
36805 wxWindow *arg2 = (wxWindow *) 0 ;
36806 void *argp1 = 0 ;
36807 int res1 = 0 ;
36808 void *argp2 = 0 ;
36809 int res2 = 0 ;
36810 PyObject * obj0 = 0 ;
36811 PyObject * obj1 = 0 ;
36812 char * kwnames[] = {
36813 (char *) "self",(char *) "child", NULL
36814 };
36815
36816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
36817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36818 if (!SWIG_IsOK(res1)) {
36819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36820 }
36821 arg1 = reinterpret_cast< wxWindow * >(argp1);
36822 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36823 if (!SWIG_IsOK(res2)) {
36824 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36825 }
36826 arg2 = reinterpret_cast< wxWindow * >(argp2);
36827 {
36828 PyThreadState* __tstate = wxPyBeginAllowThreads();
36829 (arg1)->AddChild(arg2);
36830 wxPyEndAllowThreads(__tstate);
36831 if (PyErr_Occurred()) SWIG_fail;
36832 }
36833 resultobj = SWIG_Py_Void();
36834 return resultobj;
36835 fail:
36836 return NULL;
36837 }
36838
36839
36840 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36841 PyObject *resultobj = 0;
36842 wxWindow *arg1 = (wxWindow *) 0 ;
36843 wxWindow *arg2 = (wxWindow *) 0 ;
36844 void *argp1 = 0 ;
36845 int res1 = 0 ;
36846 void *argp2 = 0 ;
36847 int res2 = 0 ;
36848 PyObject * obj0 = 0 ;
36849 PyObject * obj1 = 0 ;
36850 char * kwnames[] = {
36851 (char *) "self",(char *) "child", NULL
36852 };
36853
36854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
36855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36856 if (!SWIG_IsOK(res1)) {
36857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36858 }
36859 arg1 = reinterpret_cast< wxWindow * >(argp1);
36860 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36861 if (!SWIG_IsOK(res2)) {
36862 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36863 }
36864 arg2 = reinterpret_cast< wxWindow * >(argp2);
36865 {
36866 PyThreadState* __tstate = wxPyBeginAllowThreads();
36867 (arg1)->RemoveChild(arg2);
36868 wxPyEndAllowThreads(__tstate);
36869 if (PyErr_Occurred()) SWIG_fail;
36870 }
36871 resultobj = SWIG_Py_Void();
36872 return resultobj;
36873 fail:
36874 return NULL;
36875 }
36876
36877
36878 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36879 PyObject *resultobj = 0;
36880 wxWindow *arg1 = (wxWindow *) 0 ;
36881 bool arg2 ;
36882 void *argp1 = 0 ;
36883 int res1 = 0 ;
36884 bool val2 ;
36885 int ecode2 = 0 ;
36886 PyObject * obj0 = 0 ;
36887 PyObject * obj1 = 0 ;
36888 char * kwnames[] = {
36889 (char *) "self",(char *) "on", NULL
36890 };
36891
36892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
36893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36894 if (!SWIG_IsOK(res1)) {
36895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
36896 }
36897 arg1 = reinterpret_cast< wxWindow * >(argp1);
36898 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36899 if (!SWIG_IsOK(ecode2)) {
36900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
36901 }
36902 arg2 = static_cast< bool >(val2);
36903 {
36904 PyThreadState* __tstate = wxPyBeginAllowThreads();
36905 wxWindow_SetDoubleBuffered(arg1,arg2);
36906 wxPyEndAllowThreads(__tstate);
36907 if (PyErr_Occurred()) SWIG_fail;
36908 }
36909 resultobj = SWIG_Py_Void();
36910 return resultobj;
36911 fail:
36912 return NULL;
36913 }
36914
36915
36916 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36917 PyObject *resultobj = 0;
36918 wxWindow *arg1 = (wxWindow *) 0 ;
36919 long arg2 ;
36920 wxWindow *result = 0 ;
36921 void *argp1 = 0 ;
36922 int res1 = 0 ;
36923 long val2 ;
36924 int ecode2 = 0 ;
36925 PyObject * obj0 = 0 ;
36926 PyObject * obj1 = 0 ;
36927 char * kwnames[] = {
36928 (char *) "self",(char *) "winid", NULL
36929 };
36930
36931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
36932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36933 if (!SWIG_IsOK(res1)) {
36934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
36935 }
36936 arg1 = reinterpret_cast< wxWindow * >(argp1);
36937 ecode2 = SWIG_AsVal_long(obj1, &val2);
36938 if (!SWIG_IsOK(ecode2)) {
36939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
36940 }
36941 arg2 = static_cast< long >(val2);
36942 {
36943 PyThreadState* __tstate = wxPyBeginAllowThreads();
36944 result = (wxWindow *)(arg1)->FindWindow(arg2);
36945 wxPyEndAllowThreads(__tstate);
36946 if (PyErr_Occurred()) SWIG_fail;
36947 }
36948 {
36949 resultobj = wxPyMake_wxObject(result, 0);
36950 }
36951 return resultobj;
36952 fail:
36953 return NULL;
36954 }
36955
36956
36957 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36958 PyObject *resultobj = 0;
36959 wxWindow *arg1 = (wxWindow *) 0 ;
36960 wxString *arg2 = 0 ;
36961 wxWindow *result = 0 ;
36962 void *argp1 = 0 ;
36963 int res1 = 0 ;
36964 bool temp2 = false ;
36965 PyObject * obj0 = 0 ;
36966 PyObject * obj1 = 0 ;
36967 char * kwnames[] = {
36968 (char *) "self",(char *) "name", NULL
36969 };
36970
36971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
36972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36973 if (!SWIG_IsOK(res1)) {
36974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
36975 }
36976 arg1 = reinterpret_cast< wxWindow * >(argp1);
36977 {
36978 arg2 = wxString_in_helper(obj1);
36979 if (arg2 == NULL) SWIG_fail;
36980 temp2 = true;
36981 }
36982 {
36983 PyThreadState* __tstate = wxPyBeginAllowThreads();
36984 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
36985 wxPyEndAllowThreads(__tstate);
36986 if (PyErr_Occurred()) SWIG_fail;
36987 }
36988 {
36989 resultobj = wxPyMake_wxObject(result, 0);
36990 }
36991 {
36992 if (temp2)
36993 delete arg2;
36994 }
36995 return resultobj;
36996 fail:
36997 {
36998 if (temp2)
36999 delete arg2;
37000 }
37001 return NULL;
37002 }
37003
37004
37005 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37006 PyObject *resultobj = 0;
37007 wxWindow *arg1 = (wxWindow *) 0 ;
37008 wxEvtHandler *result = 0 ;
37009 void *argp1 = 0 ;
37010 int res1 = 0 ;
37011 PyObject *swig_obj[1] ;
37012
37013 if (!args) SWIG_fail;
37014 swig_obj[0] = args;
37015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37016 if (!SWIG_IsOK(res1)) {
37017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
37018 }
37019 arg1 = reinterpret_cast< wxWindow * >(argp1);
37020 {
37021 PyThreadState* __tstate = wxPyBeginAllowThreads();
37022 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
37023 wxPyEndAllowThreads(__tstate);
37024 if (PyErr_Occurred()) SWIG_fail;
37025 }
37026 {
37027 resultobj = wxPyMake_wxObject(result, 0);
37028 }
37029 return resultobj;
37030 fail:
37031 return NULL;
37032 }
37033
37034
37035 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37036 PyObject *resultobj = 0;
37037 wxWindow *arg1 = (wxWindow *) 0 ;
37038 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
37039 void *argp1 = 0 ;
37040 int res1 = 0 ;
37041 void *argp2 = 0 ;
37042 int res2 = 0 ;
37043 PyObject * obj0 = 0 ;
37044 PyObject * obj1 = 0 ;
37045 char * kwnames[] = {
37046 (char *) "self",(char *) "handler", NULL
37047 };
37048
37049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37051 if (!SWIG_IsOK(res1)) {
37052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37053 }
37054 arg1 = reinterpret_cast< wxWindow * >(argp1);
37055 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
37056 if (!SWIG_IsOK(res2)) {
37057 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
37058 }
37059 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
37060 {
37061 PyThreadState* __tstate = wxPyBeginAllowThreads();
37062 (arg1)->SetEventHandler(arg2);
37063 wxPyEndAllowThreads(__tstate);
37064 if (PyErr_Occurred()) SWIG_fail;
37065 }
37066 resultobj = SWIG_Py_Void();
37067 return resultobj;
37068 fail:
37069 return NULL;
37070 }
37071
37072
37073 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37074 PyObject *resultobj = 0;
37075 wxWindow *arg1 = (wxWindow *) 0 ;
37076 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
37077 void *argp1 = 0 ;
37078 int res1 = 0 ;
37079 void *argp2 = 0 ;
37080 int res2 = 0 ;
37081 PyObject * obj0 = 0 ;
37082 PyObject * obj1 = 0 ;
37083 char * kwnames[] = {
37084 (char *) "self",(char *) "handler", NULL
37085 };
37086
37087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37089 if (!SWIG_IsOK(res1)) {
37090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37091 }
37092 arg1 = reinterpret_cast< wxWindow * >(argp1);
37093 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
37094 if (!SWIG_IsOK(res2)) {
37095 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
37096 }
37097 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
37098 {
37099 PyThreadState* __tstate = wxPyBeginAllowThreads();
37100 (arg1)->PushEventHandler(arg2);
37101 wxPyEndAllowThreads(__tstate);
37102 if (PyErr_Occurred()) SWIG_fail;
37103 }
37104 resultobj = SWIG_Py_Void();
37105 return resultobj;
37106 fail:
37107 return NULL;
37108 }
37109
37110
37111 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37112 PyObject *resultobj = 0;
37113 wxWindow *arg1 = (wxWindow *) 0 ;
37114 bool arg2 = (bool) false ;
37115 wxEvtHandler *result = 0 ;
37116 void *argp1 = 0 ;
37117 int res1 = 0 ;
37118 bool val2 ;
37119 int ecode2 = 0 ;
37120 PyObject * obj0 = 0 ;
37121 PyObject * obj1 = 0 ;
37122 char * kwnames[] = {
37123 (char *) "self",(char *) "deleteHandler", NULL
37124 };
37125
37126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37128 if (!SWIG_IsOK(res1)) {
37129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37130 }
37131 arg1 = reinterpret_cast< wxWindow * >(argp1);
37132 if (obj1) {
37133 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37134 if (!SWIG_IsOK(ecode2)) {
37135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
37136 }
37137 arg2 = static_cast< bool >(val2);
37138 }
37139 {
37140 PyThreadState* __tstate = wxPyBeginAllowThreads();
37141 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
37142 wxPyEndAllowThreads(__tstate);
37143 if (PyErr_Occurred()) SWIG_fail;
37144 }
37145 {
37146 resultobj = wxPyMake_wxObject(result, 0);
37147 }
37148 return resultobj;
37149 fail:
37150 return NULL;
37151 }
37152
37153
37154 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37155 PyObject *resultobj = 0;
37156 wxWindow *arg1 = (wxWindow *) 0 ;
37157 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
37158 bool result;
37159 void *argp1 = 0 ;
37160 int res1 = 0 ;
37161 void *argp2 = 0 ;
37162 int res2 = 0 ;
37163 PyObject * obj0 = 0 ;
37164 PyObject * obj1 = 0 ;
37165 char * kwnames[] = {
37166 (char *) "self",(char *) "handler", NULL
37167 };
37168
37169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37171 if (!SWIG_IsOK(res1)) {
37172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37173 }
37174 arg1 = reinterpret_cast< wxWindow * >(argp1);
37175 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
37176 if (!SWIG_IsOK(res2)) {
37177 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
37178 }
37179 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
37180 {
37181 PyThreadState* __tstate = wxPyBeginAllowThreads();
37182 result = (bool)(arg1)->RemoveEventHandler(arg2);
37183 wxPyEndAllowThreads(__tstate);
37184 if (PyErr_Occurred()) SWIG_fail;
37185 }
37186 {
37187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37188 }
37189 return resultobj;
37190 fail:
37191 return NULL;
37192 }
37193
37194
37195 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37196 PyObject *resultobj = 0;
37197 wxWindow *arg1 = (wxWindow *) 0 ;
37198 wxValidator *arg2 = 0 ;
37199 void *argp1 = 0 ;
37200 int res1 = 0 ;
37201 void *argp2 = 0 ;
37202 int res2 = 0 ;
37203 PyObject * obj0 = 0 ;
37204 PyObject * obj1 = 0 ;
37205 char * kwnames[] = {
37206 (char *) "self",(char *) "validator", NULL
37207 };
37208
37209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
37210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37211 if (!SWIG_IsOK(res1)) {
37212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
37213 }
37214 arg1 = reinterpret_cast< wxWindow * >(argp1);
37215 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
37216 if (!SWIG_IsOK(res2)) {
37217 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
37218 }
37219 if (!argp2) {
37220 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
37221 }
37222 arg2 = reinterpret_cast< wxValidator * >(argp2);
37223 {
37224 PyThreadState* __tstate = wxPyBeginAllowThreads();
37225 (arg1)->SetValidator((wxValidator const &)*arg2);
37226 wxPyEndAllowThreads(__tstate);
37227 if (PyErr_Occurred()) SWIG_fail;
37228 }
37229 resultobj = SWIG_Py_Void();
37230 return resultobj;
37231 fail:
37232 return NULL;
37233 }
37234
37235
37236 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37237 PyObject *resultobj = 0;
37238 wxWindow *arg1 = (wxWindow *) 0 ;
37239 wxValidator *result = 0 ;
37240 void *argp1 = 0 ;
37241 int res1 = 0 ;
37242 PyObject *swig_obj[1] ;
37243
37244 if (!args) SWIG_fail;
37245 swig_obj[0] = args;
37246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37247 if (!SWIG_IsOK(res1)) {
37248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
37249 }
37250 arg1 = reinterpret_cast< wxWindow * >(argp1);
37251 {
37252 PyThreadState* __tstate = wxPyBeginAllowThreads();
37253 result = (wxValidator *)(arg1)->GetValidator();
37254 wxPyEndAllowThreads(__tstate);
37255 if (PyErr_Occurred()) SWIG_fail;
37256 }
37257 {
37258 resultobj = wxPyMake_wxObject(result, (bool)0);
37259 }
37260 return resultobj;
37261 fail:
37262 return NULL;
37263 }
37264
37265
37266 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37267 PyObject *resultobj = 0;
37268 wxWindow *arg1 = (wxWindow *) 0 ;
37269 bool result;
37270 void *argp1 = 0 ;
37271 int res1 = 0 ;
37272 PyObject *swig_obj[1] ;
37273
37274 if (!args) SWIG_fail;
37275 swig_obj[0] = args;
37276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37277 if (!SWIG_IsOK(res1)) {
37278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
37279 }
37280 arg1 = reinterpret_cast< wxWindow * >(argp1);
37281 {
37282 PyThreadState* __tstate = wxPyBeginAllowThreads();
37283 result = (bool)(arg1)->Validate();
37284 wxPyEndAllowThreads(__tstate);
37285 if (PyErr_Occurred()) SWIG_fail;
37286 }
37287 {
37288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37289 }
37290 return resultobj;
37291 fail:
37292 return NULL;
37293 }
37294
37295
37296 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37297 PyObject *resultobj = 0;
37298 wxWindow *arg1 = (wxWindow *) 0 ;
37299 bool result;
37300 void *argp1 = 0 ;
37301 int res1 = 0 ;
37302 PyObject *swig_obj[1] ;
37303
37304 if (!args) SWIG_fail;
37305 swig_obj[0] = args;
37306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37307 if (!SWIG_IsOK(res1)) {
37308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37309 }
37310 arg1 = reinterpret_cast< wxWindow * >(argp1);
37311 {
37312 PyThreadState* __tstate = wxPyBeginAllowThreads();
37313 result = (bool)(arg1)->TransferDataToWindow();
37314 wxPyEndAllowThreads(__tstate);
37315 if (PyErr_Occurred()) SWIG_fail;
37316 }
37317 {
37318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37319 }
37320 return resultobj;
37321 fail:
37322 return NULL;
37323 }
37324
37325
37326 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37327 PyObject *resultobj = 0;
37328 wxWindow *arg1 = (wxWindow *) 0 ;
37329 bool result;
37330 void *argp1 = 0 ;
37331 int res1 = 0 ;
37332 PyObject *swig_obj[1] ;
37333
37334 if (!args) SWIG_fail;
37335 swig_obj[0] = args;
37336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37337 if (!SWIG_IsOK(res1)) {
37338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37339 }
37340 arg1 = reinterpret_cast< wxWindow * >(argp1);
37341 {
37342 PyThreadState* __tstate = wxPyBeginAllowThreads();
37343 result = (bool)(arg1)->TransferDataFromWindow();
37344 wxPyEndAllowThreads(__tstate);
37345 if (PyErr_Occurred()) SWIG_fail;
37346 }
37347 {
37348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37349 }
37350 return resultobj;
37351 fail:
37352 return NULL;
37353 }
37354
37355
37356 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37357 PyObject *resultobj = 0;
37358 wxWindow *arg1 = (wxWindow *) 0 ;
37359 void *argp1 = 0 ;
37360 int res1 = 0 ;
37361 PyObject *swig_obj[1] ;
37362
37363 if (!args) SWIG_fail;
37364 swig_obj[0] = args;
37365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37366 if (!SWIG_IsOK(res1)) {
37367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37368 }
37369 arg1 = reinterpret_cast< wxWindow * >(argp1);
37370 {
37371 PyThreadState* __tstate = wxPyBeginAllowThreads();
37372 (arg1)->InitDialog();
37373 wxPyEndAllowThreads(__tstate);
37374 if (PyErr_Occurred()) SWIG_fail;
37375 }
37376 resultobj = SWIG_Py_Void();
37377 return resultobj;
37378 fail:
37379 return NULL;
37380 }
37381
37382
37383 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37384 PyObject *resultobj = 0;
37385 wxWindow *arg1 = (wxWindow *) 0 ;
37386 wxAcceleratorTable *arg2 = 0 ;
37387 void *argp1 = 0 ;
37388 int res1 = 0 ;
37389 void *argp2 = 0 ;
37390 int res2 = 0 ;
37391 PyObject * obj0 = 0 ;
37392 PyObject * obj1 = 0 ;
37393 char * kwnames[] = {
37394 (char *) "self",(char *) "accel", NULL
37395 };
37396
37397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
37398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37399 if (!SWIG_IsOK(res1)) {
37400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37401 }
37402 arg1 = reinterpret_cast< wxWindow * >(argp1);
37403 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
37404 if (!SWIG_IsOK(res2)) {
37405 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37406 }
37407 if (!argp2) {
37408 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37409 }
37410 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
37411 {
37412 PyThreadState* __tstate = wxPyBeginAllowThreads();
37413 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
37414 wxPyEndAllowThreads(__tstate);
37415 if (PyErr_Occurred()) SWIG_fail;
37416 }
37417 resultobj = SWIG_Py_Void();
37418 return resultobj;
37419 fail:
37420 return NULL;
37421 }
37422
37423
37424 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37425 PyObject *resultobj = 0;
37426 wxWindow *arg1 = (wxWindow *) 0 ;
37427 wxAcceleratorTable *result = 0 ;
37428 void *argp1 = 0 ;
37429 int res1 = 0 ;
37430 PyObject *swig_obj[1] ;
37431
37432 if (!args) SWIG_fail;
37433 swig_obj[0] = args;
37434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37435 if (!SWIG_IsOK(res1)) {
37436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37437 }
37438 arg1 = reinterpret_cast< wxWindow * >(argp1);
37439 {
37440 PyThreadState* __tstate = wxPyBeginAllowThreads();
37441 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
37442 wxPyEndAllowThreads(__tstate);
37443 if (PyErr_Occurred()) SWIG_fail;
37444 }
37445 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
37446 return resultobj;
37447 fail:
37448 return NULL;
37449 }
37450
37451
37452 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37453 PyObject *resultobj = 0;
37454 wxWindow *arg1 = (wxWindow *) 0 ;
37455 int arg2 ;
37456 int arg3 ;
37457 int arg4 ;
37458 bool result;
37459 void *argp1 = 0 ;
37460 int res1 = 0 ;
37461 int val2 ;
37462 int ecode2 = 0 ;
37463 int val3 ;
37464 int ecode3 = 0 ;
37465 int val4 ;
37466 int ecode4 = 0 ;
37467 PyObject * obj0 = 0 ;
37468 PyObject * obj1 = 0 ;
37469 PyObject * obj2 = 0 ;
37470 PyObject * obj3 = 0 ;
37471 char * kwnames[] = {
37472 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
37473 };
37474
37475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37477 if (!SWIG_IsOK(res1)) {
37478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37479 }
37480 arg1 = reinterpret_cast< wxWindow * >(argp1);
37481 ecode2 = SWIG_AsVal_int(obj1, &val2);
37482 if (!SWIG_IsOK(ecode2)) {
37483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
37484 }
37485 arg2 = static_cast< int >(val2);
37486 ecode3 = SWIG_AsVal_int(obj2, &val3);
37487 if (!SWIG_IsOK(ecode3)) {
37488 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
37489 }
37490 arg3 = static_cast< int >(val3);
37491 ecode4 = SWIG_AsVal_int(obj3, &val4);
37492 if (!SWIG_IsOK(ecode4)) {
37493 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
37494 }
37495 arg4 = static_cast< int >(val4);
37496 {
37497 PyThreadState* __tstate = wxPyBeginAllowThreads();
37498 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
37499 wxPyEndAllowThreads(__tstate);
37500 if (PyErr_Occurred()) SWIG_fail;
37501 }
37502 {
37503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37504 }
37505 return resultobj;
37506 fail:
37507 return NULL;
37508 }
37509
37510
37511 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37512 PyObject *resultobj = 0;
37513 wxWindow *arg1 = (wxWindow *) 0 ;
37514 int arg2 ;
37515 bool result;
37516 void *argp1 = 0 ;
37517 int res1 = 0 ;
37518 int val2 ;
37519 int ecode2 = 0 ;
37520 PyObject * obj0 = 0 ;
37521 PyObject * obj1 = 0 ;
37522 char * kwnames[] = {
37523 (char *) "self",(char *) "hotkeyId", NULL
37524 };
37525
37526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
37527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37528 if (!SWIG_IsOK(res1)) {
37529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37530 }
37531 arg1 = reinterpret_cast< wxWindow * >(argp1);
37532 ecode2 = SWIG_AsVal_int(obj1, &val2);
37533 if (!SWIG_IsOK(ecode2)) {
37534 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
37535 }
37536 arg2 = static_cast< int >(val2);
37537 {
37538 PyThreadState* __tstate = wxPyBeginAllowThreads();
37539 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
37540 wxPyEndAllowThreads(__tstate);
37541 if (PyErr_Occurred()) SWIG_fail;
37542 }
37543 {
37544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37545 }
37546 return resultobj;
37547 fail:
37548 return NULL;
37549 }
37550
37551
37552 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37553 PyObject *resultobj = 0;
37554 wxWindow *arg1 = (wxWindow *) 0 ;
37555 wxPoint *arg2 = 0 ;
37556 wxPoint result;
37557 void *argp1 = 0 ;
37558 int res1 = 0 ;
37559 wxPoint temp2 ;
37560 PyObject * obj0 = 0 ;
37561 PyObject * obj1 = 0 ;
37562 char * kwnames[] = {
37563 (char *) "self",(char *) "pt", NULL
37564 };
37565
37566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37568 if (!SWIG_IsOK(res1)) {
37569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37570 }
37571 arg1 = reinterpret_cast< wxWindow * >(argp1);
37572 {
37573 arg2 = &temp2;
37574 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37575 }
37576 {
37577 PyThreadState* __tstate = wxPyBeginAllowThreads();
37578 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37579 wxPyEndAllowThreads(__tstate);
37580 if (PyErr_Occurred()) SWIG_fail;
37581 }
37582 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37583 return resultobj;
37584 fail:
37585 return NULL;
37586 }
37587
37588
37589 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37590 PyObject *resultobj = 0;
37591 wxWindow *arg1 = (wxWindow *) 0 ;
37592 wxSize *arg2 = 0 ;
37593 wxSize result;
37594 void *argp1 = 0 ;
37595 int res1 = 0 ;
37596 wxSize temp2 ;
37597 PyObject * obj0 = 0 ;
37598 PyObject * obj1 = 0 ;
37599 char * kwnames[] = {
37600 (char *) "self",(char *) "sz", NULL
37601 };
37602
37603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37605 if (!SWIG_IsOK(res1)) {
37606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37607 }
37608 arg1 = reinterpret_cast< wxWindow * >(argp1);
37609 {
37610 arg2 = &temp2;
37611 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37612 }
37613 {
37614 PyThreadState* __tstate = wxPyBeginAllowThreads();
37615 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37616 wxPyEndAllowThreads(__tstate);
37617 if (PyErr_Occurred()) SWIG_fail;
37618 }
37619 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37620 return resultobj;
37621 fail:
37622 return NULL;
37623 }
37624
37625
37626 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37627 PyObject *resultobj = 0;
37628 wxWindow *arg1 = (wxWindow *) 0 ;
37629 wxPoint *arg2 = 0 ;
37630 wxPoint result;
37631 void *argp1 = 0 ;
37632 int res1 = 0 ;
37633 wxPoint temp2 ;
37634 PyObject * obj0 = 0 ;
37635 PyObject * obj1 = 0 ;
37636 char * kwnames[] = {
37637 (char *) "self",(char *) "pt", NULL
37638 };
37639
37640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
37641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37642 if (!SWIG_IsOK(res1)) {
37643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
37644 }
37645 arg1 = reinterpret_cast< wxWindow * >(argp1);
37646 {
37647 arg2 = &temp2;
37648 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37649 }
37650 {
37651 PyThreadState* __tstate = wxPyBeginAllowThreads();
37652 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37653 wxPyEndAllowThreads(__tstate);
37654 if (PyErr_Occurred()) SWIG_fail;
37655 }
37656 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37657 return resultobj;
37658 fail:
37659 return NULL;
37660 }
37661
37662
37663 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37664 PyObject *resultobj = 0;
37665 wxWindow *arg1 = (wxWindow *) 0 ;
37666 wxSize *arg2 = 0 ;
37667 wxSize result;
37668 void *argp1 = 0 ;
37669 int res1 = 0 ;
37670 wxSize temp2 ;
37671 PyObject * obj0 = 0 ;
37672 PyObject * obj1 = 0 ;
37673 char * kwnames[] = {
37674 (char *) "self",(char *) "sz", NULL
37675 };
37676
37677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
37678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37679 if (!SWIG_IsOK(res1)) {
37680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
37681 }
37682 arg1 = reinterpret_cast< wxWindow * >(argp1);
37683 {
37684 arg2 = &temp2;
37685 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37686 }
37687 {
37688 PyThreadState* __tstate = wxPyBeginAllowThreads();
37689 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37690 wxPyEndAllowThreads(__tstate);
37691 if (PyErr_Occurred()) SWIG_fail;
37692 }
37693 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37694 return resultobj;
37695 fail:
37696 return NULL;
37697 }
37698
37699
37700 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37701 PyObject *resultobj = 0;
37702 wxWindow *arg1 = (wxWindow *) 0 ;
37703 wxPoint *arg2 = 0 ;
37704 wxPoint result;
37705 void *argp1 = 0 ;
37706 int res1 = 0 ;
37707 wxPoint temp2 ;
37708 PyObject * obj0 = 0 ;
37709 PyObject * obj1 = 0 ;
37710 char * kwnames[] = {
37711 (char *) "self",(char *) "pt", NULL
37712 };
37713
37714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37716 if (!SWIG_IsOK(res1)) {
37717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37718 }
37719 arg1 = reinterpret_cast< wxWindow * >(argp1);
37720 {
37721 arg2 = &temp2;
37722 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37723 }
37724 {
37725 PyThreadState* __tstate = wxPyBeginAllowThreads();
37726 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
37727 wxPyEndAllowThreads(__tstate);
37728 if (PyErr_Occurred()) SWIG_fail;
37729 }
37730 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37731 return resultobj;
37732 fail:
37733 return NULL;
37734 }
37735
37736
37737 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37738 PyObject *resultobj = 0;
37739 wxWindow *arg1 = (wxWindow *) 0 ;
37740 wxSize *arg2 = 0 ;
37741 wxSize result;
37742 void *argp1 = 0 ;
37743 int res1 = 0 ;
37744 wxSize temp2 ;
37745 PyObject * obj0 = 0 ;
37746 PyObject * obj1 = 0 ;
37747 char * kwnames[] = {
37748 (char *) "self",(char *) "sz", NULL
37749 };
37750
37751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37753 if (!SWIG_IsOK(res1)) {
37754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37755 }
37756 arg1 = reinterpret_cast< wxWindow * >(argp1);
37757 {
37758 arg2 = &temp2;
37759 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37760 }
37761 {
37762 PyThreadState* __tstate = wxPyBeginAllowThreads();
37763 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
37764 wxPyEndAllowThreads(__tstate);
37765 if (PyErr_Occurred()) SWIG_fail;
37766 }
37767 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37768 return resultobj;
37769 fail:
37770 return NULL;
37771 }
37772
37773
37774 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37775 PyObject *resultobj = 0;
37776 wxWindow *arg1 = (wxWindow *) 0 ;
37777 int arg2 ;
37778 int arg3 ;
37779 void *argp1 = 0 ;
37780 int res1 = 0 ;
37781 int val2 ;
37782 int ecode2 = 0 ;
37783 int val3 ;
37784 int ecode3 = 0 ;
37785 PyObject * obj0 = 0 ;
37786 PyObject * obj1 = 0 ;
37787 PyObject * obj2 = 0 ;
37788 char * kwnames[] = {
37789 (char *) "self",(char *) "x",(char *) "y", NULL
37790 };
37791
37792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37794 if (!SWIG_IsOK(res1)) {
37795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
37796 }
37797 arg1 = reinterpret_cast< wxWindow * >(argp1);
37798 ecode2 = SWIG_AsVal_int(obj1, &val2);
37799 if (!SWIG_IsOK(ecode2)) {
37800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
37801 }
37802 arg2 = static_cast< int >(val2);
37803 ecode3 = SWIG_AsVal_int(obj2, &val3);
37804 if (!SWIG_IsOK(ecode3)) {
37805 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
37806 }
37807 arg3 = static_cast< int >(val3);
37808 {
37809 PyThreadState* __tstate = wxPyBeginAllowThreads();
37810 (arg1)->WarpPointer(arg2,arg3);
37811 wxPyEndAllowThreads(__tstate);
37812 if (PyErr_Occurred()) SWIG_fail;
37813 }
37814 resultobj = SWIG_Py_Void();
37815 return resultobj;
37816 fail:
37817 return NULL;
37818 }
37819
37820
37821 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37822 PyObject *resultobj = 0;
37823 wxWindow *arg1 = (wxWindow *) 0 ;
37824 void *argp1 = 0 ;
37825 int res1 = 0 ;
37826 PyObject *swig_obj[1] ;
37827
37828 if (!args) SWIG_fail;
37829 swig_obj[0] = args;
37830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37831 if (!SWIG_IsOK(res1)) {
37832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37833 }
37834 arg1 = reinterpret_cast< wxWindow * >(argp1);
37835 {
37836 PyThreadState* __tstate = wxPyBeginAllowThreads();
37837 (arg1)->CaptureMouse();
37838 wxPyEndAllowThreads(__tstate);
37839 if (PyErr_Occurred()) SWIG_fail;
37840 }
37841 resultobj = SWIG_Py_Void();
37842 return resultobj;
37843 fail:
37844 return NULL;
37845 }
37846
37847
37848 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37849 PyObject *resultobj = 0;
37850 wxWindow *arg1 = (wxWindow *) 0 ;
37851 void *argp1 = 0 ;
37852 int res1 = 0 ;
37853 PyObject *swig_obj[1] ;
37854
37855 if (!args) SWIG_fail;
37856 swig_obj[0] = args;
37857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37858 if (!SWIG_IsOK(res1)) {
37859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37860 }
37861 arg1 = reinterpret_cast< wxWindow * >(argp1);
37862 {
37863 PyThreadState* __tstate = wxPyBeginAllowThreads();
37864 (arg1)->ReleaseMouse();
37865 wxPyEndAllowThreads(__tstate);
37866 if (PyErr_Occurred()) SWIG_fail;
37867 }
37868 resultobj = SWIG_Py_Void();
37869 return resultobj;
37870 fail:
37871 return NULL;
37872 }
37873
37874
37875 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37876 PyObject *resultobj = 0;
37877 wxWindow *result = 0 ;
37878
37879 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
37880 {
37881 if (!wxPyCheckForApp()) SWIG_fail;
37882 PyThreadState* __tstate = wxPyBeginAllowThreads();
37883 result = (wxWindow *)wxWindow::GetCapture();
37884 wxPyEndAllowThreads(__tstate);
37885 if (PyErr_Occurred()) SWIG_fail;
37886 }
37887 {
37888 resultobj = wxPyMake_wxObject(result, 0);
37889 }
37890 return resultobj;
37891 fail:
37892 return NULL;
37893 }
37894
37895
37896 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37897 PyObject *resultobj = 0;
37898 wxWindow *arg1 = (wxWindow *) 0 ;
37899 bool result;
37900 void *argp1 = 0 ;
37901 int res1 = 0 ;
37902 PyObject *swig_obj[1] ;
37903
37904 if (!args) SWIG_fail;
37905 swig_obj[0] = args;
37906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37907 if (!SWIG_IsOK(res1)) {
37908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
37909 }
37910 arg1 = reinterpret_cast< wxWindow * >(argp1);
37911 {
37912 PyThreadState* __tstate = wxPyBeginAllowThreads();
37913 result = (bool)((wxWindow const *)arg1)->HasCapture();
37914 wxPyEndAllowThreads(__tstate);
37915 if (PyErr_Occurred()) SWIG_fail;
37916 }
37917 {
37918 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37919 }
37920 return resultobj;
37921 fail:
37922 return NULL;
37923 }
37924
37925
37926 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37927 PyObject *resultobj = 0;
37928 wxWindow *arg1 = (wxWindow *) 0 ;
37929 bool arg2 = (bool) true ;
37930 wxRect *arg3 = (wxRect *) NULL ;
37931 void *argp1 = 0 ;
37932 int res1 = 0 ;
37933 bool val2 ;
37934 int ecode2 = 0 ;
37935 void *argp3 = 0 ;
37936 int res3 = 0 ;
37937 PyObject * obj0 = 0 ;
37938 PyObject * obj1 = 0 ;
37939 PyObject * obj2 = 0 ;
37940 char * kwnames[] = {
37941 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
37942 };
37943
37944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37946 if (!SWIG_IsOK(res1)) {
37947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
37948 }
37949 arg1 = reinterpret_cast< wxWindow * >(argp1);
37950 if (obj1) {
37951 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37952 if (!SWIG_IsOK(ecode2)) {
37953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
37954 }
37955 arg2 = static_cast< bool >(val2);
37956 }
37957 if (obj2) {
37958 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
37959 if (!SWIG_IsOK(res3)) {
37960 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
37961 }
37962 arg3 = reinterpret_cast< wxRect * >(argp3);
37963 }
37964 {
37965 PyThreadState* __tstate = wxPyBeginAllowThreads();
37966 (arg1)->Refresh(arg2,(wxRect const *)arg3);
37967 wxPyEndAllowThreads(__tstate);
37968 if (PyErr_Occurred()) SWIG_fail;
37969 }
37970 resultobj = SWIG_Py_Void();
37971 return resultobj;
37972 fail:
37973 return NULL;
37974 }
37975
37976
37977 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37978 PyObject *resultobj = 0;
37979 wxWindow *arg1 = (wxWindow *) 0 ;
37980 wxRect *arg2 = 0 ;
37981 bool arg3 = (bool) true ;
37982 void *argp1 = 0 ;
37983 int res1 = 0 ;
37984 wxRect temp2 ;
37985 bool val3 ;
37986 int ecode3 = 0 ;
37987 PyObject * obj0 = 0 ;
37988 PyObject * obj1 = 0 ;
37989 PyObject * obj2 = 0 ;
37990 char * kwnames[] = {
37991 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
37992 };
37993
37994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37996 if (!SWIG_IsOK(res1)) {
37997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
37998 }
37999 arg1 = reinterpret_cast< wxWindow * >(argp1);
38000 {
38001 arg2 = &temp2;
38002 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38003 }
38004 if (obj2) {
38005 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38006 if (!SWIG_IsOK(ecode3)) {
38007 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
38008 }
38009 arg3 = static_cast< bool >(val3);
38010 }
38011 {
38012 PyThreadState* __tstate = wxPyBeginAllowThreads();
38013 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
38014 wxPyEndAllowThreads(__tstate);
38015 if (PyErr_Occurred()) SWIG_fail;
38016 }
38017 resultobj = SWIG_Py_Void();
38018 return resultobj;
38019 fail:
38020 return NULL;
38021 }
38022
38023
38024 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38025 PyObject *resultobj = 0;
38026 wxWindow *arg1 = (wxWindow *) 0 ;
38027 void *argp1 = 0 ;
38028 int res1 = 0 ;
38029 PyObject *swig_obj[1] ;
38030
38031 if (!args) SWIG_fail;
38032 swig_obj[0] = args;
38033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38034 if (!SWIG_IsOK(res1)) {
38035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
38036 }
38037 arg1 = reinterpret_cast< wxWindow * >(argp1);
38038 {
38039 PyThreadState* __tstate = wxPyBeginAllowThreads();
38040 (arg1)->Update();
38041 wxPyEndAllowThreads(__tstate);
38042 if (PyErr_Occurred()) SWIG_fail;
38043 }
38044 resultobj = SWIG_Py_Void();
38045 return resultobj;
38046 fail:
38047 return NULL;
38048 }
38049
38050
38051 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38052 PyObject *resultobj = 0;
38053 wxWindow *arg1 = (wxWindow *) 0 ;
38054 void *argp1 = 0 ;
38055 int res1 = 0 ;
38056 PyObject *swig_obj[1] ;
38057
38058 if (!args) SWIG_fail;
38059 swig_obj[0] = args;
38060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38061 if (!SWIG_IsOK(res1)) {
38062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
38063 }
38064 arg1 = reinterpret_cast< wxWindow * >(argp1);
38065 {
38066 PyThreadState* __tstate = wxPyBeginAllowThreads();
38067 (arg1)->ClearBackground();
38068 wxPyEndAllowThreads(__tstate);
38069 if (PyErr_Occurred()) SWIG_fail;
38070 }
38071 resultobj = SWIG_Py_Void();
38072 return resultobj;
38073 fail:
38074 return NULL;
38075 }
38076
38077
38078 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38079 PyObject *resultobj = 0;
38080 wxWindow *arg1 = (wxWindow *) 0 ;
38081 void *argp1 = 0 ;
38082 int res1 = 0 ;
38083 PyObject *swig_obj[1] ;
38084
38085 if (!args) SWIG_fail;
38086 swig_obj[0] = args;
38087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38088 if (!SWIG_IsOK(res1)) {
38089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
38090 }
38091 arg1 = reinterpret_cast< wxWindow * >(argp1);
38092 {
38093 PyThreadState* __tstate = wxPyBeginAllowThreads();
38094 (arg1)->Freeze();
38095 wxPyEndAllowThreads(__tstate);
38096 if (PyErr_Occurred()) SWIG_fail;
38097 }
38098 resultobj = SWIG_Py_Void();
38099 return resultobj;
38100 fail:
38101 return NULL;
38102 }
38103
38104
38105 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38106 PyObject *resultobj = 0;
38107 wxWindow *arg1 = (wxWindow *) 0 ;
38108 bool result;
38109 void *argp1 = 0 ;
38110 int res1 = 0 ;
38111 PyObject *swig_obj[1] ;
38112
38113 if (!args) SWIG_fail;
38114 swig_obj[0] = args;
38115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38116 if (!SWIG_IsOK(res1)) {
38117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
38118 }
38119 arg1 = reinterpret_cast< wxWindow * >(argp1);
38120 {
38121 PyThreadState* __tstate = wxPyBeginAllowThreads();
38122 result = (bool)((wxWindow const *)arg1)->IsFrozen();
38123 wxPyEndAllowThreads(__tstate);
38124 if (PyErr_Occurred()) SWIG_fail;
38125 }
38126 {
38127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38128 }
38129 return resultobj;
38130 fail:
38131 return NULL;
38132 }
38133
38134
38135 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38136 PyObject *resultobj = 0;
38137 wxWindow *arg1 = (wxWindow *) 0 ;
38138 void *argp1 = 0 ;
38139 int res1 = 0 ;
38140 PyObject *swig_obj[1] ;
38141
38142 if (!args) SWIG_fail;
38143 swig_obj[0] = args;
38144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38145 if (!SWIG_IsOK(res1)) {
38146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
38147 }
38148 arg1 = reinterpret_cast< wxWindow * >(argp1);
38149 {
38150 PyThreadState* __tstate = wxPyBeginAllowThreads();
38151 (arg1)->Thaw();
38152 wxPyEndAllowThreads(__tstate);
38153 if (PyErr_Occurred()) SWIG_fail;
38154 }
38155 resultobj = SWIG_Py_Void();
38156 return resultobj;
38157 fail:
38158 return NULL;
38159 }
38160
38161
38162 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38163 PyObject *resultobj = 0;
38164 wxWindow *arg1 = (wxWindow *) 0 ;
38165 wxDC *arg2 = 0 ;
38166 void *argp1 = 0 ;
38167 int res1 = 0 ;
38168 void *argp2 = 0 ;
38169 int res2 = 0 ;
38170 PyObject * obj0 = 0 ;
38171 PyObject * obj1 = 0 ;
38172 char * kwnames[] = {
38173 (char *) "self",(char *) "dc", NULL
38174 };
38175
38176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
38177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38178 if (!SWIG_IsOK(res1)) {
38179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
38180 }
38181 arg1 = reinterpret_cast< wxWindow * >(argp1);
38182 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
38183 if (!SWIG_IsOK(res2)) {
38184 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
38185 }
38186 if (!argp2) {
38187 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
38188 }
38189 arg2 = reinterpret_cast< wxDC * >(argp2);
38190 {
38191 PyThreadState* __tstate = wxPyBeginAllowThreads();
38192 (arg1)->PrepareDC(*arg2);
38193 wxPyEndAllowThreads(__tstate);
38194 if (PyErr_Occurred()) SWIG_fail;
38195 }
38196 resultobj = SWIG_Py_Void();
38197 return resultobj;
38198 fail:
38199 return NULL;
38200 }
38201
38202
38203 SWIGINTERN PyObject *_wrap_Window_IsDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38204 PyObject *resultobj = 0;
38205 wxWindow *arg1 = (wxWindow *) 0 ;
38206 bool result;
38207 void *argp1 = 0 ;
38208 int res1 = 0 ;
38209 PyObject *swig_obj[1] ;
38210
38211 if (!args) SWIG_fail;
38212 swig_obj[0] = args;
38213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38214 if (!SWIG_IsOK(res1)) {
38215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow const *""'");
38216 }
38217 arg1 = reinterpret_cast< wxWindow * >(argp1);
38218 {
38219 PyThreadState* __tstate = wxPyBeginAllowThreads();
38220 result = (bool)((wxWindow const *)arg1)->IsDoubleBuffered();
38221 wxPyEndAllowThreads(__tstate);
38222 if (PyErr_Occurred()) SWIG_fail;
38223 }
38224 {
38225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38226 }
38227 return resultobj;
38228 fail:
38229 return NULL;
38230 }
38231
38232
38233 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38234 PyObject *resultobj = 0;
38235 wxWindow *arg1 = (wxWindow *) 0 ;
38236 wxRegion *result = 0 ;
38237 void *argp1 = 0 ;
38238 int res1 = 0 ;
38239 PyObject *swig_obj[1] ;
38240
38241 if (!args) SWIG_fail;
38242 swig_obj[0] = args;
38243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38244 if (!SWIG_IsOK(res1)) {
38245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
38246 }
38247 arg1 = reinterpret_cast< wxWindow * >(argp1);
38248 {
38249 PyThreadState* __tstate = wxPyBeginAllowThreads();
38250 {
38251 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
38252 result = (wxRegion *) &_result_ref;
38253 }
38254 wxPyEndAllowThreads(__tstate);
38255 if (PyErr_Occurred()) SWIG_fail;
38256 }
38257 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
38258 return resultobj;
38259 fail:
38260 return NULL;
38261 }
38262
38263
38264 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38265 PyObject *resultobj = 0;
38266 wxWindow *arg1 = (wxWindow *) 0 ;
38267 wxRect result;
38268 void *argp1 = 0 ;
38269 int res1 = 0 ;
38270 PyObject *swig_obj[1] ;
38271
38272 if (!args) SWIG_fail;
38273 swig_obj[0] = args;
38274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38275 if (!SWIG_IsOK(res1)) {
38276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38277 }
38278 arg1 = reinterpret_cast< wxWindow * >(argp1);
38279 {
38280 PyThreadState* __tstate = wxPyBeginAllowThreads();
38281 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
38282 wxPyEndAllowThreads(__tstate);
38283 if (PyErr_Occurred()) SWIG_fail;
38284 }
38285 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
38286 return resultobj;
38287 fail:
38288 return NULL;
38289 }
38290
38291
38292 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38293 PyObject *resultobj = 0;
38294 wxWindow *arg1 = (wxWindow *) 0 ;
38295 int arg2 ;
38296 int arg3 ;
38297 int arg4 = (int) 1 ;
38298 int arg5 = (int) 1 ;
38299 bool result;
38300 void *argp1 = 0 ;
38301 int res1 = 0 ;
38302 int val2 ;
38303 int ecode2 = 0 ;
38304 int val3 ;
38305 int ecode3 = 0 ;
38306 int val4 ;
38307 int ecode4 = 0 ;
38308 int val5 ;
38309 int ecode5 = 0 ;
38310 PyObject * obj0 = 0 ;
38311 PyObject * obj1 = 0 ;
38312 PyObject * obj2 = 0 ;
38313 PyObject * obj3 = 0 ;
38314 PyObject * obj4 = 0 ;
38315 char * kwnames[] = {
38316 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
38317 };
38318
38319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38321 if (!SWIG_IsOK(res1)) {
38322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
38323 }
38324 arg1 = reinterpret_cast< wxWindow * >(argp1);
38325 ecode2 = SWIG_AsVal_int(obj1, &val2);
38326 if (!SWIG_IsOK(ecode2)) {
38327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
38328 }
38329 arg2 = static_cast< int >(val2);
38330 ecode3 = SWIG_AsVal_int(obj2, &val3);
38331 if (!SWIG_IsOK(ecode3)) {
38332 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
38333 }
38334 arg3 = static_cast< int >(val3);
38335 if (obj3) {
38336 ecode4 = SWIG_AsVal_int(obj3, &val4);
38337 if (!SWIG_IsOK(ecode4)) {
38338 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
38339 }
38340 arg4 = static_cast< int >(val4);
38341 }
38342 if (obj4) {
38343 ecode5 = SWIG_AsVal_int(obj4, &val5);
38344 if (!SWIG_IsOK(ecode5)) {
38345 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
38346 }
38347 arg5 = static_cast< int >(val5);
38348 }
38349 {
38350 PyThreadState* __tstate = wxPyBeginAllowThreads();
38351 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
38352 wxPyEndAllowThreads(__tstate);
38353 if (PyErr_Occurred()) SWIG_fail;
38354 }
38355 {
38356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38357 }
38358 return resultobj;
38359 fail:
38360 return NULL;
38361 }
38362
38363
38364 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38365 PyObject *resultobj = 0;
38366 wxWindow *arg1 = (wxWindow *) 0 ;
38367 wxPoint *arg2 = 0 ;
38368 bool result;
38369 void *argp1 = 0 ;
38370 int res1 = 0 ;
38371 wxPoint temp2 ;
38372 PyObject * obj0 = 0 ;
38373 PyObject * obj1 = 0 ;
38374 char * kwnames[] = {
38375 (char *) "self",(char *) "pt", NULL
38376 };
38377
38378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
38379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38380 if (!SWIG_IsOK(res1)) {
38381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
38382 }
38383 arg1 = reinterpret_cast< wxWindow * >(argp1);
38384 {
38385 arg2 = &temp2;
38386 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38387 }
38388 {
38389 PyThreadState* __tstate = wxPyBeginAllowThreads();
38390 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
38391 wxPyEndAllowThreads(__tstate);
38392 if (PyErr_Occurred()) SWIG_fail;
38393 }
38394 {
38395 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38396 }
38397 return resultobj;
38398 fail:
38399 return NULL;
38400 }
38401
38402
38403 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38404 PyObject *resultobj = 0;
38405 wxWindow *arg1 = (wxWindow *) 0 ;
38406 wxRect *arg2 = 0 ;
38407 bool result;
38408 void *argp1 = 0 ;
38409 int res1 = 0 ;
38410 wxRect temp2 ;
38411 PyObject * obj0 = 0 ;
38412 PyObject * obj1 = 0 ;
38413 char * kwnames[] = {
38414 (char *) "self",(char *) "rect", NULL
38415 };
38416
38417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
38418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38419 if (!SWIG_IsOK(res1)) {
38420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38421 }
38422 arg1 = reinterpret_cast< wxWindow * >(argp1);
38423 {
38424 arg2 = &temp2;
38425 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38426 }
38427 {
38428 PyThreadState* __tstate = wxPyBeginAllowThreads();
38429 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
38430 wxPyEndAllowThreads(__tstate);
38431 if (PyErr_Occurred()) SWIG_fail;
38432 }
38433 {
38434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38435 }
38436 return resultobj;
38437 fail:
38438 return NULL;
38439 }
38440
38441
38442 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38443 PyObject *resultobj = 0;
38444 wxWindow *arg1 = (wxWindow *) 0 ;
38445 SwigValueWrapper<wxVisualAttributes > result;
38446 void *argp1 = 0 ;
38447 int res1 = 0 ;
38448 PyObject *swig_obj[1] ;
38449
38450 if (!args) SWIG_fail;
38451 swig_obj[0] = args;
38452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38453 if (!SWIG_IsOK(res1)) {
38454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
38455 }
38456 arg1 = reinterpret_cast< wxWindow * >(argp1);
38457 {
38458 PyThreadState* __tstate = wxPyBeginAllowThreads();
38459 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
38460 wxPyEndAllowThreads(__tstate);
38461 if (PyErr_Occurred()) SWIG_fail;
38462 }
38463 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38464 return resultobj;
38465 fail:
38466 return NULL;
38467 }
38468
38469
38470 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38471 PyObject *resultobj = 0;
38472 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38473 SwigValueWrapper<wxVisualAttributes > result;
38474 int val1 ;
38475 int ecode1 = 0 ;
38476 PyObject * obj0 = 0 ;
38477 char * kwnames[] = {
38478 (char *) "variant", NULL
38479 };
38480
38481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
38482 if (obj0) {
38483 ecode1 = SWIG_AsVal_int(obj0, &val1);
38484 if (!SWIG_IsOK(ecode1)) {
38485 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
38486 }
38487 arg1 = static_cast< wxWindowVariant >(val1);
38488 }
38489 {
38490 if (!wxPyCheckForApp()) SWIG_fail;
38491 PyThreadState* __tstate = wxPyBeginAllowThreads();
38492 result = wxWindow::GetClassDefaultAttributes(arg1);
38493 wxPyEndAllowThreads(__tstate);
38494 if (PyErr_Occurred()) SWIG_fail;
38495 }
38496 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38497 return resultobj;
38498 fail:
38499 return NULL;
38500 }
38501
38502
38503 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38504 PyObject *resultobj = 0;
38505 wxWindow *arg1 = (wxWindow *) 0 ;
38506 wxColour *arg2 = 0 ;
38507 bool result;
38508 void *argp1 = 0 ;
38509 int res1 = 0 ;
38510 wxColour temp2 ;
38511 PyObject * obj0 = 0 ;
38512 PyObject * obj1 = 0 ;
38513 char * kwnames[] = {
38514 (char *) "self",(char *) "colour", NULL
38515 };
38516
38517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38519 if (!SWIG_IsOK(res1)) {
38520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38521 }
38522 arg1 = reinterpret_cast< wxWindow * >(argp1);
38523 {
38524 arg2 = &temp2;
38525 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38526 }
38527 {
38528 PyThreadState* __tstate = wxPyBeginAllowThreads();
38529 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
38530 wxPyEndAllowThreads(__tstate);
38531 if (PyErr_Occurred()) SWIG_fail;
38532 }
38533 {
38534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38535 }
38536 return resultobj;
38537 fail:
38538 return NULL;
38539 }
38540
38541
38542 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38543 PyObject *resultobj = 0;
38544 wxWindow *arg1 = (wxWindow *) 0 ;
38545 wxColour *arg2 = 0 ;
38546 void *argp1 = 0 ;
38547 int res1 = 0 ;
38548 wxColour temp2 ;
38549 PyObject * obj0 = 0 ;
38550 PyObject * obj1 = 0 ;
38551 char * kwnames[] = {
38552 (char *) "self",(char *) "colour", NULL
38553 };
38554
38555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38557 if (!SWIG_IsOK(res1)) {
38558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38559 }
38560 arg1 = reinterpret_cast< wxWindow * >(argp1);
38561 {
38562 arg2 = &temp2;
38563 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38564 }
38565 {
38566 PyThreadState* __tstate = wxPyBeginAllowThreads();
38567 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
38568 wxPyEndAllowThreads(__tstate);
38569 if (PyErr_Occurred()) SWIG_fail;
38570 }
38571 resultobj = SWIG_Py_Void();
38572 return resultobj;
38573 fail:
38574 return NULL;
38575 }
38576
38577
38578 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38579 PyObject *resultobj = 0;
38580 wxWindow *arg1 = (wxWindow *) 0 ;
38581 wxColour *arg2 = 0 ;
38582 bool result;
38583 void *argp1 = 0 ;
38584 int res1 = 0 ;
38585 wxColour temp2 ;
38586 PyObject * obj0 = 0 ;
38587 PyObject * obj1 = 0 ;
38588 char * kwnames[] = {
38589 (char *) "self",(char *) "colour", NULL
38590 };
38591
38592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38594 if (!SWIG_IsOK(res1)) {
38595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38596 }
38597 arg1 = reinterpret_cast< wxWindow * >(argp1);
38598 {
38599 arg2 = &temp2;
38600 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38601 }
38602 {
38603 PyThreadState* __tstate = wxPyBeginAllowThreads();
38604 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
38605 wxPyEndAllowThreads(__tstate);
38606 if (PyErr_Occurred()) SWIG_fail;
38607 }
38608 {
38609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38610 }
38611 return resultobj;
38612 fail:
38613 return NULL;
38614 }
38615
38616
38617 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38618 PyObject *resultobj = 0;
38619 wxWindow *arg1 = (wxWindow *) 0 ;
38620 wxColour *arg2 = 0 ;
38621 void *argp1 = 0 ;
38622 int res1 = 0 ;
38623 wxColour temp2 ;
38624 PyObject * obj0 = 0 ;
38625 PyObject * obj1 = 0 ;
38626 char * kwnames[] = {
38627 (char *) "self",(char *) "colour", NULL
38628 };
38629
38630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38632 if (!SWIG_IsOK(res1)) {
38633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38634 }
38635 arg1 = reinterpret_cast< wxWindow * >(argp1);
38636 {
38637 arg2 = &temp2;
38638 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38639 }
38640 {
38641 PyThreadState* __tstate = wxPyBeginAllowThreads();
38642 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
38643 wxPyEndAllowThreads(__tstate);
38644 if (PyErr_Occurred()) SWIG_fail;
38645 }
38646 resultobj = SWIG_Py_Void();
38647 return resultobj;
38648 fail:
38649 return NULL;
38650 }
38651
38652
38653 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38654 PyObject *resultobj = 0;
38655 wxWindow *arg1 = (wxWindow *) 0 ;
38656 wxColour result;
38657 void *argp1 = 0 ;
38658 int res1 = 0 ;
38659 PyObject *swig_obj[1] ;
38660
38661 if (!args) SWIG_fail;
38662 swig_obj[0] = args;
38663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38664 if (!SWIG_IsOK(res1)) {
38665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38666 }
38667 arg1 = reinterpret_cast< wxWindow * >(argp1);
38668 {
38669 PyThreadState* __tstate = wxPyBeginAllowThreads();
38670 result = ((wxWindow const *)arg1)->GetBackgroundColour();
38671 wxPyEndAllowThreads(__tstate);
38672 if (PyErr_Occurred()) SWIG_fail;
38673 }
38674 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38675 return resultobj;
38676 fail:
38677 return NULL;
38678 }
38679
38680
38681 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38682 PyObject *resultobj = 0;
38683 wxWindow *arg1 = (wxWindow *) 0 ;
38684 wxColour result;
38685 void *argp1 = 0 ;
38686 int res1 = 0 ;
38687 PyObject *swig_obj[1] ;
38688
38689 if (!args) SWIG_fail;
38690 swig_obj[0] = args;
38691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38692 if (!SWIG_IsOK(res1)) {
38693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38694 }
38695 arg1 = reinterpret_cast< wxWindow * >(argp1);
38696 {
38697 PyThreadState* __tstate = wxPyBeginAllowThreads();
38698 result = ((wxWindow const *)arg1)->GetForegroundColour();
38699 wxPyEndAllowThreads(__tstate);
38700 if (PyErr_Occurred()) SWIG_fail;
38701 }
38702 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38703 return resultobj;
38704 fail:
38705 return NULL;
38706 }
38707
38708
38709 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38710 PyObject *resultobj = 0;
38711 wxWindow *arg1 = (wxWindow *) 0 ;
38712 bool result;
38713 void *argp1 = 0 ;
38714 int res1 = 0 ;
38715 PyObject *swig_obj[1] ;
38716
38717 if (!args) SWIG_fail;
38718 swig_obj[0] = args;
38719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38720 if (!SWIG_IsOK(res1)) {
38721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38722 }
38723 arg1 = reinterpret_cast< wxWindow * >(argp1);
38724 {
38725 PyThreadState* __tstate = wxPyBeginAllowThreads();
38726 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
38727 wxPyEndAllowThreads(__tstate);
38728 if (PyErr_Occurred()) SWIG_fail;
38729 }
38730 {
38731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38732 }
38733 return resultobj;
38734 fail:
38735 return NULL;
38736 }
38737
38738
38739 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38740 PyObject *resultobj = 0;
38741 wxWindow *arg1 = (wxWindow *) 0 ;
38742 bool result;
38743 void *argp1 = 0 ;
38744 int res1 = 0 ;
38745 PyObject *swig_obj[1] ;
38746
38747 if (!args) SWIG_fail;
38748 swig_obj[0] = args;
38749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38750 if (!SWIG_IsOK(res1)) {
38751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
38752 }
38753 arg1 = reinterpret_cast< wxWindow * >(argp1);
38754 {
38755 PyThreadState* __tstate = wxPyBeginAllowThreads();
38756 result = (bool)((wxWindow const *)arg1)->UseBgCol();
38757 wxPyEndAllowThreads(__tstate);
38758 if (PyErr_Occurred()) SWIG_fail;
38759 }
38760 {
38761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38762 }
38763 return resultobj;
38764 fail:
38765 return NULL;
38766 }
38767
38768
38769 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38770 PyObject *resultobj = 0;
38771 wxWindow *arg1 = (wxWindow *) 0 ;
38772 wxBackgroundStyle arg2 ;
38773 bool result;
38774 void *argp1 = 0 ;
38775 int res1 = 0 ;
38776 int val2 ;
38777 int ecode2 = 0 ;
38778 PyObject * obj0 = 0 ;
38779 PyObject * obj1 = 0 ;
38780 char * kwnames[] = {
38781 (char *) "self",(char *) "style", NULL
38782 };
38783
38784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
38785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38786 if (!SWIG_IsOK(res1)) {
38787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
38788 }
38789 arg1 = reinterpret_cast< wxWindow * >(argp1);
38790 ecode2 = SWIG_AsVal_int(obj1, &val2);
38791 if (!SWIG_IsOK(ecode2)) {
38792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
38793 }
38794 arg2 = static_cast< wxBackgroundStyle >(val2);
38795 {
38796 PyThreadState* __tstate = wxPyBeginAllowThreads();
38797 result = (bool)(arg1)->SetBackgroundStyle(arg2);
38798 wxPyEndAllowThreads(__tstate);
38799 if (PyErr_Occurred()) SWIG_fail;
38800 }
38801 {
38802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38803 }
38804 return resultobj;
38805 fail:
38806 return NULL;
38807 }
38808
38809
38810 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38811 PyObject *resultobj = 0;
38812 wxWindow *arg1 = (wxWindow *) 0 ;
38813 wxBackgroundStyle result;
38814 void *argp1 = 0 ;
38815 int res1 = 0 ;
38816 PyObject *swig_obj[1] ;
38817
38818 if (!args) SWIG_fail;
38819 swig_obj[0] = args;
38820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38821 if (!SWIG_IsOK(res1)) {
38822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
38823 }
38824 arg1 = reinterpret_cast< wxWindow * >(argp1);
38825 {
38826 PyThreadState* __tstate = wxPyBeginAllowThreads();
38827 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
38828 wxPyEndAllowThreads(__tstate);
38829 if (PyErr_Occurred()) SWIG_fail;
38830 }
38831 resultobj = SWIG_From_int(static_cast< int >(result));
38832 return resultobj;
38833 fail:
38834 return NULL;
38835 }
38836
38837
38838 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38839 PyObject *resultobj = 0;
38840 wxWindow *arg1 = (wxWindow *) 0 ;
38841 bool result;
38842 void *argp1 = 0 ;
38843 int res1 = 0 ;
38844 PyObject *swig_obj[1] ;
38845
38846 if (!args) SWIG_fail;
38847 swig_obj[0] = args;
38848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38849 if (!SWIG_IsOK(res1)) {
38850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
38851 }
38852 arg1 = reinterpret_cast< wxWindow * >(argp1);
38853 {
38854 PyThreadState* __tstate = wxPyBeginAllowThreads();
38855 result = (bool)(arg1)->HasTransparentBackground();
38856 wxPyEndAllowThreads(__tstate);
38857 if (PyErr_Occurred()) SWIG_fail;
38858 }
38859 {
38860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38861 }
38862 return resultobj;
38863 fail:
38864 return NULL;
38865 }
38866
38867
38868 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38869 PyObject *resultobj = 0;
38870 wxWindow *arg1 = (wxWindow *) 0 ;
38871 wxCursor *arg2 = 0 ;
38872 bool result;
38873 void *argp1 = 0 ;
38874 int res1 = 0 ;
38875 void *argp2 = 0 ;
38876 int res2 = 0 ;
38877 PyObject * obj0 = 0 ;
38878 PyObject * obj1 = 0 ;
38879 char * kwnames[] = {
38880 (char *) "self",(char *) "cursor", NULL
38881 };
38882
38883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
38884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38885 if (!SWIG_IsOK(res1)) {
38886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38887 }
38888 arg1 = reinterpret_cast< wxWindow * >(argp1);
38889 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
38890 if (!SWIG_IsOK(res2)) {
38891 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38892 }
38893 if (!argp2) {
38894 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38895 }
38896 arg2 = reinterpret_cast< wxCursor * >(argp2);
38897 {
38898 PyThreadState* __tstate = wxPyBeginAllowThreads();
38899 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
38900 wxPyEndAllowThreads(__tstate);
38901 if (PyErr_Occurred()) SWIG_fail;
38902 }
38903 {
38904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38905 }
38906 return resultobj;
38907 fail:
38908 return NULL;
38909 }
38910
38911
38912 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38913 PyObject *resultobj = 0;
38914 wxWindow *arg1 = (wxWindow *) 0 ;
38915 wxCursor result;
38916 void *argp1 = 0 ;
38917 int res1 = 0 ;
38918 PyObject *swig_obj[1] ;
38919
38920 if (!args) SWIG_fail;
38921 swig_obj[0] = args;
38922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38923 if (!SWIG_IsOK(res1)) {
38924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38925 }
38926 arg1 = reinterpret_cast< wxWindow * >(argp1);
38927 {
38928 PyThreadState* __tstate = wxPyBeginAllowThreads();
38929 result = (arg1)->GetCursor();
38930 wxPyEndAllowThreads(__tstate);
38931 if (PyErr_Occurred()) SWIG_fail;
38932 }
38933 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
38934 return resultobj;
38935 fail:
38936 return NULL;
38937 }
38938
38939
38940 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38941 PyObject *resultobj = 0;
38942 wxWindow *arg1 = (wxWindow *) 0 ;
38943 wxFont *arg2 = 0 ;
38944 bool result;
38945 void *argp1 = 0 ;
38946 int res1 = 0 ;
38947 void *argp2 = 0 ;
38948 int res2 = 0 ;
38949 PyObject * obj0 = 0 ;
38950 PyObject * obj1 = 0 ;
38951 char * kwnames[] = {
38952 (char *) "self",(char *) "font", NULL
38953 };
38954
38955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
38956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38957 if (!SWIG_IsOK(res1)) {
38958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38959 }
38960 arg1 = reinterpret_cast< wxWindow * >(argp1);
38961 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38962 if (!SWIG_IsOK(res2)) {
38963 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38964 }
38965 if (!argp2) {
38966 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38967 }
38968 arg2 = reinterpret_cast< wxFont * >(argp2);
38969 {
38970 PyThreadState* __tstate = wxPyBeginAllowThreads();
38971 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
38972 wxPyEndAllowThreads(__tstate);
38973 if (PyErr_Occurred()) SWIG_fail;
38974 }
38975 {
38976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38977 }
38978 return resultobj;
38979 fail:
38980 return NULL;
38981 }
38982
38983
38984 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38985 PyObject *resultobj = 0;
38986 wxWindow *arg1 = (wxWindow *) 0 ;
38987 wxFont *arg2 = 0 ;
38988 void *argp1 = 0 ;
38989 int res1 = 0 ;
38990 void *argp2 = 0 ;
38991 int res2 = 0 ;
38992 PyObject * obj0 = 0 ;
38993 PyObject * obj1 = 0 ;
38994 char * kwnames[] = {
38995 (char *) "self",(char *) "font", NULL
38996 };
38997
38998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
38999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39000 if (!SWIG_IsOK(res1)) {
39001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
39002 }
39003 arg1 = reinterpret_cast< wxWindow * >(argp1);
39004 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
39005 if (!SWIG_IsOK(res2)) {
39006 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
39007 }
39008 if (!argp2) {
39009 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
39010 }
39011 arg2 = reinterpret_cast< wxFont * >(argp2);
39012 {
39013 PyThreadState* __tstate = wxPyBeginAllowThreads();
39014 (arg1)->SetOwnFont((wxFont const &)*arg2);
39015 wxPyEndAllowThreads(__tstate);
39016 if (PyErr_Occurred()) SWIG_fail;
39017 }
39018 resultobj = SWIG_Py_Void();
39019 return resultobj;
39020 fail:
39021 return NULL;
39022 }
39023
39024
39025 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39026 PyObject *resultobj = 0;
39027 wxWindow *arg1 = (wxWindow *) 0 ;
39028 wxFont result;
39029 void *argp1 = 0 ;
39030 int res1 = 0 ;
39031 PyObject *swig_obj[1] ;
39032
39033 if (!args) SWIG_fail;
39034 swig_obj[0] = args;
39035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39036 if (!SWIG_IsOK(res1)) {
39037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
39038 }
39039 arg1 = reinterpret_cast< wxWindow * >(argp1);
39040 {
39041 PyThreadState* __tstate = wxPyBeginAllowThreads();
39042 result = (arg1)->GetFont();
39043 wxPyEndAllowThreads(__tstate);
39044 if (PyErr_Occurred()) SWIG_fail;
39045 }
39046 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
39047 return resultobj;
39048 fail:
39049 return NULL;
39050 }
39051
39052
39053 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39054 PyObject *resultobj = 0;
39055 wxWindow *arg1 = (wxWindow *) 0 ;
39056 wxCaret *arg2 = (wxCaret *) 0 ;
39057 void *argp1 = 0 ;
39058 int res1 = 0 ;
39059 int res2 = 0 ;
39060 PyObject * obj0 = 0 ;
39061 PyObject * obj1 = 0 ;
39062 char * kwnames[] = {
39063 (char *) "self",(char *) "caret", NULL
39064 };
39065
39066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
39067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39068 if (!SWIG_IsOK(res1)) {
39069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
39070 }
39071 arg1 = reinterpret_cast< wxWindow * >(argp1);
39072 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
39073 if (!SWIG_IsOK(res2)) {
39074 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
39075 }
39076 {
39077 PyThreadState* __tstate = wxPyBeginAllowThreads();
39078 (arg1)->SetCaret(arg2);
39079 wxPyEndAllowThreads(__tstate);
39080 if (PyErr_Occurred()) SWIG_fail;
39081 }
39082 resultobj = SWIG_Py_Void();
39083 return resultobj;
39084 fail:
39085 return NULL;
39086 }
39087
39088
39089 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39090 PyObject *resultobj = 0;
39091 wxWindow *arg1 = (wxWindow *) 0 ;
39092 wxCaret *result = 0 ;
39093 void *argp1 = 0 ;
39094 int res1 = 0 ;
39095 PyObject *swig_obj[1] ;
39096
39097 if (!args) SWIG_fail;
39098 swig_obj[0] = args;
39099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39100 if (!SWIG_IsOK(res1)) {
39101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
39102 }
39103 arg1 = reinterpret_cast< wxWindow * >(argp1);
39104 {
39105 PyThreadState* __tstate = wxPyBeginAllowThreads();
39106 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
39107 wxPyEndAllowThreads(__tstate);
39108 if (PyErr_Occurred()) SWIG_fail;
39109 }
39110 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
39111 return resultobj;
39112 fail:
39113 return NULL;
39114 }
39115
39116
39117 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39118 PyObject *resultobj = 0;
39119 wxWindow *arg1 = (wxWindow *) 0 ;
39120 int result;
39121 void *argp1 = 0 ;
39122 int res1 = 0 ;
39123 PyObject *swig_obj[1] ;
39124
39125 if (!args) SWIG_fail;
39126 swig_obj[0] = args;
39127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39128 if (!SWIG_IsOK(res1)) {
39129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
39130 }
39131 arg1 = reinterpret_cast< wxWindow * >(argp1);
39132 {
39133 PyThreadState* __tstate = wxPyBeginAllowThreads();
39134 result = (int)((wxWindow const *)arg1)->GetCharHeight();
39135 wxPyEndAllowThreads(__tstate);
39136 if (PyErr_Occurred()) SWIG_fail;
39137 }
39138 resultobj = SWIG_From_int(static_cast< int >(result));
39139 return resultobj;
39140 fail:
39141 return NULL;
39142 }
39143
39144
39145 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39146 PyObject *resultobj = 0;
39147 wxWindow *arg1 = (wxWindow *) 0 ;
39148 int result;
39149 void *argp1 = 0 ;
39150 int res1 = 0 ;
39151 PyObject *swig_obj[1] ;
39152
39153 if (!args) SWIG_fail;
39154 swig_obj[0] = args;
39155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39156 if (!SWIG_IsOK(res1)) {
39157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
39158 }
39159 arg1 = reinterpret_cast< wxWindow * >(argp1);
39160 {
39161 PyThreadState* __tstate = wxPyBeginAllowThreads();
39162 result = (int)((wxWindow const *)arg1)->GetCharWidth();
39163 wxPyEndAllowThreads(__tstate);
39164 if (PyErr_Occurred()) SWIG_fail;
39165 }
39166 resultobj = SWIG_From_int(static_cast< int >(result));
39167 return resultobj;
39168 fail:
39169 return NULL;
39170 }
39171
39172
39173 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39174 PyObject *resultobj = 0;
39175 wxWindow *arg1 = (wxWindow *) 0 ;
39176 wxString *arg2 = 0 ;
39177 int *arg3 = (int *) 0 ;
39178 int *arg4 = (int *) 0 ;
39179 void *argp1 = 0 ;
39180 int res1 = 0 ;
39181 bool temp2 = false ;
39182 int temp3 ;
39183 int res3 = SWIG_TMPOBJ ;
39184 int temp4 ;
39185 int res4 = SWIG_TMPOBJ ;
39186 PyObject * obj0 = 0 ;
39187 PyObject * obj1 = 0 ;
39188 char * kwnames[] = {
39189 (char *) "self",(char *) "string", NULL
39190 };
39191
39192 arg3 = &temp3;
39193 arg4 = &temp4;
39194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
39195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39196 if (!SWIG_IsOK(res1)) {
39197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
39198 }
39199 arg1 = reinterpret_cast< wxWindow * >(argp1);
39200 {
39201 arg2 = wxString_in_helper(obj1);
39202 if (arg2 == NULL) SWIG_fail;
39203 temp2 = true;
39204 }
39205 {
39206 PyThreadState* __tstate = wxPyBeginAllowThreads();
39207 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
39208 wxPyEndAllowThreads(__tstate);
39209 if (PyErr_Occurred()) SWIG_fail;
39210 }
39211 resultobj = SWIG_Py_Void();
39212 if (SWIG_IsTmpObj(res3)) {
39213 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39214 } else {
39215 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39216 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39217 }
39218 if (SWIG_IsTmpObj(res4)) {
39219 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
39220 } else {
39221 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39222 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
39223 }
39224 {
39225 if (temp2)
39226 delete arg2;
39227 }
39228 return resultobj;
39229 fail:
39230 {
39231 if (temp2)
39232 delete arg2;
39233 }
39234 return NULL;
39235 }
39236
39237
39238 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39239 PyObject *resultobj = 0;
39240 wxWindow *arg1 = (wxWindow *) 0 ;
39241 wxString *arg2 = 0 ;
39242 int *arg3 = (int *) 0 ;
39243 int *arg4 = (int *) 0 ;
39244 int *arg5 = (int *) 0 ;
39245 int *arg6 = (int *) 0 ;
39246 wxFont *arg7 = (wxFont *) NULL ;
39247 void *argp1 = 0 ;
39248 int res1 = 0 ;
39249 bool temp2 = false ;
39250 int temp3 ;
39251 int res3 = SWIG_TMPOBJ ;
39252 int temp4 ;
39253 int res4 = SWIG_TMPOBJ ;
39254 int temp5 ;
39255 int res5 = SWIG_TMPOBJ ;
39256 int temp6 ;
39257 int res6 = SWIG_TMPOBJ ;
39258 void *argp7 = 0 ;
39259 int res7 = 0 ;
39260 PyObject * obj0 = 0 ;
39261 PyObject * obj1 = 0 ;
39262 PyObject * obj2 = 0 ;
39263 char * kwnames[] = {
39264 (char *) "self",(char *) "string",(char *) "font", NULL
39265 };
39266
39267 arg3 = &temp3;
39268 arg4 = &temp4;
39269 arg5 = &temp5;
39270 arg6 = &temp6;
39271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39273 if (!SWIG_IsOK(res1)) {
39274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
39275 }
39276 arg1 = reinterpret_cast< wxWindow * >(argp1);
39277 {
39278 arg2 = wxString_in_helper(obj1);
39279 if (arg2 == NULL) SWIG_fail;
39280 temp2 = true;
39281 }
39282 if (obj2) {
39283 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
39284 if (!SWIG_IsOK(res7)) {
39285 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
39286 }
39287 arg7 = reinterpret_cast< wxFont * >(argp7);
39288 }
39289 {
39290 PyThreadState* __tstate = wxPyBeginAllowThreads();
39291 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
39292 wxPyEndAllowThreads(__tstate);
39293 if (PyErr_Occurred()) SWIG_fail;
39294 }
39295 resultobj = SWIG_Py_Void();
39296 if (SWIG_IsTmpObj(res3)) {
39297 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39298 } else {
39299 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39300 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39301 }
39302 if (SWIG_IsTmpObj(res4)) {
39303 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
39304 } else {
39305 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39306 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
39307 }
39308 if (SWIG_IsTmpObj(res5)) {
39309 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
39310 } else {
39311 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39312 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
39313 }
39314 if (SWIG_IsTmpObj(res6)) {
39315 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
39316 } else {
39317 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39318 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
39319 }
39320 {
39321 if (temp2)
39322 delete arg2;
39323 }
39324 return resultobj;
39325 fail:
39326 {
39327 if (temp2)
39328 delete arg2;
39329 }
39330 return NULL;
39331 }
39332
39333
39334 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39335 PyObject *resultobj = 0;
39336 wxWindow *arg1 = (wxWindow *) 0 ;
39337 int *arg2 = (int *) 0 ;
39338 int *arg3 = (int *) 0 ;
39339 void *argp1 = 0 ;
39340 int res1 = 0 ;
39341 int temp2 ;
39342 int res2 = 0 ;
39343 int temp3 ;
39344 int res3 = 0 ;
39345 PyObject * obj0 = 0 ;
39346 PyObject * obj1 = 0 ;
39347 PyObject * obj2 = 0 ;
39348 char * kwnames[] = {
39349 (char *) "self",(char *) "x",(char *) "y", NULL
39350 };
39351
39352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39354 if (!SWIG_IsOK(res1)) {
39355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39356 }
39357 arg1 = reinterpret_cast< wxWindow * >(argp1);
39358 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39359 int val;
39360 int ecode = SWIG_AsVal_int(obj1, &val);
39361 if (!SWIG_IsOK(ecode)) {
39362 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
39363 }
39364 temp2 = static_cast< int >(val);
39365 arg2 = &temp2;
39366 res2 = SWIG_AddTmpMask(ecode);
39367 }
39368 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39369 int val;
39370 int ecode = SWIG_AsVal_int(obj2, &val);
39371 if (!SWIG_IsOK(ecode)) {
39372 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
39373 }
39374 temp3 = static_cast< int >(val);
39375 arg3 = &temp3;
39376 res3 = SWIG_AddTmpMask(ecode);
39377 }
39378 {
39379 PyThreadState* __tstate = wxPyBeginAllowThreads();
39380 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
39381 wxPyEndAllowThreads(__tstate);
39382 if (PyErr_Occurred()) SWIG_fail;
39383 }
39384 resultobj = SWIG_Py_Void();
39385 if (SWIG_IsTmpObj(res2)) {
39386 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39387 } else {
39388 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39389 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39390 }
39391 if (SWIG_IsTmpObj(res3)) {
39392 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39393 } else {
39394 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39395 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39396 }
39397 return resultobj;
39398 fail:
39399 return NULL;
39400 }
39401
39402
39403 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39404 PyObject *resultobj = 0;
39405 wxWindow *arg1 = (wxWindow *) 0 ;
39406 int *arg2 = (int *) 0 ;
39407 int *arg3 = (int *) 0 ;
39408 void *argp1 = 0 ;
39409 int res1 = 0 ;
39410 int temp2 ;
39411 int res2 = 0 ;
39412 int temp3 ;
39413 int res3 = 0 ;
39414 PyObject * obj0 = 0 ;
39415 PyObject * obj1 = 0 ;
39416 PyObject * obj2 = 0 ;
39417 char * kwnames[] = {
39418 (char *) "self",(char *) "x",(char *) "y", NULL
39419 };
39420
39421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39423 if (!SWIG_IsOK(res1)) {
39424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39425 }
39426 arg1 = reinterpret_cast< wxWindow * >(argp1);
39427 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39428 int val;
39429 int ecode = SWIG_AsVal_int(obj1, &val);
39430 if (!SWIG_IsOK(ecode)) {
39431 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
39432 }
39433 temp2 = static_cast< int >(val);
39434 arg2 = &temp2;
39435 res2 = SWIG_AddTmpMask(ecode);
39436 }
39437 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39438 int val;
39439 int ecode = SWIG_AsVal_int(obj2, &val);
39440 if (!SWIG_IsOK(ecode)) {
39441 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
39442 }
39443 temp3 = static_cast< int >(val);
39444 arg3 = &temp3;
39445 res3 = SWIG_AddTmpMask(ecode);
39446 }
39447 {
39448 PyThreadState* __tstate = wxPyBeginAllowThreads();
39449 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
39450 wxPyEndAllowThreads(__tstate);
39451 if (PyErr_Occurred()) SWIG_fail;
39452 }
39453 resultobj = SWIG_Py_Void();
39454 if (SWIG_IsTmpObj(res2)) {
39455 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39456 } else {
39457 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39458 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39459 }
39460 if (SWIG_IsTmpObj(res3)) {
39461 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39462 } else {
39463 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39464 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39465 }
39466 return resultobj;
39467 fail:
39468 return NULL;
39469 }
39470
39471
39472 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39473 PyObject *resultobj = 0;
39474 wxWindow *arg1 = (wxWindow *) 0 ;
39475 wxPoint *arg2 = 0 ;
39476 wxPoint result;
39477 void *argp1 = 0 ;
39478 int res1 = 0 ;
39479 wxPoint temp2 ;
39480 PyObject * obj0 = 0 ;
39481 PyObject * obj1 = 0 ;
39482 char * kwnames[] = {
39483 (char *) "self",(char *) "pt", NULL
39484 };
39485
39486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
39487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39488 if (!SWIG_IsOK(res1)) {
39489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
39490 }
39491 arg1 = reinterpret_cast< wxWindow * >(argp1);
39492 {
39493 arg2 = &temp2;
39494 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39495 }
39496 {
39497 PyThreadState* __tstate = wxPyBeginAllowThreads();
39498 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
39499 wxPyEndAllowThreads(__tstate);
39500 if (PyErr_Occurred()) SWIG_fail;
39501 }
39502 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39503 return resultobj;
39504 fail:
39505 return NULL;
39506 }
39507
39508
39509 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39510 PyObject *resultobj = 0;
39511 wxWindow *arg1 = (wxWindow *) 0 ;
39512 wxPoint *arg2 = 0 ;
39513 wxPoint result;
39514 void *argp1 = 0 ;
39515 int res1 = 0 ;
39516 wxPoint temp2 ;
39517 PyObject * obj0 = 0 ;
39518 PyObject * obj1 = 0 ;
39519 char * kwnames[] = {
39520 (char *) "self",(char *) "pt", NULL
39521 };
39522
39523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
39524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39525 if (!SWIG_IsOK(res1)) {
39526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
39527 }
39528 arg1 = reinterpret_cast< wxWindow * >(argp1);
39529 {
39530 arg2 = &temp2;
39531 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39532 }
39533 {
39534 PyThreadState* __tstate = wxPyBeginAllowThreads();
39535 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
39536 wxPyEndAllowThreads(__tstate);
39537 if (PyErr_Occurred()) SWIG_fail;
39538 }
39539 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39540 return resultobj;
39541 fail:
39542 return NULL;
39543 }
39544
39545
39546 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39547 PyObject *resultobj = 0;
39548 wxWindow *arg1 = (wxWindow *) 0 ;
39549 int arg2 ;
39550 int arg3 ;
39551 wxHitTest result;
39552 void *argp1 = 0 ;
39553 int res1 = 0 ;
39554 int val2 ;
39555 int ecode2 = 0 ;
39556 int val3 ;
39557 int ecode3 = 0 ;
39558 PyObject * obj0 = 0 ;
39559 PyObject * obj1 = 0 ;
39560 PyObject * obj2 = 0 ;
39561 char * kwnames[] = {
39562 (char *) "self",(char *) "x",(char *) "y", NULL
39563 };
39564
39565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39567 if (!SWIG_IsOK(res1)) {
39568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39569 }
39570 arg1 = reinterpret_cast< wxWindow * >(argp1);
39571 ecode2 = SWIG_AsVal_int(obj1, &val2);
39572 if (!SWIG_IsOK(ecode2)) {
39573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
39574 }
39575 arg2 = static_cast< int >(val2);
39576 ecode3 = SWIG_AsVal_int(obj2, &val3);
39577 if (!SWIG_IsOK(ecode3)) {
39578 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
39579 }
39580 arg3 = static_cast< int >(val3);
39581 {
39582 PyThreadState* __tstate = wxPyBeginAllowThreads();
39583 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
39584 wxPyEndAllowThreads(__tstate);
39585 if (PyErr_Occurred()) SWIG_fail;
39586 }
39587 resultobj = SWIG_From_int(static_cast< int >(result));
39588 return resultobj;
39589 fail:
39590 return NULL;
39591 }
39592
39593
39594 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39595 PyObject *resultobj = 0;
39596 wxWindow *arg1 = (wxWindow *) 0 ;
39597 wxPoint *arg2 = 0 ;
39598 wxHitTest result;
39599 void *argp1 = 0 ;
39600 int res1 = 0 ;
39601 wxPoint temp2 ;
39602 PyObject * obj0 = 0 ;
39603 PyObject * obj1 = 0 ;
39604 char * kwnames[] = {
39605 (char *) "self",(char *) "pt", NULL
39606 };
39607
39608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
39609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39610 if (!SWIG_IsOK(res1)) {
39611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
39612 }
39613 arg1 = reinterpret_cast< wxWindow * >(argp1);
39614 {
39615 arg2 = &temp2;
39616 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39617 }
39618 {
39619 PyThreadState* __tstate = wxPyBeginAllowThreads();
39620 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
39621 wxPyEndAllowThreads(__tstate);
39622 if (PyErr_Occurred()) SWIG_fail;
39623 }
39624 resultobj = SWIG_From_int(static_cast< int >(result));
39625 return resultobj;
39626 fail:
39627 return NULL;
39628 }
39629
39630
39631 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39632 PyObject *resultobj = 0;
39633 wxWindow *arg1 = (wxWindow *) 0 ;
39634 long arg2 ;
39635 wxBorder result;
39636 void *argp1 = 0 ;
39637 int res1 = 0 ;
39638 long val2 ;
39639 int ecode2 = 0 ;
39640
39641 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
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_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39645 }
39646 arg1 = reinterpret_cast< wxWindow * >(argp1);
39647 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
39648 if (!SWIG_IsOK(ecode2)) {
39649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
39650 }
39651 arg2 = static_cast< long >(val2);
39652 {
39653 PyThreadState* __tstate = wxPyBeginAllowThreads();
39654 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
39655 wxPyEndAllowThreads(__tstate);
39656 if (PyErr_Occurred()) SWIG_fail;
39657 }
39658 resultobj = SWIG_From_int(static_cast< int >(result));
39659 return resultobj;
39660 fail:
39661 return NULL;
39662 }
39663
39664
39665 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39666 PyObject *resultobj = 0;
39667 wxWindow *arg1 = (wxWindow *) 0 ;
39668 wxBorder result;
39669 void *argp1 = 0 ;
39670 int res1 = 0 ;
39671
39672 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
39673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39674 if (!SWIG_IsOK(res1)) {
39675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39676 }
39677 arg1 = reinterpret_cast< wxWindow * >(argp1);
39678 {
39679 PyThreadState* __tstate = wxPyBeginAllowThreads();
39680 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
39681 wxPyEndAllowThreads(__tstate);
39682 if (PyErr_Occurred()) SWIG_fail;
39683 }
39684 resultobj = SWIG_From_int(static_cast< int >(result));
39685 return resultobj;
39686 fail:
39687 return NULL;
39688 }
39689
39690
39691 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
39692 int argc;
39693 PyObject *argv[3];
39694
39695 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
39696 --argc;
39697 if (argc == 1) {
39698 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
39699 }
39700 if (argc == 2) {
39701 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
39702 }
39703
39704 fail:
39705 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
39706 return NULL;
39707 }
39708
39709
39710 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39711 PyObject *resultobj = 0;
39712 wxWindow *arg1 = (wxWindow *) 0 ;
39713 long arg2 = (long) wxUPDATE_UI_NONE ;
39714 void *argp1 = 0 ;
39715 int res1 = 0 ;
39716 long val2 ;
39717 int ecode2 = 0 ;
39718 PyObject * obj0 = 0 ;
39719 PyObject * obj1 = 0 ;
39720 char * kwnames[] = {
39721 (char *) "self",(char *) "flags", NULL
39722 };
39723
39724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
39725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39726 if (!SWIG_IsOK(res1)) {
39727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
39728 }
39729 arg1 = reinterpret_cast< wxWindow * >(argp1);
39730 if (obj1) {
39731 ecode2 = SWIG_AsVal_long(obj1, &val2);
39732 if (!SWIG_IsOK(ecode2)) {
39733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
39734 }
39735 arg2 = static_cast< long >(val2);
39736 }
39737 {
39738 PyThreadState* __tstate = wxPyBeginAllowThreads();
39739 (arg1)->UpdateWindowUI(arg2);
39740 wxPyEndAllowThreads(__tstate);
39741 if (PyErr_Occurred()) SWIG_fail;
39742 }
39743 resultobj = SWIG_Py_Void();
39744 return resultobj;
39745 fail:
39746 return NULL;
39747 }
39748
39749
39750 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39751 PyObject *resultobj = 0;
39752 wxWindow *arg1 = (wxWindow *) 0 ;
39753 wxMenu *arg2 = (wxMenu *) 0 ;
39754 int arg3 = (int) -1 ;
39755 int arg4 = (int) -1 ;
39756 bool result;
39757 void *argp1 = 0 ;
39758 int res1 = 0 ;
39759 void *argp2 = 0 ;
39760 int res2 = 0 ;
39761 int val3 ;
39762 int ecode3 = 0 ;
39763 int val4 ;
39764 int ecode4 = 0 ;
39765 PyObject * obj0 = 0 ;
39766 PyObject * obj1 = 0 ;
39767 PyObject * obj2 = 0 ;
39768 PyObject * obj3 = 0 ;
39769 char * kwnames[] = {
39770 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
39771 };
39772
39773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39775 if (!SWIG_IsOK(res1)) {
39776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
39777 }
39778 arg1 = reinterpret_cast< wxWindow * >(argp1);
39779 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39780 if (!SWIG_IsOK(res2)) {
39781 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
39782 }
39783 arg2 = reinterpret_cast< wxMenu * >(argp2);
39784 if (obj2) {
39785 ecode3 = SWIG_AsVal_int(obj2, &val3);
39786 if (!SWIG_IsOK(ecode3)) {
39787 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
39788 }
39789 arg3 = static_cast< int >(val3);
39790 }
39791 if (obj3) {
39792 ecode4 = SWIG_AsVal_int(obj3, &val4);
39793 if (!SWIG_IsOK(ecode4)) {
39794 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
39795 }
39796 arg4 = static_cast< int >(val4);
39797 }
39798 {
39799 PyThreadState* __tstate = wxPyBeginAllowThreads();
39800 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
39801 wxPyEndAllowThreads(__tstate);
39802 if (PyErr_Occurred()) SWIG_fail;
39803 }
39804 {
39805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39806 }
39807 return resultobj;
39808 fail:
39809 return NULL;
39810 }
39811
39812
39813 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39814 PyObject *resultobj = 0;
39815 wxWindow *arg1 = (wxWindow *) 0 ;
39816 wxMenu *arg2 = (wxMenu *) 0 ;
39817 wxPoint const &arg3_defvalue = wxDefaultPosition ;
39818 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
39819 bool result;
39820 void *argp1 = 0 ;
39821 int res1 = 0 ;
39822 void *argp2 = 0 ;
39823 int res2 = 0 ;
39824 wxPoint temp3 ;
39825 PyObject * obj0 = 0 ;
39826 PyObject * obj1 = 0 ;
39827 PyObject * obj2 = 0 ;
39828 char * kwnames[] = {
39829 (char *) "self",(char *) "menu",(char *) "pos", NULL
39830 };
39831
39832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39834 if (!SWIG_IsOK(res1)) {
39835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
39836 }
39837 arg1 = reinterpret_cast< wxWindow * >(argp1);
39838 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39839 if (!SWIG_IsOK(res2)) {
39840 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39841 }
39842 arg2 = reinterpret_cast< wxMenu * >(argp2);
39843 if (obj2) {
39844 {
39845 arg3 = &temp3;
39846 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
39847 }
39848 }
39849 {
39850 PyThreadState* __tstate = wxPyBeginAllowThreads();
39851 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
39852 wxPyEndAllowThreads(__tstate);
39853 if (PyErr_Occurred()) SWIG_fail;
39854 }
39855 {
39856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39857 }
39858 return resultobj;
39859 fail:
39860 return NULL;
39861 }
39862
39863
39864 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39865 PyObject *resultobj = 0;
39866 wxWindow *arg1 = (wxWindow *) 0 ;
39867 bool result;
39868 void *argp1 = 0 ;
39869 int res1 = 0 ;
39870 PyObject *swig_obj[1] ;
39871
39872 if (!args) SWIG_fail;
39873 swig_obj[0] = args;
39874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39875 if (!SWIG_IsOK(res1)) {
39876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
39877 }
39878 arg1 = reinterpret_cast< wxWindow * >(argp1);
39879 {
39880 PyThreadState* __tstate = wxPyBeginAllowThreads();
39881 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
39882 wxPyEndAllowThreads(__tstate);
39883 if (PyErr_Occurred()) SWIG_fail;
39884 }
39885 {
39886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39887 }
39888 return resultobj;
39889 fail:
39890 return NULL;
39891 }
39892
39893
39894 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39895 PyObject *resultobj = 0;
39896 wxWindow *arg1 = (wxWindow *) 0 ;
39897 long result;
39898 void *argp1 = 0 ;
39899 int res1 = 0 ;
39900 PyObject *swig_obj[1] ;
39901
39902 if (!args) SWIG_fail;
39903 swig_obj[0] = args;
39904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39905 if (!SWIG_IsOK(res1)) {
39906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39907 }
39908 arg1 = reinterpret_cast< wxWindow * >(argp1);
39909 {
39910 PyThreadState* __tstate = wxPyBeginAllowThreads();
39911 result = (long)wxWindow_GetHandle(arg1);
39912 wxPyEndAllowThreads(__tstate);
39913 if (PyErr_Occurred()) SWIG_fail;
39914 }
39915 resultobj = SWIG_From_long(static_cast< long >(result));
39916 return resultobj;
39917 fail:
39918 return NULL;
39919 }
39920
39921
39922 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39923 PyObject *resultobj = 0;
39924 wxWindow *arg1 = (wxWindow *) 0 ;
39925 long arg2 ;
39926 void *argp1 = 0 ;
39927 int res1 = 0 ;
39928 long val2 ;
39929 int ecode2 = 0 ;
39930 PyObject * obj0 = 0 ;
39931 PyObject * obj1 = 0 ;
39932 char * kwnames[] = {
39933 (char *) "self",(char *) "handle", NULL
39934 };
39935
39936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) 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_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39940 }
39941 arg1 = reinterpret_cast< wxWindow * >(argp1);
39942 ecode2 = SWIG_AsVal_long(obj1, &val2);
39943 if (!SWIG_IsOK(ecode2)) {
39944 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
39945 }
39946 arg2 = static_cast< long >(val2);
39947 {
39948 PyThreadState* __tstate = wxPyBeginAllowThreads();
39949 wxWindow_AssociateHandle(arg1,arg2);
39950 wxPyEndAllowThreads(__tstate);
39951 if (PyErr_Occurred()) SWIG_fail;
39952 }
39953 resultobj = SWIG_Py_Void();
39954 return resultobj;
39955 fail:
39956 return NULL;
39957 }
39958
39959
39960 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39961 PyObject *resultobj = 0;
39962 wxWindow *arg1 = (wxWindow *) 0 ;
39963 void *argp1 = 0 ;
39964 int res1 = 0 ;
39965 PyObject *swig_obj[1] ;
39966
39967 if (!args) SWIG_fail;
39968 swig_obj[0] = args;
39969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39970 if (!SWIG_IsOK(res1)) {
39971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39972 }
39973 arg1 = reinterpret_cast< wxWindow * >(argp1);
39974 {
39975 PyThreadState* __tstate = wxPyBeginAllowThreads();
39976 (arg1)->DissociateHandle();
39977 wxPyEndAllowThreads(__tstate);
39978 if (PyErr_Occurred()) SWIG_fail;
39979 }
39980 resultobj = SWIG_Py_Void();
39981 return resultobj;
39982 fail:
39983 return NULL;
39984 }
39985
39986
39987 SWIGINTERN PyObject *_wrap_Window_OnPaint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39988 PyObject *resultobj = 0;
39989 wxWindow *arg1 = (wxWindow *) 0 ;
39990 wxPaintEvent *arg2 = 0 ;
39991 void *argp1 = 0 ;
39992 int res1 = 0 ;
39993 void *argp2 = 0 ;
39994 int res2 = 0 ;
39995 PyObject * obj0 = 0 ;
39996 PyObject * obj1 = 0 ;
39997 char * kwnames[] = {
39998 (char *) "self",(char *) "event", NULL
39999 };
40000
40001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",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_OnPaint" "', expected argument " "1"" of type '" "wxWindow *""'");
40005 }
40006 arg1 = reinterpret_cast< wxWindow * >(argp1);
40007 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPaintEvent, 0 );
40008 if (!SWIG_IsOK(res2)) {
40009 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
40010 }
40011 if (!argp2) {
40012 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
40013 }
40014 arg2 = reinterpret_cast< wxPaintEvent * >(argp2);
40015 {
40016 PyThreadState* __tstate = wxPyBeginAllowThreads();
40017 (arg1)->OnPaint(*arg2);
40018 wxPyEndAllowThreads(__tstate);
40019 if (PyErr_Occurred()) SWIG_fail;
40020 }
40021 resultobj = SWIG_Py_Void();
40022 return resultobj;
40023 fail:
40024 return NULL;
40025 }
40026
40027
40028 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40029 PyObject *resultobj = 0;
40030 wxWindow *arg1 = (wxWindow *) 0 ;
40031 int arg2 ;
40032 bool result;
40033 void *argp1 = 0 ;
40034 int res1 = 0 ;
40035 int val2 ;
40036 int ecode2 = 0 ;
40037 PyObject * obj0 = 0 ;
40038 PyObject * obj1 = 0 ;
40039 char * kwnames[] = {
40040 (char *) "self",(char *) "orient", NULL
40041 };
40042
40043 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
40044 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40045 if (!SWIG_IsOK(res1)) {
40046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
40047 }
40048 arg1 = reinterpret_cast< wxWindow * >(argp1);
40049 ecode2 = SWIG_AsVal_int(obj1, &val2);
40050 if (!SWIG_IsOK(ecode2)) {
40051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
40052 }
40053 arg2 = static_cast< int >(val2);
40054 {
40055 PyThreadState* __tstate = wxPyBeginAllowThreads();
40056 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
40057 wxPyEndAllowThreads(__tstate);
40058 if (PyErr_Occurred()) SWIG_fail;
40059 }
40060 {
40061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40062 }
40063 return resultobj;
40064 fail:
40065 return NULL;
40066 }
40067
40068
40069 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40070 PyObject *resultobj = 0;
40071 wxWindow *arg1 = (wxWindow *) 0 ;
40072 int arg2 ;
40073 int arg3 ;
40074 int arg4 ;
40075 int arg5 ;
40076 bool arg6 = (bool) true ;
40077 void *argp1 = 0 ;
40078 int res1 = 0 ;
40079 int val2 ;
40080 int ecode2 = 0 ;
40081 int val3 ;
40082 int ecode3 = 0 ;
40083 int val4 ;
40084 int ecode4 = 0 ;
40085 int val5 ;
40086 int ecode5 = 0 ;
40087 bool val6 ;
40088 int ecode6 = 0 ;
40089 PyObject * obj0 = 0 ;
40090 PyObject * obj1 = 0 ;
40091 PyObject * obj2 = 0 ;
40092 PyObject * obj3 = 0 ;
40093 PyObject * obj4 = 0 ;
40094 PyObject * obj5 = 0 ;
40095 char * kwnames[] = {
40096 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
40097 };
40098
40099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
40100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40101 if (!SWIG_IsOK(res1)) {
40102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
40103 }
40104 arg1 = reinterpret_cast< wxWindow * >(argp1);
40105 ecode2 = SWIG_AsVal_int(obj1, &val2);
40106 if (!SWIG_IsOK(ecode2)) {
40107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
40108 }
40109 arg2 = static_cast< int >(val2);
40110 ecode3 = SWIG_AsVal_int(obj2, &val3);
40111 if (!SWIG_IsOK(ecode3)) {
40112 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
40113 }
40114 arg3 = static_cast< int >(val3);
40115 ecode4 = SWIG_AsVal_int(obj3, &val4);
40116 if (!SWIG_IsOK(ecode4)) {
40117 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
40118 }
40119 arg4 = static_cast< int >(val4);
40120 ecode5 = SWIG_AsVal_int(obj4, &val5);
40121 if (!SWIG_IsOK(ecode5)) {
40122 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
40123 }
40124 arg5 = static_cast< int >(val5);
40125 if (obj5) {
40126 ecode6 = SWIG_AsVal_bool(obj5, &val6);
40127 if (!SWIG_IsOK(ecode6)) {
40128 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
40129 }
40130 arg6 = static_cast< bool >(val6);
40131 }
40132 {
40133 PyThreadState* __tstate = wxPyBeginAllowThreads();
40134 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
40135 wxPyEndAllowThreads(__tstate);
40136 if (PyErr_Occurred()) SWIG_fail;
40137 }
40138 resultobj = SWIG_Py_Void();
40139 return resultobj;
40140 fail:
40141 return NULL;
40142 }
40143
40144
40145 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40146 PyObject *resultobj = 0;
40147 wxWindow *arg1 = (wxWindow *) 0 ;
40148 int arg2 ;
40149 int arg3 ;
40150 bool arg4 = (bool) true ;
40151 void *argp1 = 0 ;
40152 int res1 = 0 ;
40153 int val2 ;
40154 int ecode2 = 0 ;
40155 int val3 ;
40156 int ecode3 = 0 ;
40157 bool val4 ;
40158 int ecode4 = 0 ;
40159 PyObject * obj0 = 0 ;
40160 PyObject * obj1 = 0 ;
40161 PyObject * obj2 = 0 ;
40162 PyObject * obj3 = 0 ;
40163 char * kwnames[] = {
40164 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
40165 };
40166
40167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40169 if (!SWIG_IsOK(res1)) {
40170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
40171 }
40172 arg1 = reinterpret_cast< wxWindow * >(argp1);
40173 ecode2 = SWIG_AsVal_int(obj1, &val2);
40174 if (!SWIG_IsOK(ecode2)) {
40175 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
40176 }
40177 arg2 = static_cast< int >(val2);
40178 ecode3 = SWIG_AsVal_int(obj2, &val3);
40179 if (!SWIG_IsOK(ecode3)) {
40180 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
40181 }
40182 arg3 = static_cast< int >(val3);
40183 if (obj3) {
40184 ecode4 = SWIG_AsVal_bool(obj3, &val4);
40185 if (!SWIG_IsOK(ecode4)) {
40186 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
40187 }
40188 arg4 = static_cast< bool >(val4);
40189 }
40190 {
40191 PyThreadState* __tstate = wxPyBeginAllowThreads();
40192 (arg1)->SetScrollPos(arg2,arg3,arg4);
40193 wxPyEndAllowThreads(__tstate);
40194 if (PyErr_Occurred()) SWIG_fail;
40195 }
40196 resultobj = SWIG_Py_Void();
40197 return resultobj;
40198 fail:
40199 return NULL;
40200 }
40201
40202
40203 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40204 PyObject *resultobj = 0;
40205 wxWindow *arg1 = (wxWindow *) 0 ;
40206 int arg2 ;
40207 int result;
40208 void *argp1 = 0 ;
40209 int res1 = 0 ;
40210 int val2 ;
40211 int ecode2 = 0 ;
40212 PyObject * obj0 = 0 ;
40213 PyObject * obj1 = 0 ;
40214 char * kwnames[] = {
40215 (char *) "self",(char *) "orientation", NULL
40216 };
40217
40218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
40219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40220 if (!SWIG_IsOK(res1)) {
40221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
40222 }
40223 arg1 = reinterpret_cast< wxWindow * >(argp1);
40224 ecode2 = SWIG_AsVal_int(obj1, &val2);
40225 if (!SWIG_IsOK(ecode2)) {
40226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
40227 }
40228 arg2 = static_cast< int >(val2);
40229 {
40230 PyThreadState* __tstate = wxPyBeginAllowThreads();
40231 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
40232 wxPyEndAllowThreads(__tstate);
40233 if (PyErr_Occurred()) SWIG_fail;
40234 }
40235 resultobj = SWIG_From_int(static_cast< int >(result));
40236 return resultobj;
40237 fail:
40238 return NULL;
40239 }
40240
40241
40242 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40243 PyObject *resultobj = 0;
40244 wxWindow *arg1 = (wxWindow *) 0 ;
40245 int arg2 ;
40246 int result;
40247 void *argp1 = 0 ;
40248 int res1 = 0 ;
40249 int val2 ;
40250 int ecode2 = 0 ;
40251 PyObject * obj0 = 0 ;
40252 PyObject * obj1 = 0 ;
40253 char * kwnames[] = {
40254 (char *) "self",(char *) "orientation", NULL
40255 };
40256
40257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
40258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40259 if (!SWIG_IsOK(res1)) {
40260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
40261 }
40262 arg1 = reinterpret_cast< wxWindow * >(argp1);
40263 ecode2 = SWIG_AsVal_int(obj1, &val2);
40264 if (!SWIG_IsOK(ecode2)) {
40265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
40266 }
40267 arg2 = static_cast< int >(val2);
40268 {
40269 PyThreadState* __tstate = wxPyBeginAllowThreads();
40270 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
40271 wxPyEndAllowThreads(__tstate);
40272 if (PyErr_Occurred()) SWIG_fail;
40273 }
40274 resultobj = SWIG_From_int(static_cast< int >(result));
40275 return resultobj;
40276 fail:
40277 return NULL;
40278 }
40279
40280
40281 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40282 PyObject *resultobj = 0;
40283 wxWindow *arg1 = (wxWindow *) 0 ;
40284 int arg2 ;
40285 int result;
40286 void *argp1 = 0 ;
40287 int res1 = 0 ;
40288 int val2 ;
40289 int ecode2 = 0 ;
40290 PyObject * obj0 = 0 ;
40291 PyObject * obj1 = 0 ;
40292 char * kwnames[] = {
40293 (char *) "self",(char *) "orientation", NULL
40294 };
40295
40296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
40297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40298 if (!SWIG_IsOK(res1)) {
40299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
40300 }
40301 arg1 = reinterpret_cast< wxWindow * >(argp1);
40302 ecode2 = SWIG_AsVal_int(obj1, &val2);
40303 if (!SWIG_IsOK(ecode2)) {
40304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
40305 }
40306 arg2 = static_cast< int >(val2);
40307 {
40308 PyThreadState* __tstate = wxPyBeginAllowThreads();
40309 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
40310 wxPyEndAllowThreads(__tstate);
40311 if (PyErr_Occurred()) SWIG_fail;
40312 }
40313 resultobj = SWIG_From_int(static_cast< int >(result));
40314 return resultobj;
40315 fail:
40316 return NULL;
40317 }
40318
40319
40320 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40321 PyObject *resultobj = 0;
40322 wxWindow *arg1 = (wxWindow *) 0 ;
40323 int arg2 ;
40324 int arg3 ;
40325 wxRect *arg4 = (wxRect *) NULL ;
40326 void *argp1 = 0 ;
40327 int res1 = 0 ;
40328 int val2 ;
40329 int ecode2 = 0 ;
40330 int val3 ;
40331 int ecode3 = 0 ;
40332 void *argp4 = 0 ;
40333 int res4 = 0 ;
40334 PyObject * obj0 = 0 ;
40335 PyObject * obj1 = 0 ;
40336 PyObject * obj2 = 0 ;
40337 PyObject * obj3 = 0 ;
40338 char * kwnames[] = {
40339 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
40340 };
40341
40342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40344 if (!SWIG_IsOK(res1)) {
40345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
40346 }
40347 arg1 = reinterpret_cast< wxWindow * >(argp1);
40348 ecode2 = SWIG_AsVal_int(obj1, &val2);
40349 if (!SWIG_IsOK(ecode2)) {
40350 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
40351 }
40352 arg2 = static_cast< int >(val2);
40353 ecode3 = SWIG_AsVal_int(obj2, &val3);
40354 if (!SWIG_IsOK(ecode3)) {
40355 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
40356 }
40357 arg3 = static_cast< int >(val3);
40358 if (obj3) {
40359 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
40360 if (!SWIG_IsOK(res4)) {
40361 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
40362 }
40363 arg4 = reinterpret_cast< wxRect * >(argp4);
40364 }
40365 {
40366 PyThreadState* __tstate = wxPyBeginAllowThreads();
40367 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
40368 wxPyEndAllowThreads(__tstate);
40369 if (PyErr_Occurred()) SWIG_fail;
40370 }
40371 resultobj = SWIG_Py_Void();
40372 return resultobj;
40373 fail:
40374 return NULL;
40375 }
40376
40377
40378 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40379 PyObject *resultobj = 0;
40380 wxWindow *arg1 = (wxWindow *) 0 ;
40381 int arg2 ;
40382 bool result;
40383 void *argp1 = 0 ;
40384 int res1 = 0 ;
40385 int val2 ;
40386 int ecode2 = 0 ;
40387 PyObject * obj0 = 0 ;
40388 PyObject * obj1 = 0 ;
40389 char * kwnames[] = {
40390 (char *) "self",(char *) "lines", NULL
40391 };
40392
40393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
40394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40395 if (!SWIG_IsOK(res1)) {
40396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
40397 }
40398 arg1 = reinterpret_cast< wxWindow * >(argp1);
40399 ecode2 = SWIG_AsVal_int(obj1, &val2);
40400 if (!SWIG_IsOK(ecode2)) {
40401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
40402 }
40403 arg2 = static_cast< int >(val2);
40404 {
40405 PyThreadState* __tstate = wxPyBeginAllowThreads();
40406 result = (bool)(arg1)->ScrollLines(arg2);
40407 wxPyEndAllowThreads(__tstate);
40408 if (PyErr_Occurred()) SWIG_fail;
40409 }
40410 {
40411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40412 }
40413 return resultobj;
40414 fail:
40415 return NULL;
40416 }
40417
40418
40419 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40420 PyObject *resultobj = 0;
40421 wxWindow *arg1 = (wxWindow *) 0 ;
40422 int arg2 ;
40423 bool result;
40424 void *argp1 = 0 ;
40425 int res1 = 0 ;
40426 int val2 ;
40427 int ecode2 = 0 ;
40428 PyObject * obj0 = 0 ;
40429 PyObject * obj1 = 0 ;
40430 char * kwnames[] = {
40431 (char *) "self",(char *) "pages", NULL
40432 };
40433
40434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
40435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40436 if (!SWIG_IsOK(res1)) {
40437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
40438 }
40439 arg1 = reinterpret_cast< wxWindow * >(argp1);
40440 ecode2 = SWIG_AsVal_int(obj1, &val2);
40441 if (!SWIG_IsOK(ecode2)) {
40442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
40443 }
40444 arg2 = static_cast< int >(val2);
40445 {
40446 PyThreadState* __tstate = wxPyBeginAllowThreads();
40447 result = (bool)(arg1)->ScrollPages(arg2);
40448 wxPyEndAllowThreads(__tstate);
40449 if (PyErr_Occurred()) SWIG_fail;
40450 }
40451 {
40452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40453 }
40454 return resultobj;
40455 fail:
40456 return NULL;
40457 }
40458
40459
40460 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40461 PyObject *resultobj = 0;
40462 wxWindow *arg1 = (wxWindow *) 0 ;
40463 bool result;
40464 void *argp1 = 0 ;
40465 int res1 = 0 ;
40466 PyObject *swig_obj[1] ;
40467
40468 if (!args) SWIG_fail;
40469 swig_obj[0] = args;
40470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40471 if (!SWIG_IsOK(res1)) {
40472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40473 }
40474 arg1 = reinterpret_cast< wxWindow * >(argp1);
40475 {
40476 PyThreadState* __tstate = wxPyBeginAllowThreads();
40477 result = (bool)(arg1)->LineUp();
40478 wxPyEndAllowThreads(__tstate);
40479 if (PyErr_Occurred()) SWIG_fail;
40480 }
40481 {
40482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40483 }
40484 return resultobj;
40485 fail:
40486 return NULL;
40487 }
40488
40489
40490 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40491 PyObject *resultobj = 0;
40492 wxWindow *arg1 = (wxWindow *) 0 ;
40493 bool result;
40494 void *argp1 = 0 ;
40495 int res1 = 0 ;
40496 PyObject *swig_obj[1] ;
40497
40498 if (!args) SWIG_fail;
40499 swig_obj[0] = args;
40500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40501 if (!SWIG_IsOK(res1)) {
40502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40503 }
40504 arg1 = reinterpret_cast< wxWindow * >(argp1);
40505 {
40506 PyThreadState* __tstate = wxPyBeginAllowThreads();
40507 result = (bool)(arg1)->LineDown();
40508 wxPyEndAllowThreads(__tstate);
40509 if (PyErr_Occurred()) SWIG_fail;
40510 }
40511 {
40512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40513 }
40514 return resultobj;
40515 fail:
40516 return NULL;
40517 }
40518
40519
40520 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40521 PyObject *resultobj = 0;
40522 wxWindow *arg1 = (wxWindow *) 0 ;
40523 bool result;
40524 void *argp1 = 0 ;
40525 int res1 = 0 ;
40526 PyObject *swig_obj[1] ;
40527
40528 if (!args) SWIG_fail;
40529 swig_obj[0] = args;
40530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40531 if (!SWIG_IsOK(res1)) {
40532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40533 }
40534 arg1 = reinterpret_cast< wxWindow * >(argp1);
40535 {
40536 PyThreadState* __tstate = wxPyBeginAllowThreads();
40537 result = (bool)(arg1)->PageUp();
40538 wxPyEndAllowThreads(__tstate);
40539 if (PyErr_Occurred()) SWIG_fail;
40540 }
40541 {
40542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40543 }
40544 return resultobj;
40545 fail:
40546 return NULL;
40547 }
40548
40549
40550 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40551 PyObject *resultobj = 0;
40552 wxWindow *arg1 = (wxWindow *) 0 ;
40553 bool result;
40554 void *argp1 = 0 ;
40555 int res1 = 0 ;
40556 PyObject *swig_obj[1] ;
40557
40558 if (!args) SWIG_fail;
40559 swig_obj[0] = args;
40560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40561 if (!SWIG_IsOK(res1)) {
40562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40563 }
40564 arg1 = reinterpret_cast< wxWindow * >(argp1);
40565 {
40566 PyThreadState* __tstate = wxPyBeginAllowThreads();
40567 result = (bool)(arg1)->PageDown();
40568 wxPyEndAllowThreads(__tstate);
40569 if (PyErr_Occurred()) SWIG_fail;
40570 }
40571 {
40572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40573 }
40574 return resultobj;
40575 fail:
40576 return NULL;
40577 }
40578
40579
40580 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40581 PyObject *resultobj = 0;
40582 wxWindow *arg1 = (wxWindow *) 0 ;
40583 wxString *arg2 = 0 ;
40584 void *argp1 = 0 ;
40585 int res1 = 0 ;
40586 bool temp2 = false ;
40587 PyObject * obj0 = 0 ;
40588 PyObject * obj1 = 0 ;
40589 char * kwnames[] = {
40590 (char *) "self",(char *) "text", NULL
40591 };
40592
40593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
40594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40595 if (!SWIG_IsOK(res1)) {
40596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
40597 }
40598 arg1 = reinterpret_cast< wxWindow * >(argp1);
40599 {
40600 arg2 = wxString_in_helper(obj1);
40601 if (arg2 == NULL) SWIG_fail;
40602 temp2 = true;
40603 }
40604 {
40605 PyThreadState* __tstate = wxPyBeginAllowThreads();
40606 (arg1)->SetHelpText((wxString const &)*arg2);
40607 wxPyEndAllowThreads(__tstate);
40608 if (PyErr_Occurred()) SWIG_fail;
40609 }
40610 resultobj = SWIG_Py_Void();
40611 {
40612 if (temp2)
40613 delete arg2;
40614 }
40615 return resultobj;
40616 fail:
40617 {
40618 if (temp2)
40619 delete arg2;
40620 }
40621 return NULL;
40622 }
40623
40624
40625 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40626 PyObject *resultobj = 0;
40627 wxWindow *arg1 = (wxWindow *) 0 ;
40628 wxString *arg2 = 0 ;
40629 void *argp1 = 0 ;
40630 int res1 = 0 ;
40631 bool temp2 = false ;
40632 PyObject * obj0 = 0 ;
40633 PyObject * obj1 = 0 ;
40634 char * kwnames[] = {
40635 (char *) "self",(char *) "text", NULL
40636 };
40637
40638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
40639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40640 if (!SWIG_IsOK(res1)) {
40641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
40642 }
40643 arg1 = reinterpret_cast< wxWindow * >(argp1);
40644 {
40645 arg2 = wxString_in_helper(obj1);
40646 if (arg2 == NULL) SWIG_fail;
40647 temp2 = true;
40648 }
40649 {
40650 PyThreadState* __tstate = wxPyBeginAllowThreads();
40651 (arg1)->SetHelpTextForId((wxString const &)*arg2);
40652 wxPyEndAllowThreads(__tstate);
40653 if (PyErr_Occurred()) SWIG_fail;
40654 }
40655 resultobj = SWIG_Py_Void();
40656 {
40657 if (temp2)
40658 delete arg2;
40659 }
40660 return resultobj;
40661 fail:
40662 {
40663 if (temp2)
40664 delete arg2;
40665 }
40666 return NULL;
40667 }
40668
40669
40670 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40671 PyObject *resultobj = 0;
40672 wxWindow *arg1 = (wxWindow *) 0 ;
40673 wxPoint *arg2 = 0 ;
40674 wxHelpEvent::Origin arg3 ;
40675 wxString result;
40676 void *argp1 = 0 ;
40677 int res1 = 0 ;
40678 wxPoint temp2 ;
40679 void *argp3 ;
40680 int res3 = 0 ;
40681 PyObject * obj0 = 0 ;
40682 PyObject * obj1 = 0 ;
40683 PyObject * obj2 = 0 ;
40684 char * kwnames[] = {
40685 (char *) "self",(char *) "pt",(char *) "origin", NULL
40686 };
40687
40688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40690 if (!SWIG_IsOK(res1)) {
40691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
40692 }
40693 arg1 = reinterpret_cast< wxWindow * >(argp1);
40694 {
40695 arg2 = &temp2;
40696 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40697 }
40698 {
40699 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
40700 if (!SWIG_IsOK(res3)) {
40701 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40702 }
40703 if (!argp3) {
40704 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40705 } else {
40706 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
40707 arg3 = *temp;
40708 if (SWIG_IsNewObj(res3)) delete temp;
40709 }
40710 }
40711 {
40712 PyThreadState* __tstate = wxPyBeginAllowThreads();
40713 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
40714 wxPyEndAllowThreads(__tstate);
40715 if (PyErr_Occurred()) SWIG_fail;
40716 }
40717 {
40718 #if wxUSE_UNICODE
40719 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40720 #else
40721 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40722 #endif
40723 }
40724 return resultobj;
40725 fail:
40726 return NULL;
40727 }
40728
40729
40730 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40731 PyObject *resultobj = 0;
40732 wxWindow *arg1 = (wxWindow *) 0 ;
40733 wxString result;
40734 void *argp1 = 0 ;
40735 int res1 = 0 ;
40736 PyObject *swig_obj[1] ;
40737
40738 if (!args) SWIG_fail;
40739 swig_obj[0] = args;
40740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40741 if (!SWIG_IsOK(res1)) {
40742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
40743 }
40744 arg1 = reinterpret_cast< wxWindow * >(argp1);
40745 {
40746 PyThreadState* __tstate = wxPyBeginAllowThreads();
40747 result = ((wxWindow const *)arg1)->GetHelpText();
40748 wxPyEndAllowThreads(__tstate);
40749 if (PyErr_Occurred()) SWIG_fail;
40750 }
40751 {
40752 #if wxUSE_UNICODE
40753 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40754 #else
40755 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40756 #endif
40757 }
40758 return resultobj;
40759 fail:
40760 return NULL;
40761 }
40762
40763
40764 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40765 PyObject *resultobj = 0;
40766 wxWindow *arg1 = (wxWindow *) 0 ;
40767 wxString *arg2 = 0 ;
40768 void *argp1 = 0 ;
40769 int res1 = 0 ;
40770 bool temp2 = false ;
40771 PyObject * obj0 = 0 ;
40772 PyObject * obj1 = 0 ;
40773 char * kwnames[] = {
40774 (char *) "self",(char *) "tip", NULL
40775 };
40776
40777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
40778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40779 if (!SWIG_IsOK(res1)) {
40780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
40781 }
40782 arg1 = reinterpret_cast< wxWindow * >(argp1);
40783 {
40784 arg2 = wxString_in_helper(obj1);
40785 if (arg2 == NULL) SWIG_fail;
40786 temp2 = true;
40787 }
40788 {
40789 PyThreadState* __tstate = wxPyBeginAllowThreads();
40790 (arg1)->SetToolTip((wxString const &)*arg2);
40791 wxPyEndAllowThreads(__tstate);
40792 if (PyErr_Occurred()) SWIG_fail;
40793 }
40794 resultobj = SWIG_Py_Void();
40795 {
40796 if (temp2)
40797 delete arg2;
40798 }
40799 return resultobj;
40800 fail:
40801 {
40802 if (temp2)
40803 delete arg2;
40804 }
40805 return NULL;
40806 }
40807
40808
40809 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40810 PyObject *resultobj = 0;
40811 wxWindow *arg1 = (wxWindow *) 0 ;
40812 wxToolTip *arg2 = (wxToolTip *) 0 ;
40813 void *argp1 = 0 ;
40814 int res1 = 0 ;
40815 int res2 = 0 ;
40816 PyObject * obj0 = 0 ;
40817 PyObject * obj1 = 0 ;
40818 char * kwnames[] = {
40819 (char *) "self",(char *) "tip", NULL
40820 };
40821
40822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
40823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40824 if (!SWIG_IsOK(res1)) {
40825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
40826 }
40827 arg1 = reinterpret_cast< wxWindow * >(argp1);
40828 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
40829 if (!SWIG_IsOK(res2)) {
40830 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
40831 }
40832 {
40833 PyThreadState* __tstate = wxPyBeginAllowThreads();
40834 (arg1)->SetToolTip(arg2);
40835 wxPyEndAllowThreads(__tstate);
40836 if (PyErr_Occurred()) SWIG_fail;
40837 }
40838 resultobj = SWIG_Py_Void();
40839 return resultobj;
40840 fail:
40841 return NULL;
40842 }
40843
40844
40845 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40846 PyObject *resultobj = 0;
40847 wxWindow *arg1 = (wxWindow *) 0 ;
40848 wxToolTip *result = 0 ;
40849 void *argp1 = 0 ;
40850 int res1 = 0 ;
40851 PyObject *swig_obj[1] ;
40852
40853 if (!args) SWIG_fail;
40854 swig_obj[0] = args;
40855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40856 if (!SWIG_IsOK(res1)) {
40857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
40858 }
40859 arg1 = reinterpret_cast< wxWindow * >(argp1);
40860 {
40861 PyThreadState* __tstate = wxPyBeginAllowThreads();
40862 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
40863 wxPyEndAllowThreads(__tstate);
40864 if (PyErr_Occurred()) SWIG_fail;
40865 }
40866 {
40867 resultobj = wxPyMake_wxObject(result, (bool)0);
40868 }
40869 return resultobj;
40870 fail:
40871 return NULL;
40872 }
40873
40874
40875 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40876 PyObject *resultobj = 0;
40877 wxWindow *arg1 = (wxWindow *) 0 ;
40878 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
40879 void *argp1 = 0 ;
40880 int res1 = 0 ;
40881 int res2 = 0 ;
40882 PyObject * obj0 = 0 ;
40883 PyObject * obj1 = 0 ;
40884 char * kwnames[] = {
40885 (char *) "self",(char *) "dropTarget", NULL
40886 };
40887
40888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
40889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40890 if (!SWIG_IsOK(res1)) {
40891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
40892 }
40893 arg1 = reinterpret_cast< wxWindow * >(argp1);
40894 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
40895 if (!SWIG_IsOK(res2)) {
40896 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
40897 }
40898 {
40899 PyThreadState* __tstate = wxPyBeginAllowThreads();
40900 (arg1)->SetDropTarget(arg2);
40901 wxPyEndAllowThreads(__tstate);
40902 if (PyErr_Occurred()) SWIG_fail;
40903 }
40904 resultobj = SWIG_Py_Void();
40905 return resultobj;
40906 fail:
40907 return NULL;
40908 }
40909
40910
40911 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40912 PyObject *resultobj = 0;
40913 wxWindow *arg1 = (wxWindow *) 0 ;
40914 wxPyDropTarget *result = 0 ;
40915 void *argp1 = 0 ;
40916 int res1 = 0 ;
40917 PyObject *swig_obj[1] ;
40918
40919 if (!args) SWIG_fail;
40920 swig_obj[0] = args;
40921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40922 if (!SWIG_IsOK(res1)) {
40923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
40924 }
40925 arg1 = reinterpret_cast< wxWindow * >(argp1);
40926 {
40927 PyThreadState* __tstate = wxPyBeginAllowThreads();
40928 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
40929 wxPyEndAllowThreads(__tstate);
40930 if (PyErr_Occurred()) SWIG_fail;
40931 }
40932 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
40933 return resultobj;
40934 fail:
40935 return NULL;
40936 }
40937
40938
40939 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40940 PyObject *resultobj = 0;
40941 wxWindow *arg1 = (wxWindow *) 0 ;
40942 bool arg2 ;
40943 void *argp1 = 0 ;
40944 int res1 = 0 ;
40945 bool val2 ;
40946 int ecode2 = 0 ;
40947 PyObject * obj0 = 0 ;
40948 PyObject * obj1 = 0 ;
40949 char * kwnames[] = {
40950 (char *) "self",(char *) "accept", NULL
40951 };
40952
40953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
40954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40955 if (!SWIG_IsOK(res1)) {
40956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
40957 }
40958 arg1 = reinterpret_cast< wxWindow * >(argp1);
40959 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40960 if (!SWIG_IsOK(ecode2)) {
40961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
40962 }
40963 arg2 = static_cast< bool >(val2);
40964 {
40965 PyThreadState* __tstate = wxPyBeginAllowThreads();
40966 (arg1)->DragAcceptFiles(arg2);
40967 wxPyEndAllowThreads(__tstate);
40968 if (PyErr_Occurred()) SWIG_fail;
40969 }
40970 resultobj = SWIG_Py_Void();
40971 return resultobj;
40972 fail:
40973 return NULL;
40974 }
40975
40976
40977 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40978 PyObject *resultobj = 0;
40979 wxWindow *arg1 = (wxWindow *) 0 ;
40980 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
40981 void *argp1 = 0 ;
40982 int res1 = 0 ;
40983 int res2 = 0 ;
40984 PyObject * obj0 = 0 ;
40985 PyObject * obj1 = 0 ;
40986 char * kwnames[] = {
40987 (char *) "self",(char *) "constraints", NULL
40988 };
40989
40990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
40991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40992 if (!SWIG_IsOK(res1)) {
40993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
40994 }
40995 arg1 = reinterpret_cast< wxWindow * >(argp1);
40996 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
40997 if (!SWIG_IsOK(res2)) {
40998 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
40999 }
41000 {
41001 PyThreadState* __tstate = wxPyBeginAllowThreads();
41002 (arg1)->SetConstraints(arg2);
41003 wxPyEndAllowThreads(__tstate);
41004 if (PyErr_Occurred()) SWIG_fail;
41005 }
41006 resultobj = SWIG_Py_Void();
41007 return resultobj;
41008 fail:
41009 return NULL;
41010 }
41011
41012
41013 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41014 PyObject *resultobj = 0;
41015 wxWindow *arg1 = (wxWindow *) 0 ;
41016 wxLayoutConstraints *result = 0 ;
41017 void *argp1 = 0 ;
41018 int res1 = 0 ;
41019 PyObject *swig_obj[1] ;
41020
41021 if (!args) SWIG_fail;
41022 swig_obj[0] = args;
41023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41024 if (!SWIG_IsOK(res1)) {
41025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
41026 }
41027 arg1 = reinterpret_cast< wxWindow * >(argp1);
41028 {
41029 PyThreadState* __tstate = wxPyBeginAllowThreads();
41030 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
41031 wxPyEndAllowThreads(__tstate);
41032 if (PyErr_Occurred()) SWIG_fail;
41033 }
41034 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
41035 return resultobj;
41036 fail:
41037 return NULL;
41038 }
41039
41040
41041 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41042 PyObject *resultobj = 0;
41043 wxWindow *arg1 = (wxWindow *) 0 ;
41044 bool arg2 ;
41045 void *argp1 = 0 ;
41046 int res1 = 0 ;
41047 bool val2 ;
41048 int ecode2 = 0 ;
41049 PyObject * obj0 = 0 ;
41050 PyObject * obj1 = 0 ;
41051 char * kwnames[] = {
41052 (char *) "self",(char *) "autoLayout", NULL
41053 };
41054
41055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
41056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41057 if (!SWIG_IsOK(res1)) {
41058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
41059 }
41060 arg1 = reinterpret_cast< wxWindow * >(argp1);
41061 ecode2 = SWIG_AsVal_bool(obj1, &val2);
41062 if (!SWIG_IsOK(ecode2)) {
41063 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
41064 }
41065 arg2 = static_cast< bool >(val2);
41066 {
41067 PyThreadState* __tstate = wxPyBeginAllowThreads();
41068 (arg1)->SetAutoLayout(arg2);
41069 wxPyEndAllowThreads(__tstate);
41070 if (PyErr_Occurred()) SWIG_fail;
41071 }
41072 resultobj = SWIG_Py_Void();
41073 return resultobj;
41074 fail:
41075 return NULL;
41076 }
41077
41078
41079 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41080 PyObject *resultobj = 0;
41081 wxWindow *arg1 = (wxWindow *) 0 ;
41082 bool result;
41083 void *argp1 = 0 ;
41084 int res1 = 0 ;
41085 PyObject *swig_obj[1] ;
41086
41087 if (!args) SWIG_fail;
41088 swig_obj[0] = args;
41089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41090 if (!SWIG_IsOK(res1)) {
41091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
41092 }
41093 arg1 = reinterpret_cast< wxWindow * >(argp1);
41094 {
41095 PyThreadState* __tstate = wxPyBeginAllowThreads();
41096 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
41097 wxPyEndAllowThreads(__tstate);
41098 if (PyErr_Occurred()) SWIG_fail;
41099 }
41100 {
41101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41102 }
41103 return resultobj;
41104 fail:
41105 return NULL;
41106 }
41107
41108
41109 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41110 PyObject *resultobj = 0;
41111 wxWindow *arg1 = (wxWindow *) 0 ;
41112 bool result;
41113 void *argp1 = 0 ;
41114 int res1 = 0 ;
41115 PyObject *swig_obj[1] ;
41116
41117 if (!args) SWIG_fail;
41118 swig_obj[0] = args;
41119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41120 if (!SWIG_IsOK(res1)) {
41121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
41122 }
41123 arg1 = reinterpret_cast< wxWindow * >(argp1);
41124 {
41125 PyThreadState* __tstate = wxPyBeginAllowThreads();
41126 result = (bool)(arg1)->Layout();
41127 wxPyEndAllowThreads(__tstate);
41128 if (PyErr_Occurred()) SWIG_fail;
41129 }
41130 {
41131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41132 }
41133 return resultobj;
41134 fail:
41135 return NULL;
41136 }
41137
41138
41139 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41140 PyObject *resultobj = 0;
41141 wxWindow *arg1 = (wxWindow *) 0 ;
41142 wxSizer *arg2 = (wxSizer *) 0 ;
41143 bool arg3 = (bool) true ;
41144 void *argp1 = 0 ;
41145 int res1 = 0 ;
41146 int res2 = 0 ;
41147 bool val3 ;
41148 int ecode3 = 0 ;
41149 PyObject * obj0 = 0 ;
41150 PyObject * obj1 = 0 ;
41151 PyObject * obj2 = 0 ;
41152 char * kwnames[] = {
41153 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
41154 };
41155
41156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41158 if (!SWIG_IsOK(res1)) {
41159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
41160 }
41161 arg1 = reinterpret_cast< wxWindow * >(argp1);
41162 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
41163 if (!SWIG_IsOK(res2)) {
41164 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
41165 }
41166 if (obj2) {
41167 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41168 if (!SWIG_IsOK(ecode3)) {
41169 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
41170 }
41171 arg3 = static_cast< bool >(val3);
41172 }
41173 {
41174 PyThreadState* __tstate = wxPyBeginAllowThreads();
41175 (arg1)->SetSizer(arg2,arg3);
41176 wxPyEndAllowThreads(__tstate);
41177 if (PyErr_Occurred()) SWIG_fail;
41178 }
41179 resultobj = SWIG_Py_Void();
41180 return resultobj;
41181 fail:
41182 return NULL;
41183 }
41184
41185
41186 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41187 PyObject *resultobj = 0;
41188 wxWindow *arg1 = (wxWindow *) 0 ;
41189 wxSizer *arg2 = (wxSizer *) 0 ;
41190 bool arg3 = (bool) true ;
41191 void *argp1 = 0 ;
41192 int res1 = 0 ;
41193 int res2 = 0 ;
41194 bool val3 ;
41195 int ecode3 = 0 ;
41196 PyObject * obj0 = 0 ;
41197 PyObject * obj1 = 0 ;
41198 PyObject * obj2 = 0 ;
41199 char * kwnames[] = {
41200 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
41201 };
41202
41203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41205 if (!SWIG_IsOK(res1)) {
41206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
41207 }
41208 arg1 = reinterpret_cast< wxWindow * >(argp1);
41209 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
41210 if (!SWIG_IsOK(res2)) {
41211 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
41212 }
41213 if (obj2) {
41214 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41215 if (!SWIG_IsOK(ecode3)) {
41216 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
41217 }
41218 arg3 = static_cast< bool >(val3);
41219 }
41220 {
41221 PyThreadState* __tstate = wxPyBeginAllowThreads();
41222 (arg1)->SetSizerAndFit(arg2,arg3);
41223 wxPyEndAllowThreads(__tstate);
41224 if (PyErr_Occurred()) SWIG_fail;
41225 }
41226 resultobj = SWIG_Py_Void();
41227 return resultobj;
41228 fail:
41229 return NULL;
41230 }
41231
41232
41233 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41234 PyObject *resultobj = 0;
41235 wxWindow *arg1 = (wxWindow *) 0 ;
41236 wxSizer *result = 0 ;
41237 void *argp1 = 0 ;
41238 int res1 = 0 ;
41239 PyObject *swig_obj[1] ;
41240
41241 if (!args) SWIG_fail;
41242 swig_obj[0] = args;
41243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41244 if (!SWIG_IsOK(res1)) {
41245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
41246 }
41247 arg1 = reinterpret_cast< wxWindow * >(argp1);
41248 {
41249 PyThreadState* __tstate = wxPyBeginAllowThreads();
41250 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
41251 wxPyEndAllowThreads(__tstate);
41252 if (PyErr_Occurred()) SWIG_fail;
41253 }
41254 {
41255 resultobj = wxPyMake_wxObject(result, (bool)0);
41256 }
41257 return resultobj;
41258 fail:
41259 return NULL;
41260 }
41261
41262
41263 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41264 PyObject *resultobj = 0;
41265 wxWindow *arg1 = (wxWindow *) 0 ;
41266 wxSizer *arg2 = (wxSizer *) 0 ;
41267 void *argp1 = 0 ;
41268 int res1 = 0 ;
41269 void *argp2 = 0 ;
41270 int res2 = 0 ;
41271 PyObject * obj0 = 0 ;
41272 PyObject * obj1 = 0 ;
41273 char * kwnames[] = {
41274 (char *) "self",(char *) "sizer", NULL
41275 };
41276
41277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
41278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41279 if (!SWIG_IsOK(res1)) {
41280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
41281 }
41282 arg1 = reinterpret_cast< wxWindow * >(argp1);
41283 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
41284 if (!SWIG_IsOK(res2)) {
41285 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
41286 }
41287 arg2 = reinterpret_cast< wxSizer * >(argp2);
41288 {
41289 PyThreadState* __tstate = wxPyBeginAllowThreads();
41290 (arg1)->SetContainingSizer(arg2);
41291 wxPyEndAllowThreads(__tstate);
41292 if (PyErr_Occurred()) SWIG_fail;
41293 }
41294 resultobj = SWIG_Py_Void();
41295 return resultobj;
41296 fail:
41297 return NULL;
41298 }
41299
41300
41301 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41302 PyObject *resultobj = 0;
41303 wxWindow *arg1 = (wxWindow *) 0 ;
41304 wxSizer *result = 0 ;
41305 void *argp1 = 0 ;
41306 int res1 = 0 ;
41307 PyObject *swig_obj[1] ;
41308
41309 if (!args) SWIG_fail;
41310 swig_obj[0] = args;
41311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41312 if (!SWIG_IsOK(res1)) {
41313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
41314 }
41315 arg1 = reinterpret_cast< wxWindow * >(argp1);
41316 {
41317 PyThreadState* __tstate = wxPyBeginAllowThreads();
41318 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
41319 wxPyEndAllowThreads(__tstate);
41320 if (PyErr_Occurred()) SWIG_fail;
41321 }
41322 {
41323 resultobj = wxPyMake_wxObject(result, (bool)0);
41324 }
41325 return resultobj;
41326 fail:
41327 return NULL;
41328 }
41329
41330
41331 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41332 PyObject *resultobj = 0;
41333 wxWindow *arg1 = (wxWindow *) 0 ;
41334 void *argp1 = 0 ;
41335 int res1 = 0 ;
41336 PyObject *swig_obj[1] ;
41337
41338 if (!args) SWIG_fail;
41339 swig_obj[0] = args;
41340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41341 if (!SWIG_IsOK(res1)) {
41342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
41343 }
41344 arg1 = reinterpret_cast< wxWindow * >(argp1);
41345 {
41346 PyThreadState* __tstate = wxPyBeginAllowThreads();
41347 (arg1)->InheritAttributes();
41348 wxPyEndAllowThreads(__tstate);
41349 if (PyErr_Occurred()) SWIG_fail;
41350 }
41351 resultobj = SWIG_Py_Void();
41352 return resultobj;
41353 fail:
41354 return NULL;
41355 }
41356
41357
41358 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41359 PyObject *resultobj = 0;
41360 wxWindow *arg1 = (wxWindow *) 0 ;
41361 bool result;
41362 void *argp1 = 0 ;
41363 int res1 = 0 ;
41364 PyObject *swig_obj[1] ;
41365
41366 if (!args) SWIG_fail;
41367 swig_obj[0] = args;
41368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41369 if (!SWIG_IsOK(res1)) {
41370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
41371 }
41372 arg1 = reinterpret_cast< wxWindow * >(argp1);
41373 {
41374 PyThreadState* __tstate = wxPyBeginAllowThreads();
41375 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
41376 wxPyEndAllowThreads(__tstate);
41377 if (PyErr_Occurred()) SWIG_fail;
41378 }
41379 {
41380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41381 }
41382 return resultobj;
41383 fail:
41384 return NULL;
41385 }
41386
41387
41388 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41389 PyObject *resultobj = 0;
41390 wxWindow *arg1 = (wxWindow *) 0 ;
41391 bool result;
41392 void *argp1 = 0 ;
41393 int res1 = 0 ;
41394 PyObject *swig_obj[1] ;
41395
41396 if (!args) SWIG_fail;
41397 swig_obj[0] = args;
41398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41399 if (!SWIG_IsOK(res1)) {
41400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41401 }
41402 arg1 = reinterpret_cast< wxWindow * >(argp1);
41403 {
41404 PyThreadState* __tstate = wxPyBeginAllowThreads();
41405 result = (bool)(arg1)->CanSetTransparent();
41406 wxPyEndAllowThreads(__tstate);
41407 if (PyErr_Occurred()) SWIG_fail;
41408 }
41409 {
41410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41411 }
41412 return resultobj;
41413 fail:
41414 return NULL;
41415 }
41416
41417
41418 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41419 PyObject *resultobj = 0;
41420 wxWindow *arg1 = (wxWindow *) 0 ;
41421 byte arg2 ;
41422 bool result;
41423 void *argp1 = 0 ;
41424 int res1 = 0 ;
41425 unsigned char val2 ;
41426 int ecode2 = 0 ;
41427 PyObject * obj0 = 0 ;
41428 PyObject * obj1 = 0 ;
41429 char * kwnames[] = {
41430 (char *) "self",(char *) "alpha", NULL
41431 };
41432
41433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
41434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41435 if (!SWIG_IsOK(res1)) {
41436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41437 }
41438 arg1 = reinterpret_cast< wxWindow * >(argp1);
41439 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
41440 if (!SWIG_IsOK(ecode2)) {
41441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
41442 }
41443 arg2 = static_cast< byte >(val2);
41444 {
41445 PyThreadState* __tstate = wxPyBeginAllowThreads();
41446 result = (bool)(arg1)->SetTransparent(arg2);
41447 wxPyEndAllowThreads(__tstate);
41448 if (PyErr_Occurred()) SWIG_fail;
41449 }
41450 {
41451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41452 }
41453 return resultobj;
41454 fail:
41455 return NULL;
41456 }
41457
41458
41459 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41460 PyObject *obj;
41461 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41462 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
41463 return SWIG_Py_Void();
41464 }
41465
41466 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41467 return SWIG_Python_InitShadowInstance(args);
41468 }
41469
41470 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41471 PyObject *resultobj = 0;
41472 long arg1 ;
41473 wxWindow *arg2 = (wxWindow *) NULL ;
41474 wxWindow *result = 0 ;
41475 long val1 ;
41476 int ecode1 = 0 ;
41477 void *argp2 = 0 ;
41478 int res2 = 0 ;
41479 PyObject * obj0 = 0 ;
41480 PyObject * obj1 = 0 ;
41481 char * kwnames[] = {
41482 (char *) "id",(char *) "parent", NULL
41483 };
41484
41485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
41486 ecode1 = SWIG_AsVal_long(obj0, &val1);
41487 if (!SWIG_IsOK(ecode1)) {
41488 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
41489 }
41490 arg1 = static_cast< long >(val1);
41491 if (obj1) {
41492 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41493 if (!SWIG_IsOK(res2)) {
41494 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
41495 }
41496 arg2 = reinterpret_cast< wxWindow * >(argp2);
41497 }
41498 {
41499 if (!wxPyCheckForApp()) SWIG_fail;
41500 PyThreadState* __tstate = wxPyBeginAllowThreads();
41501 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
41502 wxPyEndAllowThreads(__tstate);
41503 if (PyErr_Occurred()) SWIG_fail;
41504 }
41505 {
41506 resultobj = wxPyMake_wxObject(result, 0);
41507 }
41508 return resultobj;
41509 fail:
41510 return NULL;
41511 }
41512
41513
41514 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41515 PyObject *resultobj = 0;
41516 wxString *arg1 = 0 ;
41517 wxWindow *arg2 = (wxWindow *) NULL ;
41518 wxWindow *result = 0 ;
41519 bool temp1 = false ;
41520 void *argp2 = 0 ;
41521 int res2 = 0 ;
41522 PyObject * obj0 = 0 ;
41523 PyObject * obj1 = 0 ;
41524 char * kwnames[] = {
41525 (char *) "name",(char *) "parent", NULL
41526 };
41527
41528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
41529 {
41530 arg1 = wxString_in_helper(obj0);
41531 if (arg1 == NULL) SWIG_fail;
41532 temp1 = true;
41533 }
41534 if (obj1) {
41535 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41536 if (!SWIG_IsOK(res2)) {
41537 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
41538 }
41539 arg2 = reinterpret_cast< wxWindow * >(argp2);
41540 }
41541 {
41542 if (!wxPyCheckForApp()) SWIG_fail;
41543 PyThreadState* __tstate = wxPyBeginAllowThreads();
41544 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
41545 wxPyEndAllowThreads(__tstate);
41546 if (PyErr_Occurred()) SWIG_fail;
41547 }
41548 {
41549 resultobj = wxPyMake_wxObject(result, 0);
41550 }
41551 {
41552 if (temp1)
41553 delete arg1;
41554 }
41555 return resultobj;
41556 fail:
41557 {
41558 if (temp1)
41559 delete arg1;
41560 }
41561 return NULL;
41562 }
41563
41564
41565 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41566 PyObject *resultobj = 0;
41567 wxString *arg1 = 0 ;
41568 wxWindow *arg2 = (wxWindow *) NULL ;
41569 wxWindow *result = 0 ;
41570 bool temp1 = false ;
41571 void *argp2 = 0 ;
41572 int res2 = 0 ;
41573 PyObject * obj0 = 0 ;
41574 PyObject * obj1 = 0 ;
41575 char * kwnames[] = {
41576 (char *) "label",(char *) "parent", NULL
41577 };
41578
41579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41580 {
41581 arg1 = wxString_in_helper(obj0);
41582 if (arg1 == NULL) SWIG_fail;
41583 temp1 = true;
41584 }
41585 if (obj1) {
41586 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41587 if (!SWIG_IsOK(res2)) {
41588 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
41589 }
41590 arg2 = reinterpret_cast< wxWindow * >(argp2);
41591 }
41592 {
41593 if (!wxPyCheckForApp()) SWIG_fail;
41594 PyThreadState* __tstate = wxPyBeginAllowThreads();
41595 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
41596 wxPyEndAllowThreads(__tstate);
41597 if (PyErr_Occurred()) SWIG_fail;
41598 }
41599 {
41600 resultobj = wxPyMake_wxObject(result, 0);
41601 }
41602 {
41603 if (temp1)
41604 delete arg1;
41605 }
41606 return resultobj;
41607 fail:
41608 {
41609 if (temp1)
41610 delete arg1;
41611 }
41612 return NULL;
41613 }
41614
41615
41616 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41617 PyObject *resultobj = 0;
41618 wxWindow *arg1 = (wxWindow *) 0 ;
41619 unsigned long arg2 ;
41620 wxWindow *result = 0 ;
41621 void *argp1 = 0 ;
41622 int res1 = 0 ;
41623 unsigned long val2 ;
41624 int ecode2 = 0 ;
41625 PyObject * obj0 = 0 ;
41626 PyObject * obj1 = 0 ;
41627 char * kwnames[] = {
41628 (char *) "parent",(char *) "_hWnd", NULL
41629 };
41630
41631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
41632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41633 if (!SWIG_IsOK(res1)) {
41634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
41635 }
41636 arg1 = reinterpret_cast< wxWindow * >(argp1);
41637 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
41638 if (!SWIG_IsOK(ecode2)) {
41639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
41640 }
41641 arg2 = static_cast< unsigned long >(val2);
41642 {
41643 if (!wxPyCheckForApp()) SWIG_fail;
41644 PyThreadState* __tstate = wxPyBeginAllowThreads();
41645 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
41646 wxPyEndAllowThreads(__tstate);
41647 if (PyErr_Occurred()) SWIG_fail;
41648 }
41649 {
41650 resultobj = wxPyMake_wxObject(result, 0);
41651 }
41652 return resultobj;
41653 fail:
41654 return NULL;
41655 }
41656
41657
41658 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41659 PyObject *resultobj = 0;
41660 PyObject *result = 0 ;
41661
41662 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
41663 {
41664 PyThreadState* __tstate = wxPyBeginAllowThreads();
41665 result = (PyObject *)GetTopLevelWindows();
41666 wxPyEndAllowThreads(__tstate);
41667 if (PyErr_Occurred()) SWIG_fail;
41668 }
41669 resultobj = result;
41670 return resultobj;
41671 fail:
41672 return NULL;
41673 }
41674
41675
41676 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41677 PyObject *resultobj = 0;
41678 wxValidator *result = 0 ;
41679
41680 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
41681 {
41682 PyThreadState* __tstate = wxPyBeginAllowThreads();
41683 result = (wxValidator *)new wxValidator();
41684 wxPyEndAllowThreads(__tstate);
41685 if (PyErr_Occurred()) SWIG_fail;
41686 }
41687 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
41688 return resultobj;
41689 fail:
41690 return NULL;
41691 }
41692
41693
41694 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41695 PyObject *resultobj = 0;
41696 wxValidator *arg1 = (wxValidator *) 0 ;
41697 wxValidator *result = 0 ;
41698 void *argp1 = 0 ;
41699 int res1 = 0 ;
41700 PyObject *swig_obj[1] ;
41701
41702 if (!args) SWIG_fail;
41703 swig_obj[0] = args;
41704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41705 if (!SWIG_IsOK(res1)) {
41706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
41707 }
41708 arg1 = reinterpret_cast< wxValidator * >(argp1);
41709 {
41710 PyThreadState* __tstate = wxPyBeginAllowThreads();
41711 result = (wxValidator *)(arg1)->Clone();
41712 wxPyEndAllowThreads(__tstate);
41713 if (PyErr_Occurred()) SWIG_fail;
41714 }
41715 {
41716 resultobj = wxPyMake_wxObject(result, 0);
41717 }
41718 return resultobj;
41719 fail:
41720 return NULL;
41721 }
41722
41723
41724 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41725 PyObject *resultobj = 0;
41726 wxValidator *arg1 = (wxValidator *) 0 ;
41727 wxWindow *arg2 = (wxWindow *) 0 ;
41728 bool result;
41729 void *argp1 = 0 ;
41730 int res1 = 0 ;
41731 void *argp2 = 0 ;
41732 int res2 = 0 ;
41733 PyObject * obj0 = 0 ;
41734 PyObject * obj1 = 0 ;
41735 char * kwnames[] = {
41736 (char *) "self",(char *) "parent", NULL
41737 };
41738
41739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
41740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41741 if (!SWIG_IsOK(res1)) {
41742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
41743 }
41744 arg1 = reinterpret_cast< wxValidator * >(argp1);
41745 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41746 if (!SWIG_IsOK(res2)) {
41747 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
41748 }
41749 arg2 = reinterpret_cast< wxWindow * >(argp2);
41750 {
41751 PyThreadState* __tstate = wxPyBeginAllowThreads();
41752 result = (bool)(arg1)->Validate(arg2);
41753 wxPyEndAllowThreads(__tstate);
41754 if (PyErr_Occurred()) SWIG_fail;
41755 }
41756 {
41757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41758 }
41759 return resultobj;
41760 fail:
41761 return NULL;
41762 }
41763
41764
41765 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41766 PyObject *resultobj = 0;
41767 wxValidator *arg1 = (wxValidator *) 0 ;
41768 bool result;
41769 void *argp1 = 0 ;
41770 int res1 = 0 ;
41771 PyObject *swig_obj[1] ;
41772
41773 if (!args) SWIG_fail;
41774 swig_obj[0] = args;
41775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41776 if (!SWIG_IsOK(res1)) {
41777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41778 }
41779 arg1 = reinterpret_cast< wxValidator * >(argp1);
41780 {
41781 PyThreadState* __tstate = wxPyBeginAllowThreads();
41782 result = (bool)(arg1)->TransferToWindow();
41783 wxPyEndAllowThreads(__tstate);
41784 if (PyErr_Occurred()) SWIG_fail;
41785 }
41786 {
41787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41788 }
41789 return resultobj;
41790 fail:
41791 return NULL;
41792 }
41793
41794
41795 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41796 PyObject *resultobj = 0;
41797 wxValidator *arg1 = (wxValidator *) 0 ;
41798 bool result;
41799 void *argp1 = 0 ;
41800 int res1 = 0 ;
41801 PyObject *swig_obj[1] ;
41802
41803 if (!args) SWIG_fail;
41804 swig_obj[0] = args;
41805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41806 if (!SWIG_IsOK(res1)) {
41807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41808 }
41809 arg1 = reinterpret_cast< wxValidator * >(argp1);
41810 {
41811 PyThreadState* __tstate = wxPyBeginAllowThreads();
41812 result = (bool)(arg1)->TransferFromWindow();
41813 wxPyEndAllowThreads(__tstate);
41814 if (PyErr_Occurred()) SWIG_fail;
41815 }
41816 {
41817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41818 }
41819 return resultobj;
41820 fail:
41821 return NULL;
41822 }
41823
41824
41825 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41826 PyObject *resultobj = 0;
41827 wxValidator *arg1 = (wxValidator *) 0 ;
41828 wxWindow *result = 0 ;
41829 void *argp1 = 0 ;
41830 int res1 = 0 ;
41831 PyObject *swig_obj[1] ;
41832
41833 if (!args) SWIG_fail;
41834 swig_obj[0] = args;
41835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41836 if (!SWIG_IsOK(res1)) {
41837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41838 }
41839 arg1 = reinterpret_cast< wxValidator * >(argp1);
41840 {
41841 PyThreadState* __tstate = wxPyBeginAllowThreads();
41842 result = (wxWindow *)(arg1)->GetWindow();
41843 wxPyEndAllowThreads(__tstate);
41844 if (PyErr_Occurred()) SWIG_fail;
41845 }
41846 {
41847 resultobj = wxPyMake_wxObject(result, 0);
41848 }
41849 return resultobj;
41850 fail:
41851 return NULL;
41852 }
41853
41854
41855 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41856 PyObject *resultobj = 0;
41857 wxValidator *arg1 = (wxValidator *) 0 ;
41858 wxWindow *arg2 = (wxWindow *) 0 ;
41859 void *argp1 = 0 ;
41860 int res1 = 0 ;
41861 void *argp2 = 0 ;
41862 int res2 = 0 ;
41863 PyObject * obj0 = 0 ;
41864 PyObject * obj1 = 0 ;
41865 char * kwnames[] = {
41866 (char *) "self",(char *) "window", NULL
41867 };
41868
41869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41871 if (!SWIG_IsOK(res1)) {
41872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41873 }
41874 arg1 = reinterpret_cast< wxValidator * >(argp1);
41875 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41876 if (!SWIG_IsOK(res2)) {
41877 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41878 }
41879 arg2 = reinterpret_cast< wxWindow * >(argp2);
41880 {
41881 PyThreadState* __tstate = wxPyBeginAllowThreads();
41882 (arg1)->SetWindow(arg2);
41883 wxPyEndAllowThreads(__tstate);
41884 if (PyErr_Occurred()) SWIG_fail;
41885 }
41886 resultobj = SWIG_Py_Void();
41887 return resultobj;
41888 fail:
41889 return NULL;
41890 }
41891
41892
41893 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41894 PyObject *resultobj = 0;
41895 bool result;
41896
41897 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
41898 {
41899 PyThreadState* __tstate = wxPyBeginAllowThreads();
41900 result = (bool)wxValidator::IsSilent();
41901 wxPyEndAllowThreads(__tstate);
41902 if (PyErr_Occurred()) SWIG_fail;
41903 }
41904 {
41905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41906 }
41907 return resultobj;
41908 fail:
41909 return NULL;
41910 }
41911
41912
41913 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41914 PyObject *resultobj = 0;
41915 int arg1 = (int) true ;
41916 int val1 ;
41917 int ecode1 = 0 ;
41918 PyObject * obj0 = 0 ;
41919 char * kwnames[] = {
41920 (char *) "doIt", NULL
41921 };
41922
41923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
41924 if (obj0) {
41925 ecode1 = SWIG_AsVal_int(obj0, &val1);
41926 if (!SWIG_IsOK(ecode1)) {
41927 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
41928 }
41929 arg1 = static_cast< int >(val1);
41930 }
41931 {
41932 PyThreadState* __tstate = wxPyBeginAllowThreads();
41933 wxValidator::SetBellOnError(arg1);
41934 wxPyEndAllowThreads(__tstate);
41935 if (PyErr_Occurred()) SWIG_fail;
41936 }
41937 resultobj = SWIG_Py_Void();
41938 return resultobj;
41939 fail:
41940 return NULL;
41941 }
41942
41943
41944 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41945 PyObject *obj;
41946 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41947 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
41948 return SWIG_Py_Void();
41949 }
41950
41951 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41952 return SWIG_Python_InitShadowInstance(args);
41953 }
41954
41955 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41956 PyObject *resultobj = 0;
41957 wxPyValidator *result = 0 ;
41958
41959 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
41960 {
41961 PyThreadState* __tstate = wxPyBeginAllowThreads();
41962 result = (wxPyValidator *)new wxPyValidator();
41963 wxPyEndAllowThreads(__tstate);
41964 if (PyErr_Occurred()) SWIG_fail;
41965 }
41966 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
41967 return resultobj;
41968 fail:
41969 return NULL;
41970 }
41971
41972
41973 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41974 PyObject *resultobj = 0;
41975 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
41976 PyObject *arg2 = (PyObject *) 0 ;
41977 PyObject *arg3 = (PyObject *) 0 ;
41978 int arg4 = (int) 1 ;
41979 void *argp1 = 0 ;
41980 int res1 = 0 ;
41981 int val4 ;
41982 int ecode4 = 0 ;
41983 PyObject * obj0 = 0 ;
41984 PyObject * obj1 = 0 ;
41985 PyObject * obj2 = 0 ;
41986 PyObject * obj3 = 0 ;
41987 char * kwnames[] = {
41988 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
41989 };
41990
41991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
41993 if (!SWIG_IsOK(res1)) {
41994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
41995 }
41996 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
41997 arg2 = obj1;
41998 arg3 = obj2;
41999 if (obj3) {
42000 ecode4 = SWIG_AsVal_int(obj3, &val4);
42001 if (!SWIG_IsOK(ecode4)) {
42002 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
42003 }
42004 arg4 = static_cast< int >(val4);
42005 }
42006 {
42007 PyThreadState* __tstate = wxPyBeginAllowThreads();
42008 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
42009 wxPyEndAllowThreads(__tstate);
42010 if (PyErr_Occurred()) SWIG_fail;
42011 }
42012 resultobj = SWIG_Py_Void();
42013 return resultobj;
42014 fail:
42015 return NULL;
42016 }
42017
42018
42019 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42020 PyObject *obj;
42021 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42022 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
42023 return SWIG_Py_Void();
42024 }
42025
42026 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42027 return SWIG_Python_InitShadowInstance(args);
42028 }
42029
42030 SWIGINTERN int DefaultValidator_set(PyObject *) {
42031 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
42032 return 1;
42033 }
42034
42035
42036 SWIGINTERN PyObject *DefaultValidator_get(void) {
42037 PyObject *pyobj = 0;
42038
42039 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
42040 return pyobj;
42041 }
42042
42043
42044 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42045 PyObject *resultobj = 0;
42046 wxString const &arg1_defvalue = wxPyEmptyString ;
42047 wxString *arg1 = (wxString *) &arg1_defvalue ;
42048 long arg2 = (long) 0 ;
42049 wxMenu *result = 0 ;
42050 bool temp1 = false ;
42051 long val2 ;
42052 int ecode2 = 0 ;
42053 PyObject * obj0 = 0 ;
42054 PyObject * obj1 = 0 ;
42055 char * kwnames[] = {
42056 (char *) "title",(char *) "style", NULL
42057 };
42058
42059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
42060 if (obj0) {
42061 {
42062 arg1 = wxString_in_helper(obj0);
42063 if (arg1 == NULL) SWIG_fail;
42064 temp1 = true;
42065 }
42066 }
42067 if (obj1) {
42068 ecode2 = SWIG_AsVal_long(obj1, &val2);
42069 if (!SWIG_IsOK(ecode2)) {
42070 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
42071 }
42072 arg2 = static_cast< long >(val2);
42073 }
42074 {
42075 if (!wxPyCheckForApp()) SWIG_fail;
42076 PyThreadState* __tstate = wxPyBeginAllowThreads();
42077 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
42078 wxPyEndAllowThreads(__tstate);
42079 if (PyErr_Occurred()) SWIG_fail;
42080 }
42081 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
42082 {
42083 if (temp1)
42084 delete arg1;
42085 }
42086 return resultobj;
42087 fail:
42088 {
42089 if (temp1)
42090 delete arg1;
42091 }
42092 return NULL;
42093 }
42094
42095
42096 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42097 PyObject *resultobj = 0;
42098 wxMenu *arg1 = (wxMenu *) 0 ;
42099 int arg2 ;
42100 wxString const &arg3_defvalue = wxPyEmptyString ;
42101 wxString *arg3 = (wxString *) &arg3_defvalue ;
42102 wxString const &arg4_defvalue = wxPyEmptyString ;
42103 wxString *arg4 = (wxString *) &arg4_defvalue ;
42104 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42105 wxMenuItem *result = 0 ;
42106 void *argp1 = 0 ;
42107 int res1 = 0 ;
42108 int val2 ;
42109 int ecode2 = 0 ;
42110 bool temp3 = false ;
42111 bool temp4 = false ;
42112 int val5 ;
42113 int ecode5 = 0 ;
42114 PyObject * obj0 = 0 ;
42115 PyObject * obj1 = 0 ;
42116 PyObject * obj2 = 0 ;
42117 PyObject * obj3 = 0 ;
42118 PyObject * obj4 = 0 ;
42119 char * kwnames[] = {
42120 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42121 };
42122
42123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42125 if (!SWIG_IsOK(res1)) {
42126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
42127 }
42128 arg1 = reinterpret_cast< wxMenu * >(argp1);
42129 ecode2 = SWIG_AsVal_int(obj1, &val2);
42130 if (!SWIG_IsOK(ecode2)) {
42131 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
42132 }
42133 arg2 = static_cast< int >(val2);
42134 if (obj2) {
42135 {
42136 arg3 = wxString_in_helper(obj2);
42137 if (arg3 == NULL) SWIG_fail;
42138 temp3 = true;
42139 }
42140 }
42141 if (obj3) {
42142 {
42143 arg4 = wxString_in_helper(obj3);
42144 if (arg4 == NULL) SWIG_fail;
42145 temp4 = true;
42146 }
42147 }
42148 if (obj4) {
42149 ecode5 = SWIG_AsVal_int(obj4, &val5);
42150 if (!SWIG_IsOK(ecode5)) {
42151 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
42152 }
42153 arg5 = static_cast< wxItemKind >(val5);
42154 }
42155 {
42156 PyThreadState* __tstate = wxPyBeginAllowThreads();
42157 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
42158 wxPyEndAllowThreads(__tstate);
42159 if (PyErr_Occurred()) SWIG_fail;
42160 }
42161 {
42162 resultobj = wxPyMake_wxObject(result, (bool)0);
42163 }
42164 {
42165 if (temp3)
42166 delete arg3;
42167 }
42168 {
42169 if (temp4)
42170 delete arg4;
42171 }
42172 return resultobj;
42173 fail:
42174 {
42175 if (temp3)
42176 delete arg3;
42177 }
42178 {
42179 if (temp4)
42180 delete arg4;
42181 }
42182 return NULL;
42183 }
42184
42185
42186 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42187 PyObject *resultobj = 0;
42188 wxMenu *arg1 = (wxMenu *) 0 ;
42189 wxMenuItem *result = 0 ;
42190 void *argp1 = 0 ;
42191 int res1 = 0 ;
42192 PyObject *swig_obj[1] ;
42193
42194 if (!args) SWIG_fail;
42195 swig_obj[0] = args;
42196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42197 if (!SWIG_IsOK(res1)) {
42198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42199 }
42200 arg1 = reinterpret_cast< wxMenu * >(argp1);
42201 {
42202 PyThreadState* __tstate = wxPyBeginAllowThreads();
42203 result = (wxMenuItem *)(arg1)->AppendSeparator();
42204 wxPyEndAllowThreads(__tstate);
42205 if (PyErr_Occurred()) SWIG_fail;
42206 }
42207 {
42208 resultobj = wxPyMake_wxObject(result, (bool)0);
42209 }
42210 return resultobj;
42211 fail:
42212 return NULL;
42213 }
42214
42215
42216 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42217 PyObject *resultobj = 0;
42218 wxMenu *arg1 = (wxMenu *) 0 ;
42219 int arg2 ;
42220 wxString *arg3 = 0 ;
42221 wxString const &arg4_defvalue = wxPyEmptyString ;
42222 wxString *arg4 = (wxString *) &arg4_defvalue ;
42223 wxMenuItem *result = 0 ;
42224 void *argp1 = 0 ;
42225 int res1 = 0 ;
42226 int val2 ;
42227 int ecode2 = 0 ;
42228 bool temp3 = false ;
42229 bool temp4 = false ;
42230 PyObject * obj0 = 0 ;
42231 PyObject * obj1 = 0 ;
42232 PyObject * obj2 = 0 ;
42233 PyObject * obj3 = 0 ;
42234 char * kwnames[] = {
42235 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42236 };
42237
42238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42240 if (!SWIG_IsOK(res1)) {
42241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42242 }
42243 arg1 = reinterpret_cast< wxMenu * >(argp1);
42244 ecode2 = SWIG_AsVal_int(obj1, &val2);
42245 if (!SWIG_IsOK(ecode2)) {
42246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
42247 }
42248 arg2 = static_cast< int >(val2);
42249 {
42250 arg3 = wxString_in_helper(obj2);
42251 if (arg3 == NULL) SWIG_fail;
42252 temp3 = true;
42253 }
42254 if (obj3) {
42255 {
42256 arg4 = wxString_in_helper(obj3);
42257 if (arg4 == NULL) SWIG_fail;
42258 temp4 = true;
42259 }
42260 }
42261 {
42262 PyThreadState* __tstate = wxPyBeginAllowThreads();
42263 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42264 wxPyEndAllowThreads(__tstate);
42265 if (PyErr_Occurred()) SWIG_fail;
42266 }
42267 {
42268 resultobj = wxPyMake_wxObject(result, (bool)0);
42269 }
42270 {
42271 if (temp3)
42272 delete arg3;
42273 }
42274 {
42275 if (temp4)
42276 delete arg4;
42277 }
42278 return resultobj;
42279 fail:
42280 {
42281 if (temp3)
42282 delete arg3;
42283 }
42284 {
42285 if (temp4)
42286 delete arg4;
42287 }
42288 return NULL;
42289 }
42290
42291
42292 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42293 PyObject *resultobj = 0;
42294 wxMenu *arg1 = (wxMenu *) 0 ;
42295 int arg2 ;
42296 wxString *arg3 = 0 ;
42297 wxString const &arg4_defvalue = wxPyEmptyString ;
42298 wxString *arg4 = (wxString *) &arg4_defvalue ;
42299 wxMenuItem *result = 0 ;
42300 void *argp1 = 0 ;
42301 int res1 = 0 ;
42302 int val2 ;
42303 int ecode2 = 0 ;
42304 bool temp3 = false ;
42305 bool temp4 = false ;
42306 PyObject * obj0 = 0 ;
42307 PyObject * obj1 = 0 ;
42308 PyObject * obj2 = 0 ;
42309 PyObject * obj3 = 0 ;
42310 char * kwnames[] = {
42311 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42312 };
42313
42314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42316 if (!SWIG_IsOK(res1)) {
42317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42318 }
42319 arg1 = reinterpret_cast< wxMenu * >(argp1);
42320 ecode2 = SWIG_AsVal_int(obj1, &val2);
42321 if (!SWIG_IsOK(ecode2)) {
42322 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
42323 }
42324 arg2 = static_cast< int >(val2);
42325 {
42326 arg3 = wxString_in_helper(obj2);
42327 if (arg3 == NULL) SWIG_fail;
42328 temp3 = true;
42329 }
42330 if (obj3) {
42331 {
42332 arg4 = wxString_in_helper(obj3);
42333 if (arg4 == NULL) SWIG_fail;
42334 temp4 = true;
42335 }
42336 }
42337 {
42338 PyThreadState* __tstate = wxPyBeginAllowThreads();
42339 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42340 wxPyEndAllowThreads(__tstate);
42341 if (PyErr_Occurred()) SWIG_fail;
42342 }
42343 {
42344 resultobj = wxPyMake_wxObject(result, (bool)0);
42345 }
42346 {
42347 if (temp3)
42348 delete arg3;
42349 }
42350 {
42351 if (temp4)
42352 delete arg4;
42353 }
42354 return resultobj;
42355 fail:
42356 {
42357 if (temp3)
42358 delete arg3;
42359 }
42360 {
42361 if (temp4)
42362 delete arg4;
42363 }
42364 return NULL;
42365 }
42366
42367
42368 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42369 PyObject *resultobj = 0;
42370 wxMenu *arg1 = (wxMenu *) 0 ;
42371 int arg2 ;
42372 wxString *arg3 = 0 ;
42373 wxMenu *arg4 = (wxMenu *) 0 ;
42374 wxString const &arg5_defvalue = wxPyEmptyString ;
42375 wxString *arg5 = (wxString *) &arg5_defvalue ;
42376 wxMenuItem *result = 0 ;
42377 void *argp1 = 0 ;
42378 int res1 = 0 ;
42379 int val2 ;
42380 int ecode2 = 0 ;
42381 bool temp3 = false ;
42382 void *argp4 = 0 ;
42383 int res4 = 0 ;
42384 bool temp5 = false ;
42385 PyObject * obj0 = 0 ;
42386 PyObject * obj1 = 0 ;
42387 PyObject * obj2 = 0 ;
42388 PyObject * obj3 = 0 ;
42389 PyObject * obj4 = 0 ;
42390 char * kwnames[] = {
42391 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42392 };
42393
42394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42396 if (!SWIG_IsOK(res1)) {
42397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42398 }
42399 arg1 = reinterpret_cast< wxMenu * >(argp1);
42400 ecode2 = SWIG_AsVal_int(obj1, &val2);
42401 if (!SWIG_IsOK(ecode2)) {
42402 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
42403 }
42404 arg2 = static_cast< int >(val2);
42405 {
42406 arg3 = wxString_in_helper(obj2);
42407 if (arg3 == NULL) SWIG_fail;
42408 temp3 = true;
42409 }
42410 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
42411 if (!SWIG_IsOK(res4)) {
42412 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
42413 }
42414 arg4 = reinterpret_cast< wxMenu * >(argp4);
42415 if (obj4) {
42416 {
42417 arg5 = wxString_in_helper(obj4);
42418 if (arg5 == NULL) SWIG_fail;
42419 temp5 = true;
42420 }
42421 }
42422 {
42423 PyThreadState* __tstate = wxPyBeginAllowThreads();
42424 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
42425 wxPyEndAllowThreads(__tstate);
42426 if (PyErr_Occurred()) SWIG_fail;
42427 }
42428 {
42429 resultobj = wxPyMake_wxObject(result, (bool)0);
42430 }
42431 {
42432 if (temp3)
42433 delete arg3;
42434 }
42435 {
42436 if (temp5)
42437 delete arg5;
42438 }
42439 return resultobj;
42440 fail:
42441 {
42442 if (temp3)
42443 delete arg3;
42444 }
42445 {
42446 if (temp5)
42447 delete arg5;
42448 }
42449 return NULL;
42450 }
42451
42452
42453 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42454 PyObject *resultobj = 0;
42455 wxMenu *arg1 = (wxMenu *) 0 ;
42456 wxMenu *arg2 = (wxMenu *) 0 ;
42457 wxString *arg3 = 0 ;
42458 wxString const &arg4_defvalue = wxPyEmptyString ;
42459 wxString *arg4 = (wxString *) &arg4_defvalue ;
42460 wxMenuItem *result = 0 ;
42461 void *argp1 = 0 ;
42462 int res1 = 0 ;
42463 void *argp2 = 0 ;
42464 int res2 = 0 ;
42465 bool temp3 = false ;
42466 bool temp4 = false ;
42467 PyObject * obj0 = 0 ;
42468 PyObject * obj1 = 0 ;
42469 PyObject * obj2 = 0 ;
42470 PyObject * obj3 = 0 ;
42471 char * kwnames[] = {
42472 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
42473 };
42474
42475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42477 if (!SWIG_IsOK(res1)) {
42478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42479 }
42480 arg1 = reinterpret_cast< wxMenu * >(argp1);
42481 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42482 if (!SWIG_IsOK(res2)) {
42483 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42484 }
42485 arg2 = reinterpret_cast< wxMenu * >(argp2);
42486 {
42487 arg3 = wxString_in_helper(obj2);
42488 if (arg3 == NULL) SWIG_fail;
42489 temp3 = true;
42490 }
42491 if (obj3) {
42492 {
42493 arg4 = wxString_in_helper(obj3);
42494 if (arg4 == NULL) SWIG_fail;
42495 temp4 = true;
42496 }
42497 }
42498 {
42499 PyThreadState* __tstate = wxPyBeginAllowThreads();
42500 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42501 wxPyEndAllowThreads(__tstate);
42502 if (PyErr_Occurred()) SWIG_fail;
42503 }
42504 {
42505 resultobj = wxPyMake_wxObject(result, (bool)0);
42506 }
42507 {
42508 if (temp3)
42509 delete arg3;
42510 }
42511 {
42512 if (temp4)
42513 delete arg4;
42514 }
42515 return resultobj;
42516 fail:
42517 {
42518 if (temp3)
42519 delete arg3;
42520 }
42521 {
42522 if (temp4)
42523 delete arg4;
42524 }
42525 return NULL;
42526 }
42527
42528
42529 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42530 PyObject *resultobj = 0;
42531 wxMenu *arg1 = (wxMenu *) 0 ;
42532 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42533 wxMenuItem *result = 0 ;
42534 void *argp1 = 0 ;
42535 int res1 = 0 ;
42536 int res2 = 0 ;
42537 PyObject * obj0 = 0 ;
42538 PyObject * obj1 = 0 ;
42539 char * kwnames[] = {
42540 (char *) "self",(char *) "item", NULL
42541 };
42542
42543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
42544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42545 if (!SWIG_IsOK(res1)) {
42546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42547 }
42548 arg1 = reinterpret_cast< wxMenu * >(argp1);
42549 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42550 if (!SWIG_IsOK(res2)) {
42551 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42552 }
42553 {
42554 PyThreadState* __tstate = wxPyBeginAllowThreads();
42555 result = (wxMenuItem *)(arg1)->Append(arg2);
42556 wxPyEndAllowThreads(__tstate);
42557 if (PyErr_Occurred()) SWIG_fail;
42558 }
42559 {
42560 resultobj = wxPyMake_wxObject(result, (bool)0);
42561 }
42562 return resultobj;
42563 fail:
42564 return NULL;
42565 }
42566
42567
42568 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42569 PyObject *resultobj = 0;
42570 wxMenu *arg1 = (wxMenu *) 0 ;
42571 size_t arg2 ;
42572 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
42573 wxMenuItem *result = 0 ;
42574 void *argp1 = 0 ;
42575 int res1 = 0 ;
42576 size_t val2 ;
42577 int ecode2 = 0 ;
42578 int res3 = 0 ;
42579 PyObject * obj0 = 0 ;
42580 PyObject * obj1 = 0 ;
42581 PyObject * obj2 = 0 ;
42582 char * kwnames[] = {
42583 (char *) "self",(char *) "pos",(char *) "item", NULL
42584 };
42585
42586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42588 if (!SWIG_IsOK(res1)) {
42589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42590 }
42591 arg1 = reinterpret_cast< wxMenu * >(argp1);
42592 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42593 if (!SWIG_IsOK(ecode2)) {
42594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
42595 }
42596 arg2 = static_cast< size_t >(val2);
42597 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42598 if (!SWIG_IsOK(res3)) {
42599 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
42600 }
42601 {
42602 PyThreadState* __tstate = wxPyBeginAllowThreads();
42603 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
42604 wxPyEndAllowThreads(__tstate);
42605 if (PyErr_Occurred()) SWIG_fail;
42606 }
42607 {
42608 resultobj = wxPyMake_wxObject(result, (bool)0);
42609 }
42610 return resultobj;
42611 fail:
42612 return NULL;
42613 }
42614
42615
42616 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42617 PyObject *resultobj = 0;
42618 wxMenu *arg1 = (wxMenu *) 0 ;
42619 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42620 wxMenuItem *result = 0 ;
42621 void *argp1 = 0 ;
42622 int res1 = 0 ;
42623 int res2 = 0 ;
42624 PyObject * obj0 = 0 ;
42625 PyObject * obj1 = 0 ;
42626 char * kwnames[] = {
42627 (char *) "self",(char *) "item", NULL
42628 };
42629
42630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
42631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42632 if (!SWIG_IsOK(res1)) {
42633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42634 }
42635 arg1 = reinterpret_cast< wxMenu * >(argp1);
42636 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42637 if (!SWIG_IsOK(res2)) {
42638 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42639 }
42640 {
42641 PyThreadState* __tstate = wxPyBeginAllowThreads();
42642 result = (wxMenuItem *)(arg1)->Prepend(arg2);
42643 wxPyEndAllowThreads(__tstate);
42644 if (PyErr_Occurred()) SWIG_fail;
42645 }
42646 {
42647 resultobj = wxPyMake_wxObject(result, (bool)0);
42648 }
42649 return resultobj;
42650 fail:
42651 return NULL;
42652 }
42653
42654
42655 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42656 PyObject *resultobj = 0;
42657 wxMenu *arg1 = (wxMenu *) 0 ;
42658 void *argp1 = 0 ;
42659 int res1 = 0 ;
42660 PyObject *swig_obj[1] ;
42661
42662 if (!args) SWIG_fail;
42663 swig_obj[0] = args;
42664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42665 if (!SWIG_IsOK(res1)) {
42666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
42667 }
42668 arg1 = reinterpret_cast< wxMenu * >(argp1);
42669 {
42670 PyThreadState* __tstate = wxPyBeginAllowThreads();
42671 (arg1)->Break();
42672 wxPyEndAllowThreads(__tstate);
42673 if (PyErr_Occurred()) SWIG_fail;
42674 }
42675 resultobj = SWIG_Py_Void();
42676 return resultobj;
42677 fail:
42678 return NULL;
42679 }
42680
42681
42682 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42683 PyObject *resultobj = 0;
42684 wxMenu *arg1 = (wxMenu *) 0 ;
42685 size_t arg2 ;
42686 int arg3 ;
42687 wxString const &arg4_defvalue = wxPyEmptyString ;
42688 wxString *arg4 = (wxString *) &arg4_defvalue ;
42689 wxString const &arg5_defvalue = wxPyEmptyString ;
42690 wxString *arg5 = (wxString *) &arg5_defvalue ;
42691 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
42692 wxMenuItem *result = 0 ;
42693 void *argp1 = 0 ;
42694 int res1 = 0 ;
42695 size_t val2 ;
42696 int ecode2 = 0 ;
42697 int val3 ;
42698 int ecode3 = 0 ;
42699 bool temp4 = false ;
42700 bool temp5 = false ;
42701 int val6 ;
42702 int ecode6 = 0 ;
42703 PyObject * obj0 = 0 ;
42704 PyObject * obj1 = 0 ;
42705 PyObject * obj2 = 0 ;
42706 PyObject * obj3 = 0 ;
42707 PyObject * obj4 = 0 ;
42708 PyObject * obj5 = 0 ;
42709 char * kwnames[] = {
42710 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42711 };
42712
42713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42715 if (!SWIG_IsOK(res1)) {
42716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
42717 }
42718 arg1 = reinterpret_cast< wxMenu * >(argp1);
42719 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42720 if (!SWIG_IsOK(ecode2)) {
42721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
42722 }
42723 arg2 = static_cast< size_t >(val2);
42724 ecode3 = SWIG_AsVal_int(obj2, &val3);
42725 if (!SWIG_IsOK(ecode3)) {
42726 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
42727 }
42728 arg3 = static_cast< int >(val3);
42729 if (obj3) {
42730 {
42731 arg4 = wxString_in_helper(obj3);
42732 if (arg4 == NULL) SWIG_fail;
42733 temp4 = true;
42734 }
42735 }
42736 if (obj4) {
42737 {
42738 arg5 = wxString_in_helper(obj4);
42739 if (arg5 == NULL) SWIG_fail;
42740 temp5 = true;
42741 }
42742 }
42743 if (obj5) {
42744 ecode6 = SWIG_AsVal_int(obj5, &val6);
42745 if (!SWIG_IsOK(ecode6)) {
42746 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
42747 }
42748 arg6 = static_cast< wxItemKind >(val6);
42749 }
42750 {
42751 PyThreadState* __tstate = wxPyBeginAllowThreads();
42752 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
42753 wxPyEndAllowThreads(__tstate);
42754 if (PyErr_Occurred()) SWIG_fail;
42755 }
42756 {
42757 resultobj = wxPyMake_wxObject(result, (bool)0);
42758 }
42759 {
42760 if (temp4)
42761 delete arg4;
42762 }
42763 {
42764 if (temp5)
42765 delete arg5;
42766 }
42767 return resultobj;
42768 fail:
42769 {
42770 if (temp4)
42771 delete arg4;
42772 }
42773 {
42774 if (temp5)
42775 delete arg5;
42776 }
42777 return NULL;
42778 }
42779
42780
42781 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42782 PyObject *resultobj = 0;
42783 wxMenu *arg1 = (wxMenu *) 0 ;
42784 size_t arg2 ;
42785 wxMenuItem *result = 0 ;
42786 void *argp1 = 0 ;
42787 int res1 = 0 ;
42788 size_t val2 ;
42789 int ecode2 = 0 ;
42790 PyObject * obj0 = 0 ;
42791 PyObject * obj1 = 0 ;
42792 char * kwnames[] = {
42793 (char *) "self",(char *) "pos", NULL
42794 };
42795
42796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
42797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42798 if (!SWIG_IsOK(res1)) {
42799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42800 }
42801 arg1 = reinterpret_cast< wxMenu * >(argp1);
42802 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42803 if (!SWIG_IsOK(ecode2)) {
42804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
42805 }
42806 arg2 = static_cast< size_t >(val2);
42807 {
42808 PyThreadState* __tstate = wxPyBeginAllowThreads();
42809 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
42810 wxPyEndAllowThreads(__tstate);
42811 if (PyErr_Occurred()) SWIG_fail;
42812 }
42813 {
42814 resultobj = wxPyMake_wxObject(result, (bool)0);
42815 }
42816 return resultobj;
42817 fail:
42818 return NULL;
42819 }
42820
42821
42822 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42823 PyObject *resultobj = 0;
42824 wxMenu *arg1 = (wxMenu *) 0 ;
42825 size_t arg2 ;
42826 int arg3 ;
42827 wxString *arg4 = 0 ;
42828 wxString const &arg5_defvalue = wxPyEmptyString ;
42829 wxString *arg5 = (wxString *) &arg5_defvalue ;
42830 wxMenuItem *result = 0 ;
42831 void *argp1 = 0 ;
42832 int res1 = 0 ;
42833 size_t val2 ;
42834 int ecode2 = 0 ;
42835 int val3 ;
42836 int ecode3 = 0 ;
42837 bool temp4 = false ;
42838 bool temp5 = false ;
42839 PyObject * obj0 = 0 ;
42840 PyObject * obj1 = 0 ;
42841 PyObject * obj2 = 0 ;
42842 PyObject * obj3 = 0 ;
42843 PyObject * obj4 = 0 ;
42844 char * kwnames[] = {
42845 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42846 };
42847
42848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42850 if (!SWIG_IsOK(res1)) {
42851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42852 }
42853 arg1 = reinterpret_cast< wxMenu * >(argp1);
42854 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42855 if (!SWIG_IsOK(ecode2)) {
42856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
42857 }
42858 arg2 = static_cast< size_t >(val2);
42859 ecode3 = SWIG_AsVal_int(obj2, &val3);
42860 if (!SWIG_IsOK(ecode3)) {
42861 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
42862 }
42863 arg3 = static_cast< int >(val3);
42864 {
42865 arg4 = wxString_in_helper(obj3);
42866 if (arg4 == NULL) SWIG_fail;
42867 temp4 = true;
42868 }
42869 if (obj4) {
42870 {
42871 arg5 = wxString_in_helper(obj4);
42872 if (arg5 == NULL) SWIG_fail;
42873 temp5 = true;
42874 }
42875 }
42876 {
42877 PyThreadState* __tstate = wxPyBeginAllowThreads();
42878 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42879 wxPyEndAllowThreads(__tstate);
42880 if (PyErr_Occurred()) SWIG_fail;
42881 }
42882 {
42883 resultobj = wxPyMake_wxObject(result, (bool)0);
42884 }
42885 {
42886 if (temp4)
42887 delete arg4;
42888 }
42889 {
42890 if (temp5)
42891 delete arg5;
42892 }
42893 return resultobj;
42894 fail:
42895 {
42896 if (temp4)
42897 delete arg4;
42898 }
42899 {
42900 if (temp5)
42901 delete arg5;
42902 }
42903 return NULL;
42904 }
42905
42906
42907 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42908 PyObject *resultobj = 0;
42909 wxMenu *arg1 = (wxMenu *) 0 ;
42910 size_t arg2 ;
42911 int arg3 ;
42912 wxString *arg4 = 0 ;
42913 wxString const &arg5_defvalue = wxPyEmptyString ;
42914 wxString *arg5 = (wxString *) &arg5_defvalue ;
42915 wxMenuItem *result = 0 ;
42916 void *argp1 = 0 ;
42917 int res1 = 0 ;
42918 size_t val2 ;
42919 int ecode2 = 0 ;
42920 int val3 ;
42921 int ecode3 = 0 ;
42922 bool temp4 = false ;
42923 bool temp5 = false ;
42924 PyObject * obj0 = 0 ;
42925 PyObject * obj1 = 0 ;
42926 PyObject * obj2 = 0 ;
42927 PyObject * obj3 = 0 ;
42928 PyObject * obj4 = 0 ;
42929 char * kwnames[] = {
42930 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42931 };
42932
42933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42935 if (!SWIG_IsOK(res1)) {
42936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42937 }
42938 arg1 = reinterpret_cast< wxMenu * >(argp1);
42939 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42940 if (!SWIG_IsOK(ecode2)) {
42941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
42942 }
42943 arg2 = static_cast< size_t >(val2);
42944 ecode3 = SWIG_AsVal_int(obj2, &val3);
42945 if (!SWIG_IsOK(ecode3)) {
42946 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
42947 }
42948 arg3 = static_cast< int >(val3);
42949 {
42950 arg4 = wxString_in_helper(obj3);
42951 if (arg4 == NULL) SWIG_fail;
42952 temp4 = true;
42953 }
42954 if (obj4) {
42955 {
42956 arg5 = wxString_in_helper(obj4);
42957 if (arg5 == NULL) SWIG_fail;
42958 temp5 = true;
42959 }
42960 }
42961 {
42962 PyThreadState* __tstate = wxPyBeginAllowThreads();
42963 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42964 wxPyEndAllowThreads(__tstate);
42965 if (PyErr_Occurred()) SWIG_fail;
42966 }
42967 {
42968 resultobj = wxPyMake_wxObject(result, (bool)0);
42969 }
42970 {
42971 if (temp4)
42972 delete arg4;
42973 }
42974 {
42975 if (temp5)
42976 delete arg5;
42977 }
42978 return resultobj;
42979 fail:
42980 {
42981 if (temp4)
42982 delete arg4;
42983 }
42984 {
42985 if (temp5)
42986 delete arg5;
42987 }
42988 return NULL;
42989 }
42990
42991
42992 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42993 PyObject *resultobj = 0;
42994 wxMenu *arg1 = (wxMenu *) 0 ;
42995 size_t arg2 ;
42996 int arg3 ;
42997 wxString *arg4 = 0 ;
42998 wxMenu *arg5 = (wxMenu *) 0 ;
42999 wxString const &arg6_defvalue = wxPyEmptyString ;
43000 wxString *arg6 = (wxString *) &arg6_defvalue ;
43001 wxMenuItem *result = 0 ;
43002 void *argp1 = 0 ;
43003 int res1 = 0 ;
43004 size_t val2 ;
43005 int ecode2 = 0 ;
43006 int val3 ;
43007 int ecode3 = 0 ;
43008 bool temp4 = false ;
43009 void *argp5 = 0 ;
43010 int res5 = 0 ;
43011 bool temp6 = false ;
43012 PyObject * obj0 = 0 ;
43013 PyObject * obj1 = 0 ;
43014 PyObject * obj2 = 0 ;
43015 PyObject * obj3 = 0 ;
43016 PyObject * obj4 = 0 ;
43017 PyObject * obj5 = 0 ;
43018 char * kwnames[] = {
43019 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
43020 };
43021
43022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
43023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43024 if (!SWIG_IsOK(res1)) {
43025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
43026 }
43027 arg1 = reinterpret_cast< wxMenu * >(argp1);
43028 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43029 if (!SWIG_IsOK(ecode2)) {
43030 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
43031 }
43032 arg2 = static_cast< size_t >(val2);
43033 ecode3 = SWIG_AsVal_int(obj2, &val3);
43034 if (!SWIG_IsOK(ecode3)) {
43035 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
43036 }
43037 arg3 = static_cast< int >(val3);
43038 {
43039 arg4 = wxString_in_helper(obj3);
43040 if (arg4 == NULL) SWIG_fail;
43041 temp4 = true;
43042 }
43043 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
43044 if (!SWIG_IsOK(res5)) {
43045 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
43046 }
43047 arg5 = reinterpret_cast< wxMenu * >(argp5);
43048 if (obj5) {
43049 {
43050 arg6 = wxString_in_helper(obj5);
43051 if (arg6 == NULL) SWIG_fail;
43052 temp6 = true;
43053 }
43054 }
43055 {
43056 PyThreadState* __tstate = wxPyBeginAllowThreads();
43057 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
43058 wxPyEndAllowThreads(__tstate);
43059 if (PyErr_Occurred()) SWIG_fail;
43060 }
43061 {
43062 resultobj = wxPyMake_wxObject(result, (bool)0);
43063 }
43064 {
43065 if (temp4)
43066 delete arg4;
43067 }
43068 {
43069 if (temp6)
43070 delete arg6;
43071 }
43072 return resultobj;
43073 fail:
43074 {
43075 if (temp4)
43076 delete arg4;
43077 }
43078 {
43079 if (temp6)
43080 delete arg6;
43081 }
43082 return NULL;
43083 }
43084
43085
43086 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43087 PyObject *resultobj = 0;
43088 wxMenu *arg1 = (wxMenu *) 0 ;
43089 int arg2 ;
43090 wxString const &arg3_defvalue = wxPyEmptyString ;
43091 wxString *arg3 = (wxString *) &arg3_defvalue ;
43092 wxString const &arg4_defvalue = wxPyEmptyString ;
43093 wxString *arg4 = (wxString *) &arg4_defvalue ;
43094 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
43095 wxMenuItem *result = 0 ;
43096 void *argp1 = 0 ;
43097 int res1 = 0 ;
43098 int val2 ;
43099 int ecode2 = 0 ;
43100 bool temp3 = false ;
43101 bool temp4 = false ;
43102 int val5 ;
43103 int ecode5 = 0 ;
43104 PyObject * obj0 = 0 ;
43105 PyObject * obj1 = 0 ;
43106 PyObject * obj2 = 0 ;
43107 PyObject * obj3 = 0 ;
43108 PyObject * obj4 = 0 ;
43109 char * kwnames[] = {
43110 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
43111 };
43112
43113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43115 if (!SWIG_IsOK(res1)) {
43116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
43117 }
43118 arg1 = reinterpret_cast< wxMenu * >(argp1);
43119 ecode2 = SWIG_AsVal_int(obj1, &val2);
43120 if (!SWIG_IsOK(ecode2)) {
43121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
43122 }
43123 arg2 = static_cast< int >(val2);
43124 if (obj2) {
43125 {
43126 arg3 = wxString_in_helper(obj2);
43127 if (arg3 == NULL) SWIG_fail;
43128 temp3 = true;
43129 }
43130 }
43131 if (obj3) {
43132 {
43133 arg4 = wxString_in_helper(obj3);
43134 if (arg4 == NULL) SWIG_fail;
43135 temp4 = true;
43136 }
43137 }
43138 if (obj4) {
43139 ecode5 = SWIG_AsVal_int(obj4, &val5);
43140 if (!SWIG_IsOK(ecode5)) {
43141 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
43142 }
43143 arg5 = static_cast< wxItemKind >(val5);
43144 }
43145 {
43146 PyThreadState* __tstate = wxPyBeginAllowThreads();
43147 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
43148 wxPyEndAllowThreads(__tstate);
43149 if (PyErr_Occurred()) SWIG_fail;
43150 }
43151 {
43152 resultobj = wxPyMake_wxObject(result, (bool)0);
43153 }
43154 {
43155 if (temp3)
43156 delete arg3;
43157 }
43158 {
43159 if (temp4)
43160 delete arg4;
43161 }
43162 return resultobj;
43163 fail:
43164 {
43165 if (temp3)
43166 delete arg3;
43167 }
43168 {
43169 if (temp4)
43170 delete arg4;
43171 }
43172 return NULL;
43173 }
43174
43175
43176 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43177 PyObject *resultobj = 0;
43178 wxMenu *arg1 = (wxMenu *) 0 ;
43179 wxMenuItem *result = 0 ;
43180 void *argp1 = 0 ;
43181 int res1 = 0 ;
43182 PyObject *swig_obj[1] ;
43183
43184 if (!args) SWIG_fail;
43185 swig_obj[0] = args;
43186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43187 if (!SWIG_IsOK(res1)) {
43188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
43189 }
43190 arg1 = reinterpret_cast< wxMenu * >(argp1);
43191 {
43192 PyThreadState* __tstate = wxPyBeginAllowThreads();
43193 result = (wxMenuItem *)(arg1)->PrependSeparator();
43194 wxPyEndAllowThreads(__tstate);
43195 if (PyErr_Occurred()) SWIG_fail;
43196 }
43197 {
43198 resultobj = wxPyMake_wxObject(result, (bool)0);
43199 }
43200 return resultobj;
43201 fail:
43202 return NULL;
43203 }
43204
43205
43206 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43207 PyObject *resultobj = 0;
43208 wxMenu *arg1 = (wxMenu *) 0 ;
43209 int arg2 ;
43210 wxString *arg3 = 0 ;
43211 wxString const &arg4_defvalue = wxPyEmptyString ;
43212 wxString *arg4 = (wxString *) &arg4_defvalue ;
43213 wxMenuItem *result = 0 ;
43214 void *argp1 = 0 ;
43215 int res1 = 0 ;
43216 int val2 ;
43217 int ecode2 = 0 ;
43218 bool temp3 = false ;
43219 bool temp4 = false ;
43220 PyObject * obj0 = 0 ;
43221 PyObject * obj1 = 0 ;
43222 PyObject * obj2 = 0 ;
43223 PyObject * obj3 = 0 ;
43224 char * kwnames[] = {
43225 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
43226 };
43227
43228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43230 if (!SWIG_IsOK(res1)) {
43231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43232 }
43233 arg1 = reinterpret_cast< wxMenu * >(argp1);
43234 ecode2 = SWIG_AsVal_int(obj1, &val2);
43235 if (!SWIG_IsOK(ecode2)) {
43236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
43237 }
43238 arg2 = static_cast< int >(val2);
43239 {
43240 arg3 = wxString_in_helper(obj2);
43241 if (arg3 == NULL) SWIG_fail;
43242 temp3 = true;
43243 }
43244 if (obj3) {
43245 {
43246 arg4 = wxString_in_helper(obj3);
43247 if (arg4 == NULL) SWIG_fail;
43248 temp4 = true;
43249 }
43250 }
43251 {
43252 PyThreadState* __tstate = wxPyBeginAllowThreads();
43253 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
43254 wxPyEndAllowThreads(__tstate);
43255 if (PyErr_Occurred()) SWIG_fail;
43256 }
43257 {
43258 resultobj = wxPyMake_wxObject(result, (bool)0);
43259 }
43260 {
43261 if (temp3)
43262 delete arg3;
43263 }
43264 {
43265 if (temp4)
43266 delete arg4;
43267 }
43268 return resultobj;
43269 fail:
43270 {
43271 if (temp3)
43272 delete arg3;
43273 }
43274 {
43275 if (temp4)
43276 delete arg4;
43277 }
43278 return NULL;
43279 }
43280
43281
43282 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43283 PyObject *resultobj = 0;
43284 wxMenu *arg1 = (wxMenu *) 0 ;
43285 int arg2 ;
43286 wxString *arg3 = 0 ;
43287 wxString const &arg4_defvalue = wxPyEmptyString ;
43288 wxString *arg4 = (wxString *) &arg4_defvalue ;
43289 wxMenuItem *result = 0 ;
43290 void *argp1 = 0 ;
43291 int res1 = 0 ;
43292 int val2 ;
43293 int ecode2 = 0 ;
43294 bool temp3 = false ;
43295 bool temp4 = false ;
43296 PyObject * obj0 = 0 ;
43297 PyObject * obj1 = 0 ;
43298 PyObject * obj2 = 0 ;
43299 PyObject * obj3 = 0 ;
43300 char * kwnames[] = {
43301 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
43302 };
43303
43304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43306 if (!SWIG_IsOK(res1)) {
43307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43308 }
43309 arg1 = reinterpret_cast< wxMenu * >(argp1);
43310 ecode2 = SWIG_AsVal_int(obj1, &val2);
43311 if (!SWIG_IsOK(ecode2)) {
43312 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
43313 }
43314 arg2 = static_cast< int >(val2);
43315 {
43316 arg3 = wxString_in_helper(obj2);
43317 if (arg3 == NULL) SWIG_fail;
43318 temp3 = true;
43319 }
43320 if (obj3) {
43321 {
43322 arg4 = wxString_in_helper(obj3);
43323 if (arg4 == NULL) SWIG_fail;
43324 temp4 = true;
43325 }
43326 }
43327 {
43328 PyThreadState* __tstate = wxPyBeginAllowThreads();
43329 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
43330 wxPyEndAllowThreads(__tstate);
43331 if (PyErr_Occurred()) SWIG_fail;
43332 }
43333 {
43334 resultobj = wxPyMake_wxObject(result, (bool)0);
43335 }
43336 {
43337 if (temp3)
43338 delete arg3;
43339 }
43340 {
43341 if (temp4)
43342 delete arg4;
43343 }
43344 return resultobj;
43345 fail:
43346 {
43347 if (temp3)
43348 delete arg3;
43349 }
43350 {
43351 if (temp4)
43352 delete arg4;
43353 }
43354 return NULL;
43355 }
43356
43357
43358 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43359 PyObject *resultobj = 0;
43360 wxMenu *arg1 = (wxMenu *) 0 ;
43361 int arg2 ;
43362 wxString *arg3 = 0 ;
43363 wxMenu *arg4 = (wxMenu *) 0 ;
43364 wxString const &arg5_defvalue = wxPyEmptyString ;
43365 wxString *arg5 = (wxString *) &arg5_defvalue ;
43366 wxMenuItem *result = 0 ;
43367 void *argp1 = 0 ;
43368 int res1 = 0 ;
43369 int val2 ;
43370 int ecode2 = 0 ;
43371 bool temp3 = false ;
43372 void *argp4 = 0 ;
43373 int res4 = 0 ;
43374 bool temp5 = false ;
43375 PyObject * obj0 = 0 ;
43376 PyObject * obj1 = 0 ;
43377 PyObject * obj2 = 0 ;
43378 PyObject * obj3 = 0 ;
43379 PyObject * obj4 = 0 ;
43380 char * kwnames[] = {
43381 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
43382 };
43383
43384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43386 if (!SWIG_IsOK(res1)) {
43387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
43388 }
43389 arg1 = reinterpret_cast< wxMenu * >(argp1);
43390 ecode2 = SWIG_AsVal_int(obj1, &val2);
43391 if (!SWIG_IsOK(ecode2)) {
43392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
43393 }
43394 arg2 = static_cast< int >(val2);
43395 {
43396 arg3 = wxString_in_helper(obj2);
43397 if (arg3 == NULL) SWIG_fail;
43398 temp3 = true;
43399 }
43400 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
43401 if (!SWIG_IsOK(res4)) {
43402 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
43403 }
43404 arg4 = reinterpret_cast< wxMenu * >(argp4);
43405 if (obj4) {
43406 {
43407 arg5 = wxString_in_helper(obj4);
43408 if (arg5 == NULL) SWIG_fail;
43409 temp5 = true;
43410 }
43411 }
43412 {
43413 PyThreadState* __tstate = wxPyBeginAllowThreads();
43414 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
43415 wxPyEndAllowThreads(__tstate);
43416 if (PyErr_Occurred()) SWIG_fail;
43417 }
43418 {
43419 resultobj = wxPyMake_wxObject(result, (bool)0);
43420 }
43421 {
43422 if (temp3)
43423 delete arg3;
43424 }
43425 {
43426 if (temp5)
43427 delete arg5;
43428 }
43429 return resultobj;
43430 fail:
43431 {
43432 if (temp3)
43433 delete arg3;
43434 }
43435 {
43436 if (temp5)
43437 delete arg5;
43438 }
43439 return NULL;
43440 }
43441
43442
43443 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43444 PyObject *resultobj = 0;
43445 wxMenu *arg1 = (wxMenu *) 0 ;
43446 int arg2 ;
43447 wxMenuItem *result = 0 ;
43448 void *argp1 = 0 ;
43449 int res1 = 0 ;
43450 int val2 ;
43451 int ecode2 = 0 ;
43452 PyObject * obj0 = 0 ;
43453 PyObject * obj1 = 0 ;
43454 char * kwnames[] = {
43455 (char *) "self",(char *) "id", NULL
43456 };
43457
43458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
43459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43460 if (!SWIG_IsOK(res1)) {
43461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
43462 }
43463 arg1 = reinterpret_cast< wxMenu * >(argp1);
43464 ecode2 = SWIG_AsVal_int(obj1, &val2);
43465 if (!SWIG_IsOK(ecode2)) {
43466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
43467 }
43468 arg2 = static_cast< int >(val2);
43469 {
43470 PyThreadState* __tstate = wxPyBeginAllowThreads();
43471 result = (wxMenuItem *)(arg1)->Remove(arg2);
43472 wxPyEndAllowThreads(__tstate);
43473 if (PyErr_Occurred()) SWIG_fail;
43474 }
43475 {
43476 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43477 }
43478 return resultobj;
43479 fail:
43480 return NULL;
43481 }
43482
43483
43484 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43485 PyObject *resultobj = 0;
43486 wxMenu *arg1 = (wxMenu *) 0 ;
43487 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43488 wxMenuItem *result = 0 ;
43489 void *argp1 = 0 ;
43490 int res1 = 0 ;
43491 void *argp2 = 0 ;
43492 int res2 = 0 ;
43493 PyObject * obj0 = 0 ;
43494 PyObject * obj1 = 0 ;
43495 char * kwnames[] = {
43496 (char *) "self",(char *) "item", NULL
43497 };
43498
43499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
43500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43501 if (!SWIG_IsOK(res1)) {
43502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43503 }
43504 arg1 = reinterpret_cast< wxMenu * >(argp1);
43505 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43506 if (!SWIG_IsOK(res2)) {
43507 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43508 }
43509 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43510 {
43511 PyThreadState* __tstate = wxPyBeginAllowThreads();
43512 result = (wxMenuItem *)(arg1)->Remove(arg2);
43513 wxPyEndAllowThreads(__tstate);
43514 if (PyErr_Occurred()) SWIG_fail;
43515 }
43516 {
43517 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43518 }
43519 return resultobj;
43520 fail:
43521 return NULL;
43522 }
43523
43524
43525 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43526 PyObject *resultobj = 0;
43527 wxMenu *arg1 = (wxMenu *) 0 ;
43528 int arg2 ;
43529 bool result;
43530 void *argp1 = 0 ;
43531 int res1 = 0 ;
43532 int val2 ;
43533 int ecode2 = 0 ;
43534 PyObject * obj0 = 0 ;
43535 PyObject * obj1 = 0 ;
43536 char * kwnames[] = {
43537 (char *) "self",(char *) "id", NULL
43538 };
43539
43540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
43541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43542 if (!SWIG_IsOK(res1)) {
43543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
43544 }
43545 arg1 = reinterpret_cast< wxMenu * >(argp1);
43546 ecode2 = SWIG_AsVal_int(obj1, &val2);
43547 if (!SWIG_IsOK(ecode2)) {
43548 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
43549 }
43550 arg2 = static_cast< int >(val2);
43551 {
43552 PyThreadState* __tstate = wxPyBeginAllowThreads();
43553 result = (bool)(arg1)->Delete(arg2);
43554 wxPyEndAllowThreads(__tstate);
43555 if (PyErr_Occurred()) SWIG_fail;
43556 }
43557 {
43558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43559 }
43560 return resultobj;
43561 fail:
43562 return NULL;
43563 }
43564
43565
43566 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43567 PyObject *resultobj = 0;
43568 wxMenu *arg1 = (wxMenu *) 0 ;
43569 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43570 bool result;
43571 void *argp1 = 0 ;
43572 int res1 = 0 ;
43573 void *argp2 = 0 ;
43574 int res2 = 0 ;
43575 PyObject * obj0 = 0 ;
43576 PyObject * obj1 = 0 ;
43577 char * kwnames[] = {
43578 (char *) "self",(char *) "item", NULL
43579 };
43580
43581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
43582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43583 if (!SWIG_IsOK(res1)) {
43584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43585 }
43586 arg1 = reinterpret_cast< wxMenu * >(argp1);
43587 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43588 if (!SWIG_IsOK(res2)) {
43589 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43590 }
43591 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43592 {
43593 PyThreadState* __tstate = wxPyBeginAllowThreads();
43594 result = (bool)(arg1)->Delete(arg2);
43595 wxPyEndAllowThreads(__tstate);
43596 if (PyErr_Occurred()) SWIG_fail;
43597 }
43598 {
43599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43600 }
43601 return resultobj;
43602 fail:
43603 return NULL;
43604 }
43605
43606
43607 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43608 PyObject *resultobj = 0;
43609 wxMenu *arg1 = (wxMenu *) 0 ;
43610 void *argp1 = 0 ;
43611 int res1 = 0 ;
43612 PyObject *swig_obj[1] ;
43613
43614 if (!args) SWIG_fail;
43615 swig_obj[0] = args;
43616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43617 if (!SWIG_IsOK(res1)) {
43618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
43619 }
43620 arg1 = reinterpret_cast< wxMenu * >(argp1);
43621 {
43622 PyThreadState* __tstate = wxPyBeginAllowThreads();
43623 wxMenu_Destroy(arg1);
43624 wxPyEndAllowThreads(__tstate);
43625 if (PyErr_Occurred()) SWIG_fail;
43626 }
43627 resultobj = SWIG_Py_Void();
43628 return resultobj;
43629 fail:
43630 return NULL;
43631 }
43632
43633
43634 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43635 PyObject *resultobj = 0;
43636 wxMenu *arg1 = (wxMenu *) 0 ;
43637 int arg2 ;
43638 bool result;
43639 void *argp1 = 0 ;
43640 int res1 = 0 ;
43641 int val2 ;
43642 int ecode2 = 0 ;
43643 PyObject * obj0 = 0 ;
43644 PyObject * obj1 = 0 ;
43645 char * kwnames[] = {
43646 (char *) "self",(char *) "id", NULL
43647 };
43648
43649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
43650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43651 if (!SWIG_IsOK(res1)) {
43652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
43653 }
43654 arg1 = reinterpret_cast< wxMenu * >(argp1);
43655 ecode2 = SWIG_AsVal_int(obj1, &val2);
43656 if (!SWIG_IsOK(ecode2)) {
43657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
43658 }
43659 arg2 = static_cast< int >(val2);
43660 {
43661 PyThreadState* __tstate = wxPyBeginAllowThreads();
43662 result = (bool)(arg1)->Destroy(arg2);
43663 wxPyEndAllowThreads(__tstate);
43664 if (PyErr_Occurred()) SWIG_fail;
43665 }
43666 {
43667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43668 }
43669 return resultobj;
43670 fail:
43671 return NULL;
43672 }
43673
43674
43675 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43676 PyObject *resultobj = 0;
43677 wxMenu *arg1 = (wxMenu *) 0 ;
43678 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43679 bool result;
43680 void *argp1 = 0 ;
43681 int res1 = 0 ;
43682 void *argp2 = 0 ;
43683 int res2 = 0 ;
43684 PyObject * obj0 = 0 ;
43685 PyObject * obj1 = 0 ;
43686 char * kwnames[] = {
43687 (char *) "self",(char *) "item", NULL
43688 };
43689
43690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
43691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43692 if (!SWIG_IsOK(res1)) {
43693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43694 }
43695 arg1 = reinterpret_cast< wxMenu * >(argp1);
43696 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43697 if (!SWIG_IsOK(res2)) {
43698 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43699 }
43700 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43701 {
43702 PyThreadState* __tstate = wxPyBeginAllowThreads();
43703 result = (bool)(arg1)->Destroy(arg2);
43704 wxPyEndAllowThreads(__tstate);
43705 if (PyErr_Occurred()) SWIG_fail;
43706 }
43707 {
43708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43709 }
43710 return resultobj;
43711 fail:
43712 return NULL;
43713 }
43714
43715
43716 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43717 PyObject *resultobj = 0;
43718 wxMenu *arg1 = (wxMenu *) 0 ;
43719 size_t result;
43720 void *argp1 = 0 ;
43721 int res1 = 0 ;
43722 PyObject *swig_obj[1] ;
43723
43724 if (!args) SWIG_fail;
43725 swig_obj[0] = args;
43726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43727 if (!SWIG_IsOK(res1)) {
43728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
43729 }
43730 arg1 = reinterpret_cast< wxMenu * >(argp1);
43731 {
43732 PyThreadState* __tstate = wxPyBeginAllowThreads();
43733 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
43734 wxPyEndAllowThreads(__tstate);
43735 if (PyErr_Occurred()) SWIG_fail;
43736 }
43737 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
43738 return resultobj;
43739 fail:
43740 return NULL;
43741 }
43742
43743
43744 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43745 PyObject *resultobj = 0;
43746 wxMenu *arg1 = (wxMenu *) 0 ;
43747 PyObject *result = 0 ;
43748 void *argp1 = 0 ;
43749 int res1 = 0 ;
43750 PyObject *swig_obj[1] ;
43751
43752 if (!args) SWIG_fail;
43753 swig_obj[0] = args;
43754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43755 if (!SWIG_IsOK(res1)) {
43756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
43757 }
43758 arg1 = reinterpret_cast< wxMenu * >(argp1);
43759 {
43760 PyThreadState* __tstate = wxPyBeginAllowThreads();
43761 result = (PyObject *)wxMenu_GetMenuItems(arg1);
43762 wxPyEndAllowThreads(__tstate);
43763 if (PyErr_Occurred()) SWIG_fail;
43764 }
43765 resultobj = result;
43766 return resultobj;
43767 fail:
43768 return NULL;
43769 }
43770
43771
43772 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43773 PyObject *resultobj = 0;
43774 wxMenu *arg1 = (wxMenu *) 0 ;
43775 wxString *arg2 = 0 ;
43776 int result;
43777 void *argp1 = 0 ;
43778 int res1 = 0 ;
43779 bool temp2 = false ;
43780 PyObject * obj0 = 0 ;
43781 PyObject * obj1 = 0 ;
43782 char * kwnames[] = {
43783 (char *) "self",(char *) "item", NULL
43784 };
43785
43786 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
43787 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43788 if (!SWIG_IsOK(res1)) {
43789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
43790 }
43791 arg1 = reinterpret_cast< wxMenu * >(argp1);
43792 {
43793 arg2 = wxString_in_helper(obj1);
43794 if (arg2 == NULL) SWIG_fail;
43795 temp2 = true;
43796 }
43797 {
43798 PyThreadState* __tstate = wxPyBeginAllowThreads();
43799 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
43800 wxPyEndAllowThreads(__tstate);
43801 if (PyErr_Occurred()) SWIG_fail;
43802 }
43803 resultobj = SWIG_From_int(static_cast< int >(result));
43804 {
43805 if (temp2)
43806 delete arg2;
43807 }
43808 return resultobj;
43809 fail:
43810 {
43811 if (temp2)
43812 delete arg2;
43813 }
43814 return NULL;
43815 }
43816
43817
43818 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43819 PyObject *resultobj = 0;
43820 wxMenu *arg1 = (wxMenu *) 0 ;
43821 int arg2 ;
43822 wxMenuItem *result = 0 ;
43823 void *argp1 = 0 ;
43824 int res1 = 0 ;
43825 int val2 ;
43826 int ecode2 = 0 ;
43827 PyObject * obj0 = 0 ;
43828 PyObject * obj1 = 0 ;
43829 char * kwnames[] = {
43830 (char *) "self",(char *) "id", NULL
43831 };
43832
43833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
43834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43835 if (!SWIG_IsOK(res1)) {
43836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
43837 }
43838 arg1 = reinterpret_cast< wxMenu * >(argp1);
43839 ecode2 = SWIG_AsVal_int(obj1, &val2);
43840 if (!SWIG_IsOK(ecode2)) {
43841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
43842 }
43843 arg2 = static_cast< int >(val2);
43844 {
43845 PyThreadState* __tstate = wxPyBeginAllowThreads();
43846 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
43847 wxPyEndAllowThreads(__tstate);
43848 if (PyErr_Occurred()) SWIG_fail;
43849 }
43850 {
43851 resultobj = wxPyMake_wxObject(result, (bool)0);
43852 }
43853 return resultobj;
43854 fail:
43855 return NULL;
43856 }
43857
43858
43859 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43860 PyObject *resultobj = 0;
43861 wxMenu *arg1 = (wxMenu *) 0 ;
43862 size_t arg2 ;
43863 wxMenuItem *result = 0 ;
43864 void *argp1 = 0 ;
43865 int res1 = 0 ;
43866 size_t val2 ;
43867 int ecode2 = 0 ;
43868 PyObject * obj0 = 0 ;
43869 PyObject * obj1 = 0 ;
43870 char * kwnames[] = {
43871 (char *) "self",(char *) "position", NULL
43872 };
43873
43874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
43875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43876 if (!SWIG_IsOK(res1)) {
43877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
43878 }
43879 arg1 = reinterpret_cast< wxMenu * >(argp1);
43880 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43881 if (!SWIG_IsOK(ecode2)) {
43882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
43883 }
43884 arg2 = static_cast< size_t >(val2);
43885 {
43886 PyThreadState* __tstate = wxPyBeginAllowThreads();
43887 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
43888 wxPyEndAllowThreads(__tstate);
43889 if (PyErr_Occurred()) SWIG_fail;
43890 }
43891 {
43892 resultobj = wxPyMake_wxObject(result, (bool)0);
43893 }
43894 return resultobj;
43895 fail:
43896 return NULL;
43897 }
43898
43899
43900 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43901 PyObject *resultobj = 0;
43902 wxMenu *arg1 = (wxMenu *) 0 ;
43903 int arg2 ;
43904 bool arg3 ;
43905 void *argp1 = 0 ;
43906 int res1 = 0 ;
43907 int val2 ;
43908 int ecode2 = 0 ;
43909 bool val3 ;
43910 int ecode3 = 0 ;
43911 PyObject * obj0 = 0 ;
43912 PyObject * obj1 = 0 ;
43913 PyObject * obj2 = 0 ;
43914 char * kwnames[] = {
43915 (char *) "self",(char *) "id",(char *) "enable", NULL
43916 };
43917
43918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43920 if (!SWIG_IsOK(res1)) {
43921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
43922 }
43923 arg1 = reinterpret_cast< wxMenu * >(argp1);
43924 ecode2 = SWIG_AsVal_int(obj1, &val2);
43925 if (!SWIG_IsOK(ecode2)) {
43926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
43927 }
43928 arg2 = static_cast< int >(val2);
43929 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43930 if (!SWIG_IsOK(ecode3)) {
43931 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
43932 }
43933 arg3 = static_cast< bool >(val3);
43934 {
43935 PyThreadState* __tstate = wxPyBeginAllowThreads();
43936 (arg1)->Enable(arg2,arg3);
43937 wxPyEndAllowThreads(__tstate);
43938 if (PyErr_Occurred()) SWIG_fail;
43939 }
43940 resultobj = SWIG_Py_Void();
43941 return resultobj;
43942 fail:
43943 return NULL;
43944 }
43945
43946
43947 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43948 PyObject *resultobj = 0;
43949 wxMenu *arg1 = (wxMenu *) 0 ;
43950 int arg2 ;
43951 bool result;
43952 void *argp1 = 0 ;
43953 int res1 = 0 ;
43954 int val2 ;
43955 int ecode2 = 0 ;
43956 PyObject * obj0 = 0 ;
43957 PyObject * obj1 = 0 ;
43958 char * kwnames[] = {
43959 (char *) "self",(char *) "id", NULL
43960 };
43961
43962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
43963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43964 if (!SWIG_IsOK(res1)) {
43965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
43966 }
43967 arg1 = reinterpret_cast< wxMenu * >(argp1);
43968 ecode2 = SWIG_AsVal_int(obj1, &val2);
43969 if (!SWIG_IsOK(ecode2)) {
43970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
43971 }
43972 arg2 = static_cast< int >(val2);
43973 {
43974 PyThreadState* __tstate = wxPyBeginAllowThreads();
43975 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
43976 wxPyEndAllowThreads(__tstate);
43977 if (PyErr_Occurred()) SWIG_fail;
43978 }
43979 {
43980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43981 }
43982 return resultobj;
43983 fail:
43984 return NULL;
43985 }
43986
43987
43988 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43989 PyObject *resultobj = 0;
43990 wxMenu *arg1 = (wxMenu *) 0 ;
43991 int arg2 ;
43992 bool arg3 ;
43993 void *argp1 = 0 ;
43994 int res1 = 0 ;
43995 int val2 ;
43996 int ecode2 = 0 ;
43997 bool val3 ;
43998 int ecode3 = 0 ;
43999 PyObject * obj0 = 0 ;
44000 PyObject * obj1 = 0 ;
44001 PyObject * obj2 = 0 ;
44002 char * kwnames[] = {
44003 (char *) "self",(char *) "id",(char *) "check", NULL
44004 };
44005
44006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44008 if (!SWIG_IsOK(res1)) {
44009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
44010 }
44011 arg1 = reinterpret_cast< wxMenu * >(argp1);
44012 ecode2 = SWIG_AsVal_int(obj1, &val2);
44013 if (!SWIG_IsOK(ecode2)) {
44014 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
44015 }
44016 arg2 = static_cast< int >(val2);
44017 ecode3 = SWIG_AsVal_bool(obj2, &val3);
44018 if (!SWIG_IsOK(ecode3)) {
44019 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
44020 }
44021 arg3 = static_cast< bool >(val3);
44022 {
44023 PyThreadState* __tstate = wxPyBeginAllowThreads();
44024 (arg1)->Check(arg2,arg3);
44025 wxPyEndAllowThreads(__tstate);
44026 if (PyErr_Occurred()) SWIG_fail;
44027 }
44028 resultobj = SWIG_Py_Void();
44029 return resultobj;
44030 fail:
44031 return NULL;
44032 }
44033
44034
44035 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44036 PyObject *resultobj = 0;
44037 wxMenu *arg1 = (wxMenu *) 0 ;
44038 int arg2 ;
44039 bool result;
44040 void *argp1 = 0 ;
44041 int res1 = 0 ;
44042 int val2 ;
44043 int ecode2 = 0 ;
44044 PyObject * obj0 = 0 ;
44045 PyObject * obj1 = 0 ;
44046 char * kwnames[] = {
44047 (char *) "self",(char *) "id", NULL
44048 };
44049
44050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
44051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44052 if (!SWIG_IsOK(res1)) {
44053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
44054 }
44055 arg1 = reinterpret_cast< wxMenu * >(argp1);
44056 ecode2 = SWIG_AsVal_int(obj1, &val2);
44057 if (!SWIG_IsOK(ecode2)) {
44058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
44059 }
44060 arg2 = static_cast< int >(val2);
44061 {
44062 PyThreadState* __tstate = wxPyBeginAllowThreads();
44063 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
44064 wxPyEndAllowThreads(__tstate);
44065 if (PyErr_Occurred()) SWIG_fail;
44066 }
44067 {
44068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44069 }
44070 return resultobj;
44071 fail:
44072 return NULL;
44073 }
44074
44075
44076 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44077 PyObject *resultobj = 0;
44078 wxMenu *arg1 = (wxMenu *) 0 ;
44079 int arg2 ;
44080 wxString *arg3 = 0 ;
44081 void *argp1 = 0 ;
44082 int res1 = 0 ;
44083 int val2 ;
44084 int ecode2 = 0 ;
44085 bool temp3 = false ;
44086 PyObject * obj0 = 0 ;
44087 PyObject * obj1 = 0 ;
44088 PyObject * obj2 = 0 ;
44089 char * kwnames[] = {
44090 (char *) "self",(char *) "id",(char *) "label", NULL
44091 };
44092
44093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44095 if (!SWIG_IsOK(res1)) {
44096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
44097 }
44098 arg1 = reinterpret_cast< wxMenu * >(argp1);
44099 ecode2 = SWIG_AsVal_int(obj1, &val2);
44100 if (!SWIG_IsOK(ecode2)) {
44101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
44102 }
44103 arg2 = static_cast< int >(val2);
44104 {
44105 arg3 = wxString_in_helper(obj2);
44106 if (arg3 == NULL) SWIG_fail;
44107 temp3 = true;
44108 }
44109 {
44110 PyThreadState* __tstate = wxPyBeginAllowThreads();
44111 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
44112 wxPyEndAllowThreads(__tstate);
44113 if (PyErr_Occurred()) SWIG_fail;
44114 }
44115 resultobj = SWIG_Py_Void();
44116 {
44117 if (temp3)
44118 delete arg3;
44119 }
44120 return resultobj;
44121 fail:
44122 {
44123 if (temp3)
44124 delete arg3;
44125 }
44126 return NULL;
44127 }
44128
44129
44130 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44131 PyObject *resultobj = 0;
44132 wxMenu *arg1 = (wxMenu *) 0 ;
44133 int arg2 ;
44134 wxString result;
44135 void *argp1 = 0 ;
44136 int res1 = 0 ;
44137 int val2 ;
44138 int ecode2 = 0 ;
44139 PyObject * obj0 = 0 ;
44140 PyObject * obj1 = 0 ;
44141 char * kwnames[] = {
44142 (char *) "self",(char *) "id", NULL
44143 };
44144
44145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
44146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44147 if (!SWIG_IsOK(res1)) {
44148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
44149 }
44150 arg1 = reinterpret_cast< wxMenu * >(argp1);
44151 ecode2 = SWIG_AsVal_int(obj1, &val2);
44152 if (!SWIG_IsOK(ecode2)) {
44153 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
44154 }
44155 arg2 = static_cast< int >(val2);
44156 {
44157 PyThreadState* __tstate = wxPyBeginAllowThreads();
44158 result = ((wxMenu const *)arg1)->GetLabel(arg2);
44159 wxPyEndAllowThreads(__tstate);
44160 if (PyErr_Occurred()) SWIG_fail;
44161 }
44162 {
44163 #if wxUSE_UNICODE
44164 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44165 #else
44166 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44167 #endif
44168 }
44169 return resultobj;
44170 fail:
44171 return NULL;
44172 }
44173
44174
44175 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44176 PyObject *resultobj = 0;
44177 wxMenu *arg1 = (wxMenu *) 0 ;
44178 int arg2 ;
44179 wxString *arg3 = 0 ;
44180 void *argp1 = 0 ;
44181 int res1 = 0 ;
44182 int val2 ;
44183 int ecode2 = 0 ;
44184 bool temp3 = false ;
44185 PyObject * obj0 = 0 ;
44186 PyObject * obj1 = 0 ;
44187 PyObject * obj2 = 0 ;
44188 char * kwnames[] = {
44189 (char *) "self",(char *) "id",(char *) "helpString", NULL
44190 };
44191
44192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44194 if (!SWIG_IsOK(res1)) {
44195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
44196 }
44197 arg1 = reinterpret_cast< wxMenu * >(argp1);
44198 ecode2 = SWIG_AsVal_int(obj1, &val2);
44199 if (!SWIG_IsOK(ecode2)) {
44200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
44201 }
44202 arg2 = static_cast< int >(val2);
44203 {
44204 arg3 = wxString_in_helper(obj2);
44205 if (arg3 == NULL) SWIG_fail;
44206 temp3 = true;
44207 }
44208 {
44209 PyThreadState* __tstate = wxPyBeginAllowThreads();
44210 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
44211 wxPyEndAllowThreads(__tstate);
44212 if (PyErr_Occurred()) SWIG_fail;
44213 }
44214 resultobj = SWIG_Py_Void();
44215 {
44216 if (temp3)
44217 delete arg3;
44218 }
44219 return resultobj;
44220 fail:
44221 {
44222 if (temp3)
44223 delete arg3;
44224 }
44225 return NULL;
44226 }
44227
44228
44229 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44230 PyObject *resultobj = 0;
44231 wxMenu *arg1 = (wxMenu *) 0 ;
44232 int arg2 ;
44233 wxString result;
44234 void *argp1 = 0 ;
44235 int res1 = 0 ;
44236 int val2 ;
44237 int ecode2 = 0 ;
44238 PyObject * obj0 = 0 ;
44239 PyObject * obj1 = 0 ;
44240 char * kwnames[] = {
44241 (char *) "self",(char *) "id", NULL
44242 };
44243
44244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
44245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44246 if (!SWIG_IsOK(res1)) {
44247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
44248 }
44249 arg1 = reinterpret_cast< wxMenu * >(argp1);
44250 ecode2 = SWIG_AsVal_int(obj1, &val2);
44251 if (!SWIG_IsOK(ecode2)) {
44252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
44253 }
44254 arg2 = static_cast< int >(val2);
44255 {
44256 PyThreadState* __tstate = wxPyBeginAllowThreads();
44257 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
44258 wxPyEndAllowThreads(__tstate);
44259 if (PyErr_Occurred()) SWIG_fail;
44260 }
44261 {
44262 #if wxUSE_UNICODE
44263 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44264 #else
44265 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44266 #endif
44267 }
44268 return resultobj;
44269 fail:
44270 return NULL;
44271 }
44272
44273
44274 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44275 PyObject *resultobj = 0;
44276 wxMenu *arg1 = (wxMenu *) 0 ;
44277 wxString *arg2 = 0 ;
44278 void *argp1 = 0 ;
44279 int res1 = 0 ;
44280 bool temp2 = false ;
44281 PyObject * obj0 = 0 ;
44282 PyObject * obj1 = 0 ;
44283 char * kwnames[] = {
44284 (char *) "self",(char *) "title", NULL
44285 };
44286
44287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
44288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44289 if (!SWIG_IsOK(res1)) {
44290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
44291 }
44292 arg1 = reinterpret_cast< wxMenu * >(argp1);
44293 {
44294 arg2 = wxString_in_helper(obj1);
44295 if (arg2 == NULL) SWIG_fail;
44296 temp2 = true;
44297 }
44298 {
44299 PyThreadState* __tstate = wxPyBeginAllowThreads();
44300 (arg1)->SetTitle((wxString const &)*arg2);
44301 wxPyEndAllowThreads(__tstate);
44302 if (PyErr_Occurred()) SWIG_fail;
44303 }
44304 resultobj = SWIG_Py_Void();
44305 {
44306 if (temp2)
44307 delete arg2;
44308 }
44309 return resultobj;
44310 fail:
44311 {
44312 if (temp2)
44313 delete arg2;
44314 }
44315 return NULL;
44316 }
44317
44318
44319 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44320 PyObject *resultobj = 0;
44321 wxMenu *arg1 = (wxMenu *) 0 ;
44322 wxString result;
44323 void *argp1 = 0 ;
44324 int res1 = 0 ;
44325 PyObject *swig_obj[1] ;
44326
44327 if (!args) SWIG_fail;
44328 swig_obj[0] = args;
44329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44330 if (!SWIG_IsOK(res1)) {
44331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44332 }
44333 arg1 = reinterpret_cast< wxMenu * >(argp1);
44334 {
44335 PyThreadState* __tstate = wxPyBeginAllowThreads();
44336 result = ((wxMenu const *)arg1)->GetTitle();
44337 wxPyEndAllowThreads(__tstate);
44338 if (PyErr_Occurred()) SWIG_fail;
44339 }
44340 {
44341 #if wxUSE_UNICODE
44342 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44343 #else
44344 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44345 #endif
44346 }
44347 return resultobj;
44348 fail:
44349 return NULL;
44350 }
44351
44352
44353 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44354 PyObject *resultobj = 0;
44355 wxMenu *arg1 = (wxMenu *) 0 ;
44356 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
44357 void *argp1 = 0 ;
44358 int res1 = 0 ;
44359 void *argp2 = 0 ;
44360 int res2 = 0 ;
44361 PyObject * obj0 = 0 ;
44362 PyObject * obj1 = 0 ;
44363 char * kwnames[] = {
44364 (char *) "self",(char *) "handler", NULL
44365 };
44366
44367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
44368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44369 if (!SWIG_IsOK(res1)) {
44370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
44371 }
44372 arg1 = reinterpret_cast< wxMenu * >(argp1);
44373 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44374 if (!SWIG_IsOK(res2)) {
44375 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44376 }
44377 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44378 {
44379 PyThreadState* __tstate = wxPyBeginAllowThreads();
44380 (arg1)->SetEventHandler(arg2);
44381 wxPyEndAllowThreads(__tstate);
44382 if (PyErr_Occurred()) SWIG_fail;
44383 }
44384 resultobj = SWIG_Py_Void();
44385 return resultobj;
44386 fail:
44387 return NULL;
44388 }
44389
44390
44391 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44392 PyObject *resultobj = 0;
44393 wxMenu *arg1 = (wxMenu *) 0 ;
44394 wxEvtHandler *result = 0 ;
44395 void *argp1 = 0 ;
44396 int res1 = 0 ;
44397 PyObject *swig_obj[1] ;
44398
44399 if (!args) SWIG_fail;
44400 swig_obj[0] = args;
44401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44402 if (!SWIG_IsOK(res1)) {
44403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
44404 }
44405 arg1 = reinterpret_cast< wxMenu * >(argp1);
44406 {
44407 PyThreadState* __tstate = wxPyBeginAllowThreads();
44408 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
44409 wxPyEndAllowThreads(__tstate);
44410 if (PyErr_Occurred()) SWIG_fail;
44411 }
44412 {
44413 resultobj = wxPyMake_wxObject(result, 0);
44414 }
44415 return resultobj;
44416 fail:
44417 return NULL;
44418 }
44419
44420
44421 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44422 PyObject *resultobj = 0;
44423 wxMenu *arg1 = (wxMenu *) 0 ;
44424 wxWindow *arg2 = (wxWindow *) 0 ;
44425 void *argp1 = 0 ;
44426 int res1 = 0 ;
44427 void *argp2 = 0 ;
44428 int res2 = 0 ;
44429 PyObject * obj0 = 0 ;
44430 PyObject * obj1 = 0 ;
44431 char * kwnames[] = {
44432 (char *) "self",(char *) "win", NULL
44433 };
44434
44435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
44436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44437 if (!SWIG_IsOK(res1)) {
44438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
44439 }
44440 arg1 = reinterpret_cast< wxMenu * >(argp1);
44441 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44442 if (!SWIG_IsOK(res2)) {
44443 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
44444 }
44445 arg2 = reinterpret_cast< wxWindow * >(argp2);
44446 {
44447 PyThreadState* __tstate = wxPyBeginAllowThreads();
44448 (arg1)->SetInvokingWindow(arg2);
44449 wxPyEndAllowThreads(__tstate);
44450 if (PyErr_Occurred()) SWIG_fail;
44451 }
44452 resultobj = SWIG_Py_Void();
44453 return resultobj;
44454 fail:
44455 return NULL;
44456 }
44457
44458
44459 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44460 PyObject *resultobj = 0;
44461 wxMenu *arg1 = (wxMenu *) 0 ;
44462 wxWindow *result = 0 ;
44463 void *argp1 = 0 ;
44464 int res1 = 0 ;
44465 PyObject *swig_obj[1] ;
44466
44467 if (!args) SWIG_fail;
44468 swig_obj[0] = args;
44469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44470 if (!SWIG_IsOK(res1)) {
44471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
44472 }
44473 arg1 = reinterpret_cast< wxMenu * >(argp1);
44474 {
44475 PyThreadState* __tstate = wxPyBeginAllowThreads();
44476 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
44477 wxPyEndAllowThreads(__tstate);
44478 if (PyErr_Occurred()) SWIG_fail;
44479 }
44480 {
44481 resultobj = wxPyMake_wxObject(result, 0);
44482 }
44483 return resultobj;
44484 fail:
44485 return NULL;
44486 }
44487
44488
44489 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44490 PyObject *resultobj = 0;
44491 wxMenu *arg1 = (wxMenu *) 0 ;
44492 long result;
44493 void *argp1 = 0 ;
44494 int res1 = 0 ;
44495 PyObject *swig_obj[1] ;
44496
44497 if (!args) SWIG_fail;
44498 swig_obj[0] = args;
44499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44500 if (!SWIG_IsOK(res1)) {
44501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44502 }
44503 arg1 = reinterpret_cast< wxMenu * >(argp1);
44504 {
44505 PyThreadState* __tstate = wxPyBeginAllowThreads();
44506 result = (long)((wxMenu const *)arg1)->GetStyle();
44507 wxPyEndAllowThreads(__tstate);
44508 if (PyErr_Occurred()) SWIG_fail;
44509 }
44510 resultobj = SWIG_From_long(static_cast< long >(result));
44511 return resultobj;
44512 fail:
44513 return NULL;
44514 }
44515
44516
44517 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44518 PyObject *resultobj = 0;
44519 wxMenu *arg1 = (wxMenu *) 0 ;
44520 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
44521 void *argp1 = 0 ;
44522 int res1 = 0 ;
44523 void *argp2 = 0 ;
44524 int res2 = 0 ;
44525 PyObject * obj0 = 0 ;
44526 PyObject * obj1 = 0 ;
44527 char * kwnames[] = {
44528 (char *) "self",(char *) "source", NULL
44529 };
44530
44531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
44532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44533 if (!SWIG_IsOK(res1)) {
44534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
44535 }
44536 arg1 = reinterpret_cast< wxMenu * >(argp1);
44537 if (obj1) {
44538 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44539 if (!SWIG_IsOK(res2)) {
44540 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44541 }
44542 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44543 }
44544 {
44545 PyThreadState* __tstate = wxPyBeginAllowThreads();
44546 (arg1)->UpdateUI(arg2);
44547 wxPyEndAllowThreads(__tstate);
44548 if (PyErr_Occurred()) SWIG_fail;
44549 }
44550 resultobj = SWIG_Py_Void();
44551 return resultobj;
44552 fail:
44553 return NULL;
44554 }
44555
44556
44557 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44558 PyObject *resultobj = 0;
44559 wxMenu *arg1 = (wxMenu *) 0 ;
44560 wxMenuBar *result = 0 ;
44561 void *argp1 = 0 ;
44562 int res1 = 0 ;
44563 PyObject *swig_obj[1] ;
44564
44565 if (!args) SWIG_fail;
44566 swig_obj[0] = args;
44567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44568 if (!SWIG_IsOK(res1)) {
44569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
44570 }
44571 arg1 = reinterpret_cast< wxMenu * >(argp1);
44572 {
44573 PyThreadState* __tstate = wxPyBeginAllowThreads();
44574 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
44575 wxPyEndAllowThreads(__tstate);
44576 if (PyErr_Occurred()) SWIG_fail;
44577 }
44578 {
44579 resultobj = wxPyMake_wxObject(result, (bool)0);
44580 }
44581 return resultobj;
44582 fail:
44583 return NULL;
44584 }
44585
44586
44587 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44588 PyObject *resultobj = 0;
44589 wxMenu *arg1 = (wxMenu *) 0 ;
44590 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
44591 void *argp1 = 0 ;
44592 int res1 = 0 ;
44593 void *argp2 = 0 ;
44594 int res2 = 0 ;
44595 PyObject * obj0 = 0 ;
44596 PyObject * obj1 = 0 ;
44597 char * kwnames[] = {
44598 (char *) "self",(char *) "menubar", NULL
44599 };
44600
44601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
44602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44603 if (!SWIG_IsOK(res1)) {
44604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
44605 }
44606 arg1 = reinterpret_cast< wxMenu * >(argp1);
44607 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
44608 if (!SWIG_IsOK(res2)) {
44609 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
44610 }
44611 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
44612 {
44613 PyThreadState* __tstate = wxPyBeginAllowThreads();
44614 (arg1)->Attach(arg2);
44615 wxPyEndAllowThreads(__tstate);
44616 if (PyErr_Occurred()) SWIG_fail;
44617 }
44618 resultobj = SWIG_Py_Void();
44619 return resultobj;
44620 fail:
44621 return NULL;
44622 }
44623
44624
44625 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44626 PyObject *resultobj = 0;
44627 wxMenu *arg1 = (wxMenu *) 0 ;
44628 void *argp1 = 0 ;
44629 int res1 = 0 ;
44630 PyObject *swig_obj[1] ;
44631
44632 if (!args) SWIG_fail;
44633 swig_obj[0] = args;
44634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44635 if (!SWIG_IsOK(res1)) {
44636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
44637 }
44638 arg1 = reinterpret_cast< wxMenu * >(argp1);
44639 {
44640 PyThreadState* __tstate = wxPyBeginAllowThreads();
44641 (arg1)->Detach();
44642 wxPyEndAllowThreads(__tstate);
44643 if (PyErr_Occurred()) SWIG_fail;
44644 }
44645 resultobj = SWIG_Py_Void();
44646 return resultobj;
44647 fail:
44648 return NULL;
44649 }
44650
44651
44652 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44653 PyObject *resultobj = 0;
44654 wxMenu *arg1 = (wxMenu *) 0 ;
44655 bool result;
44656 void *argp1 = 0 ;
44657 int res1 = 0 ;
44658 PyObject *swig_obj[1] ;
44659
44660 if (!args) SWIG_fail;
44661 swig_obj[0] = args;
44662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44663 if (!SWIG_IsOK(res1)) {
44664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
44665 }
44666 arg1 = reinterpret_cast< wxMenu * >(argp1);
44667 {
44668 PyThreadState* __tstate = wxPyBeginAllowThreads();
44669 result = (bool)((wxMenu const *)arg1)->IsAttached();
44670 wxPyEndAllowThreads(__tstate);
44671 if (PyErr_Occurred()) SWIG_fail;
44672 }
44673 {
44674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44675 }
44676 return resultobj;
44677 fail:
44678 return NULL;
44679 }
44680
44681
44682 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44683 PyObject *resultobj = 0;
44684 wxMenu *arg1 = (wxMenu *) 0 ;
44685 wxMenu *arg2 = (wxMenu *) 0 ;
44686 void *argp1 = 0 ;
44687 int res1 = 0 ;
44688 void *argp2 = 0 ;
44689 int res2 = 0 ;
44690 PyObject * obj0 = 0 ;
44691 PyObject * obj1 = 0 ;
44692 char * kwnames[] = {
44693 (char *) "self",(char *) "parent", NULL
44694 };
44695
44696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
44697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44698 if (!SWIG_IsOK(res1)) {
44699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
44700 }
44701 arg1 = reinterpret_cast< wxMenu * >(argp1);
44702 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44703 if (!SWIG_IsOK(res2)) {
44704 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
44705 }
44706 arg2 = reinterpret_cast< wxMenu * >(argp2);
44707 {
44708 PyThreadState* __tstate = wxPyBeginAllowThreads();
44709 (arg1)->SetParent(arg2);
44710 wxPyEndAllowThreads(__tstate);
44711 if (PyErr_Occurred()) SWIG_fail;
44712 }
44713 resultobj = SWIG_Py_Void();
44714 return resultobj;
44715 fail:
44716 return NULL;
44717 }
44718
44719
44720 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44721 PyObject *resultobj = 0;
44722 wxMenu *arg1 = (wxMenu *) 0 ;
44723 wxMenu *result = 0 ;
44724 void *argp1 = 0 ;
44725 int res1 = 0 ;
44726 PyObject *swig_obj[1] ;
44727
44728 if (!args) SWIG_fail;
44729 swig_obj[0] = args;
44730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44731 if (!SWIG_IsOK(res1)) {
44732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
44733 }
44734 arg1 = reinterpret_cast< wxMenu * >(argp1);
44735 {
44736 PyThreadState* __tstate = wxPyBeginAllowThreads();
44737 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
44738 wxPyEndAllowThreads(__tstate);
44739 if (PyErr_Occurred()) SWIG_fail;
44740 }
44741 {
44742 resultobj = wxPyMake_wxObject(result, 0);
44743 }
44744 return resultobj;
44745 fail:
44746 return NULL;
44747 }
44748
44749
44750 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44751 PyObject *obj;
44752 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44753 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
44754 return SWIG_Py_Void();
44755 }
44756
44757 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44758 return SWIG_Python_InitShadowInstance(args);
44759 }
44760
44761 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44762 PyObject *resultobj = 0;
44763 long arg1 = (long) 0 ;
44764 wxMenuBar *result = 0 ;
44765 long val1 ;
44766 int ecode1 = 0 ;
44767 PyObject * obj0 = 0 ;
44768 char * kwnames[] = {
44769 (char *) "style", NULL
44770 };
44771
44772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
44773 if (obj0) {
44774 ecode1 = SWIG_AsVal_long(obj0, &val1);
44775 if (!SWIG_IsOK(ecode1)) {
44776 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
44777 }
44778 arg1 = static_cast< long >(val1);
44779 }
44780 {
44781 if (!wxPyCheckForApp()) SWIG_fail;
44782 PyThreadState* __tstate = wxPyBeginAllowThreads();
44783 result = (wxMenuBar *)new wxMenuBar(arg1);
44784 wxPyEndAllowThreads(__tstate);
44785 if (PyErr_Occurred()) SWIG_fail;
44786 }
44787 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
44788 return resultobj;
44789 fail:
44790 return NULL;
44791 }
44792
44793
44794 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44795 PyObject *resultobj = 0;
44796 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44797 wxMenu *arg2 = (wxMenu *) 0 ;
44798 wxString *arg3 = 0 ;
44799 bool result;
44800 void *argp1 = 0 ;
44801 int res1 = 0 ;
44802 void *argp2 = 0 ;
44803 int res2 = 0 ;
44804 bool temp3 = false ;
44805 PyObject * obj0 = 0 ;
44806 PyObject * obj1 = 0 ;
44807 PyObject * obj2 = 0 ;
44808 char * kwnames[] = {
44809 (char *) "self",(char *) "menu",(char *) "title", NULL
44810 };
44811
44812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44814 if (!SWIG_IsOK(res1)) {
44815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44816 }
44817 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44818 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44819 if (!SWIG_IsOK(res2)) {
44820 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
44821 }
44822 arg2 = reinterpret_cast< wxMenu * >(argp2);
44823 {
44824 arg3 = wxString_in_helper(obj2);
44825 if (arg3 == NULL) SWIG_fail;
44826 temp3 = true;
44827 }
44828 {
44829 PyThreadState* __tstate = wxPyBeginAllowThreads();
44830 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
44831 wxPyEndAllowThreads(__tstate);
44832 if (PyErr_Occurred()) SWIG_fail;
44833 }
44834 {
44835 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44836 }
44837 {
44838 if (temp3)
44839 delete arg3;
44840 }
44841 return resultobj;
44842 fail:
44843 {
44844 if (temp3)
44845 delete arg3;
44846 }
44847 return NULL;
44848 }
44849
44850
44851 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44852 PyObject *resultobj = 0;
44853 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44854 size_t arg2 ;
44855 wxMenu *arg3 = (wxMenu *) 0 ;
44856 wxString *arg4 = 0 ;
44857 bool result;
44858 void *argp1 = 0 ;
44859 int res1 = 0 ;
44860 size_t val2 ;
44861 int ecode2 = 0 ;
44862 void *argp3 = 0 ;
44863 int res3 = 0 ;
44864 bool temp4 = false ;
44865 PyObject * obj0 = 0 ;
44866 PyObject * obj1 = 0 ;
44867 PyObject * obj2 = 0 ;
44868 PyObject * obj3 = 0 ;
44869 char * kwnames[] = {
44870 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44871 };
44872
44873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44875 if (!SWIG_IsOK(res1)) {
44876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44877 }
44878 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44879 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44880 if (!SWIG_IsOK(ecode2)) {
44881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
44882 }
44883 arg2 = static_cast< size_t >(val2);
44884 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44885 if (!SWIG_IsOK(res3)) {
44886 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
44887 }
44888 arg3 = reinterpret_cast< wxMenu * >(argp3);
44889 {
44890 arg4 = wxString_in_helper(obj3);
44891 if (arg4 == NULL) SWIG_fail;
44892 temp4 = true;
44893 }
44894 {
44895 PyThreadState* __tstate = wxPyBeginAllowThreads();
44896 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
44897 wxPyEndAllowThreads(__tstate);
44898 if (PyErr_Occurred()) SWIG_fail;
44899 }
44900 {
44901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44902 }
44903 {
44904 if (temp4)
44905 delete arg4;
44906 }
44907 return resultobj;
44908 fail:
44909 {
44910 if (temp4)
44911 delete arg4;
44912 }
44913 return NULL;
44914 }
44915
44916
44917 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44918 PyObject *resultobj = 0;
44919 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44920 size_t result;
44921 void *argp1 = 0 ;
44922 int res1 = 0 ;
44923 PyObject *swig_obj[1] ;
44924
44925 if (!args) SWIG_fail;
44926 swig_obj[0] = args;
44927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44928 if (!SWIG_IsOK(res1)) {
44929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44930 }
44931 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44932 {
44933 PyThreadState* __tstate = wxPyBeginAllowThreads();
44934 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
44935 wxPyEndAllowThreads(__tstate);
44936 if (PyErr_Occurred()) SWIG_fail;
44937 }
44938 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
44939 return resultobj;
44940 fail:
44941 return NULL;
44942 }
44943
44944
44945 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44946 PyObject *resultobj = 0;
44947 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44948 size_t arg2 ;
44949 wxMenu *result = 0 ;
44950 void *argp1 = 0 ;
44951 int res1 = 0 ;
44952 size_t val2 ;
44953 int ecode2 = 0 ;
44954 PyObject * obj0 = 0 ;
44955 PyObject * obj1 = 0 ;
44956 char * kwnames[] = {
44957 (char *) "self",(char *) "pos", NULL
44958 };
44959
44960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44962 if (!SWIG_IsOK(res1)) {
44963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44964 }
44965 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44966 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44967 if (!SWIG_IsOK(ecode2)) {
44968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
44969 }
44970 arg2 = static_cast< size_t >(val2);
44971 {
44972 PyThreadState* __tstate = wxPyBeginAllowThreads();
44973 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
44974 wxPyEndAllowThreads(__tstate);
44975 if (PyErr_Occurred()) SWIG_fail;
44976 }
44977 {
44978 resultobj = wxPyMake_wxObject(result, 0);
44979 }
44980 return resultobj;
44981 fail:
44982 return NULL;
44983 }
44984
44985
44986 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44987 PyObject *resultobj = 0;
44988 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44989 size_t arg2 ;
44990 wxMenu *arg3 = (wxMenu *) 0 ;
44991 wxString *arg4 = 0 ;
44992 wxMenu *result = 0 ;
44993 void *argp1 = 0 ;
44994 int res1 = 0 ;
44995 size_t val2 ;
44996 int ecode2 = 0 ;
44997 void *argp3 = 0 ;
44998 int res3 = 0 ;
44999 bool temp4 = false ;
45000 PyObject * obj0 = 0 ;
45001 PyObject * obj1 = 0 ;
45002 PyObject * obj2 = 0 ;
45003 PyObject * obj3 = 0 ;
45004 char * kwnames[] = {
45005 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
45006 };
45007
45008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
45009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45010 if (!SWIG_IsOK(res1)) {
45011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45012 }
45013 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45014 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45015 if (!SWIG_IsOK(ecode2)) {
45016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
45017 }
45018 arg2 = static_cast< size_t >(val2);
45019 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
45020 if (!SWIG_IsOK(res3)) {
45021 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
45022 }
45023 arg3 = reinterpret_cast< wxMenu * >(argp3);
45024 {
45025 arg4 = wxString_in_helper(obj3);
45026 if (arg4 == NULL) SWIG_fail;
45027 temp4 = true;
45028 }
45029 {
45030 PyThreadState* __tstate = wxPyBeginAllowThreads();
45031 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
45032 wxPyEndAllowThreads(__tstate);
45033 if (PyErr_Occurred()) SWIG_fail;
45034 }
45035 {
45036 resultobj = wxPyMake_wxObject(result, 0);
45037 }
45038 {
45039 if (temp4)
45040 delete arg4;
45041 }
45042 return resultobj;
45043 fail:
45044 {
45045 if (temp4)
45046 delete arg4;
45047 }
45048 return NULL;
45049 }
45050
45051
45052 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45053 PyObject *resultobj = 0;
45054 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45055 size_t arg2 ;
45056 wxMenu *result = 0 ;
45057 void *argp1 = 0 ;
45058 int res1 = 0 ;
45059 size_t val2 ;
45060 int ecode2 = 0 ;
45061 PyObject * obj0 = 0 ;
45062 PyObject * obj1 = 0 ;
45063 char * kwnames[] = {
45064 (char *) "self",(char *) "pos", NULL
45065 };
45066
45067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
45068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45069 if (!SWIG_IsOK(res1)) {
45070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45071 }
45072 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45073 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45074 if (!SWIG_IsOK(ecode2)) {
45075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
45076 }
45077 arg2 = static_cast< size_t >(val2);
45078 {
45079 PyThreadState* __tstate = wxPyBeginAllowThreads();
45080 result = (wxMenu *)(arg1)->Remove(arg2);
45081 wxPyEndAllowThreads(__tstate);
45082 if (PyErr_Occurred()) SWIG_fail;
45083 }
45084 {
45085 resultobj = wxPyMake_wxObject(result, 0);
45086 }
45087 return resultobj;
45088 fail:
45089 return NULL;
45090 }
45091
45092
45093 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45094 PyObject *resultobj = 0;
45095 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45096 size_t arg2 ;
45097 bool arg3 ;
45098 void *argp1 = 0 ;
45099 int res1 = 0 ;
45100 size_t val2 ;
45101 int ecode2 = 0 ;
45102 bool val3 ;
45103 int ecode3 = 0 ;
45104 PyObject * obj0 = 0 ;
45105 PyObject * obj1 = 0 ;
45106 PyObject * obj2 = 0 ;
45107 char * kwnames[] = {
45108 (char *) "self",(char *) "pos",(char *) "enable", NULL
45109 };
45110
45111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45113 if (!SWIG_IsOK(res1)) {
45114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45115 }
45116 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45117 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45118 if (!SWIG_IsOK(ecode2)) {
45119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
45120 }
45121 arg2 = static_cast< size_t >(val2);
45122 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45123 if (!SWIG_IsOK(ecode3)) {
45124 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
45125 }
45126 arg3 = static_cast< bool >(val3);
45127 {
45128 PyThreadState* __tstate = wxPyBeginAllowThreads();
45129 (arg1)->EnableTop(arg2,arg3);
45130 wxPyEndAllowThreads(__tstate);
45131 if (PyErr_Occurred()) SWIG_fail;
45132 }
45133 resultobj = SWIG_Py_Void();
45134 return resultobj;
45135 fail:
45136 return NULL;
45137 }
45138
45139
45140 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45141 PyObject *resultobj = 0;
45142 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45143 size_t arg2 ;
45144 bool result;
45145 void *argp1 = 0 ;
45146 int res1 = 0 ;
45147 size_t val2 ;
45148 int ecode2 = 0 ;
45149 PyObject * obj0 = 0 ;
45150 PyObject * obj1 = 0 ;
45151 char * kwnames[] = {
45152 (char *) "self",(char *) "pos", NULL
45153 };
45154
45155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
45156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45157 if (!SWIG_IsOK(res1)) {
45158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45159 }
45160 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45161 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45162 if (!SWIG_IsOK(ecode2)) {
45163 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
45164 }
45165 arg2 = static_cast< size_t >(val2);
45166 {
45167 PyThreadState* __tstate = wxPyBeginAllowThreads();
45168 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
45169 wxPyEndAllowThreads(__tstate);
45170 if (PyErr_Occurred()) SWIG_fail;
45171 }
45172 {
45173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45174 }
45175 return resultobj;
45176 fail:
45177 return NULL;
45178 }
45179
45180
45181 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45182 PyObject *resultobj = 0;
45183 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45184 size_t arg2 ;
45185 wxString *arg3 = 0 ;
45186 void *argp1 = 0 ;
45187 int res1 = 0 ;
45188 size_t val2 ;
45189 int ecode2 = 0 ;
45190 bool temp3 = false ;
45191 PyObject * obj0 = 0 ;
45192 PyObject * obj1 = 0 ;
45193 PyObject * obj2 = 0 ;
45194 char * kwnames[] = {
45195 (char *) "self",(char *) "pos",(char *) "label", NULL
45196 };
45197
45198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45200 if (!SWIG_IsOK(res1)) {
45201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45202 }
45203 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45204 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45205 if (!SWIG_IsOK(ecode2)) {
45206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
45207 }
45208 arg2 = static_cast< size_t >(val2);
45209 {
45210 arg3 = wxString_in_helper(obj2);
45211 if (arg3 == NULL) SWIG_fail;
45212 temp3 = true;
45213 }
45214 {
45215 PyThreadState* __tstate = wxPyBeginAllowThreads();
45216 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
45217 wxPyEndAllowThreads(__tstate);
45218 if (PyErr_Occurred()) SWIG_fail;
45219 }
45220 resultobj = SWIG_Py_Void();
45221 {
45222 if (temp3)
45223 delete arg3;
45224 }
45225 return resultobj;
45226 fail:
45227 {
45228 if (temp3)
45229 delete arg3;
45230 }
45231 return NULL;
45232 }
45233
45234
45235 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45236 PyObject *resultobj = 0;
45237 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45238 size_t arg2 ;
45239 wxString result;
45240 void *argp1 = 0 ;
45241 int res1 = 0 ;
45242 size_t val2 ;
45243 int ecode2 = 0 ;
45244 PyObject * obj0 = 0 ;
45245 PyObject * obj1 = 0 ;
45246 char * kwnames[] = {
45247 (char *) "self",(char *) "pos", NULL
45248 };
45249
45250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
45251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45252 if (!SWIG_IsOK(res1)) {
45253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45254 }
45255 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45256 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45257 if (!SWIG_IsOK(ecode2)) {
45258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
45259 }
45260 arg2 = static_cast< size_t >(val2);
45261 {
45262 PyThreadState* __tstate = wxPyBeginAllowThreads();
45263 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
45264 wxPyEndAllowThreads(__tstate);
45265 if (PyErr_Occurred()) SWIG_fail;
45266 }
45267 {
45268 #if wxUSE_UNICODE
45269 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45270 #else
45271 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45272 #endif
45273 }
45274 return resultobj;
45275 fail:
45276 return NULL;
45277 }
45278
45279
45280 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45281 PyObject *resultobj = 0;
45282 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45283 wxString *arg2 = 0 ;
45284 wxString *arg3 = 0 ;
45285 int result;
45286 void *argp1 = 0 ;
45287 int res1 = 0 ;
45288 bool temp2 = false ;
45289 bool temp3 = false ;
45290 PyObject * obj0 = 0 ;
45291 PyObject * obj1 = 0 ;
45292 PyObject * obj2 = 0 ;
45293 char * kwnames[] = {
45294 (char *) "self",(char *) "menu",(char *) "item", NULL
45295 };
45296
45297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45299 if (!SWIG_IsOK(res1)) {
45300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45301 }
45302 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45303 {
45304 arg2 = wxString_in_helper(obj1);
45305 if (arg2 == NULL) SWIG_fail;
45306 temp2 = true;
45307 }
45308 {
45309 arg3 = wxString_in_helper(obj2);
45310 if (arg3 == NULL) SWIG_fail;
45311 temp3 = true;
45312 }
45313 {
45314 PyThreadState* __tstate = wxPyBeginAllowThreads();
45315 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
45316 wxPyEndAllowThreads(__tstate);
45317 if (PyErr_Occurred()) SWIG_fail;
45318 }
45319 resultobj = SWIG_From_int(static_cast< int >(result));
45320 {
45321 if (temp2)
45322 delete arg2;
45323 }
45324 {
45325 if (temp3)
45326 delete arg3;
45327 }
45328 return resultobj;
45329 fail:
45330 {
45331 if (temp2)
45332 delete arg2;
45333 }
45334 {
45335 if (temp3)
45336 delete arg3;
45337 }
45338 return NULL;
45339 }
45340
45341
45342 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45343 PyObject *resultobj = 0;
45344 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45345 int arg2 ;
45346 wxMenuItem *result = 0 ;
45347 void *argp1 = 0 ;
45348 int res1 = 0 ;
45349 int val2 ;
45350 int ecode2 = 0 ;
45351 PyObject * obj0 = 0 ;
45352 PyObject * obj1 = 0 ;
45353 char * kwnames[] = {
45354 (char *) "self",(char *) "id", NULL
45355 };
45356
45357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
45358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45359 if (!SWIG_IsOK(res1)) {
45360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45361 }
45362 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45363 ecode2 = SWIG_AsVal_int(obj1, &val2);
45364 if (!SWIG_IsOK(ecode2)) {
45365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
45366 }
45367 arg2 = static_cast< int >(val2);
45368 {
45369 PyThreadState* __tstate = wxPyBeginAllowThreads();
45370 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
45371 wxPyEndAllowThreads(__tstate);
45372 if (PyErr_Occurred()) SWIG_fail;
45373 }
45374 {
45375 resultobj = wxPyMake_wxObject(result, (bool)0);
45376 }
45377 return resultobj;
45378 fail:
45379 return NULL;
45380 }
45381
45382
45383 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45384 PyObject *resultobj = 0;
45385 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45386 wxString *arg2 = 0 ;
45387 int result;
45388 void *argp1 = 0 ;
45389 int res1 = 0 ;
45390 bool temp2 = false ;
45391 PyObject * obj0 = 0 ;
45392 PyObject * obj1 = 0 ;
45393 char * kwnames[] = {
45394 (char *) "self",(char *) "title", NULL
45395 };
45396
45397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45399 if (!SWIG_IsOK(res1)) {
45400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45401 }
45402 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45403 {
45404 arg2 = wxString_in_helper(obj1);
45405 if (arg2 == NULL) SWIG_fail;
45406 temp2 = true;
45407 }
45408 {
45409 PyThreadState* __tstate = wxPyBeginAllowThreads();
45410 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
45411 wxPyEndAllowThreads(__tstate);
45412 if (PyErr_Occurred()) SWIG_fail;
45413 }
45414 resultobj = SWIG_From_int(static_cast< int >(result));
45415 {
45416 if (temp2)
45417 delete arg2;
45418 }
45419 return resultobj;
45420 fail:
45421 {
45422 if (temp2)
45423 delete arg2;
45424 }
45425 return NULL;
45426 }
45427
45428
45429 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45430 PyObject *resultobj = 0;
45431 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45432 int arg2 ;
45433 bool arg3 ;
45434 void *argp1 = 0 ;
45435 int res1 = 0 ;
45436 int val2 ;
45437 int ecode2 = 0 ;
45438 bool val3 ;
45439 int ecode3 = 0 ;
45440 PyObject * obj0 = 0 ;
45441 PyObject * obj1 = 0 ;
45442 PyObject * obj2 = 0 ;
45443 char * kwnames[] = {
45444 (char *) "self",(char *) "id",(char *) "enable", NULL
45445 };
45446
45447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45449 if (!SWIG_IsOK(res1)) {
45450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45451 }
45452 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45453 ecode2 = SWIG_AsVal_int(obj1, &val2);
45454 if (!SWIG_IsOK(ecode2)) {
45455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
45456 }
45457 arg2 = static_cast< int >(val2);
45458 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45459 if (!SWIG_IsOK(ecode3)) {
45460 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
45461 }
45462 arg3 = static_cast< bool >(val3);
45463 {
45464 PyThreadState* __tstate = wxPyBeginAllowThreads();
45465 (arg1)->Enable(arg2,arg3);
45466 wxPyEndAllowThreads(__tstate);
45467 if (PyErr_Occurred()) SWIG_fail;
45468 }
45469 resultobj = SWIG_Py_Void();
45470 return resultobj;
45471 fail:
45472 return NULL;
45473 }
45474
45475
45476 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45477 PyObject *resultobj = 0;
45478 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45479 int arg2 ;
45480 bool arg3 ;
45481 void *argp1 = 0 ;
45482 int res1 = 0 ;
45483 int val2 ;
45484 int ecode2 = 0 ;
45485 bool val3 ;
45486 int ecode3 = 0 ;
45487 PyObject * obj0 = 0 ;
45488 PyObject * obj1 = 0 ;
45489 PyObject * obj2 = 0 ;
45490 char * kwnames[] = {
45491 (char *) "self",(char *) "id",(char *) "check", NULL
45492 };
45493
45494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45496 if (!SWIG_IsOK(res1)) {
45497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45498 }
45499 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45500 ecode2 = SWIG_AsVal_int(obj1, &val2);
45501 if (!SWIG_IsOK(ecode2)) {
45502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
45503 }
45504 arg2 = static_cast< int >(val2);
45505 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45506 if (!SWIG_IsOK(ecode3)) {
45507 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
45508 }
45509 arg3 = static_cast< bool >(val3);
45510 {
45511 PyThreadState* __tstate = wxPyBeginAllowThreads();
45512 (arg1)->Check(arg2,arg3);
45513 wxPyEndAllowThreads(__tstate);
45514 if (PyErr_Occurred()) SWIG_fail;
45515 }
45516 resultobj = SWIG_Py_Void();
45517 return resultobj;
45518 fail:
45519 return NULL;
45520 }
45521
45522
45523 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45524 PyObject *resultobj = 0;
45525 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45526 int arg2 ;
45527 bool result;
45528 void *argp1 = 0 ;
45529 int res1 = 0 ;
45530 int val2 ;
45531 int ecode2 = 0 ;
45532 PyObject * obj0 = 0 ;
45533 PyObject * obj1 = 0 ;
45534 char * kwnames[] = {
45535 (char *) "self",(char *) "id", NULL
45536 };
45537
45538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
45539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45540 if (!SWIG_IsOK(res1)) {
45541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45542 }
45543 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45544 ecode2 = SWIG_AsVal_int(obj1, &val2);
45545 if (!SWIG_IsOK(ecode2)) {
45546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
45547 }
45548 arg2 = static_cast< int >(val2);
45549 {
45550 PyThreadState* __tstate = wxPyBeginAllowThreads();
45551 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
45552 wxPyEndAllowThreads(__tstate);
45553 if (PyErr_Occurred()) SWIG_fail;
45554 }
45555 {
45556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45557 }
45558 return resultobj;
45559 fail:
45560 return NULL;
45561 }
45562
45563
45564 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45565 PyObject *resultobj = 0;
45566 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45567 int arg2 ;
45568 bool result;
45569 void *argp1 = 0 ;
45570 int res1 = 0 ;
45571 int val2 ;
45572 int ecode2 = 0 ;
45573 PyObject * obj0 = 0 ;
45574 PyObject * obj1 = 0 ;
45575 char * kwnames[] = {
45576 (char *) "self",(char *) "id", NULL
45577 };
45578
45579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
45580 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45581 if (!SWIG_IsOK(res1)) {
45582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45583 }
45584 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45585 ecode2 = SWIG_AsVal_int(obj1, &val2);
45586 if (!SWIG_IsOK(ecode2)) {
45587 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
45588 }
45589 arg2 = static_cast< int >(val2);
45590 {
45591 PyThreadState* __tstate = wxPyBeginAllowThreads();
45592 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
45593 wxPyEndAllowThreads(__tstate);
45594 if (PyErr_Occurred()) SWIG_fail;
45595 }
45596 {
45597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45598 }
45599 return resultobj;
45600 fail:
45601 return NULL;
45602 }
45603
45604
45605 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45606 PyObject *resultobj = 0;
45607 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45608 int arg2 ;
45609 wxString *arg3 = 0 ;
45610 void *argp1 = 0 ;
45611 int res1 = 0 ;
45612 int val2 ;
45613 int ecode2 = 0 ;
45614 bool temp3 = false ;
45615 PyObject * obj0 = 0 ;
45616 PyObject * obj1 = 0 ;
45617 PyObject * obj2 = 0 ;
45618 char * kwnames[] = {
45619 (char *) "self",(char *) "id",(char *) "label", NULL
45620 };
45621
45622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45624 if (!SWIG_IsOK(res1)) {
45625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45626 }
45627 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45628 ecode2 = SWIG_AsVal_int(obj1, &val2);
45629 if (!SWIG_IsOK(ecode2)) {
45630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
45631 }
45632 arg2 = static_cast< int >(val2);
45633 {
45634 arg3 = wxString_in_helper(obj2);
45635 if (arg3 == NULL) SWIG_fail;
45636 temp3 = true;
45637 }
45638 {
45639 PyThreadState* __tstate = wxPyBeginAllowThreads();
45640 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
45641 wxPyEndAllowThreads(__tstate);
45642 if (PyErr_Occurred()) SWIG_fail;
45643 }
45644 resultobj = SWIG_Py_Void();
45645 {
45646 if (temp3)
45647 delete arg3;
45648 }
45649 return resultobj;
45650 fail:
45651 {
45652 if (temp3)
45653 delete arg3;
45654 }
45655 return NULL;
45656 }
45657
45658
45659 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45660 PyObject *resultobj = 0;
45661 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45662 int arg2 ;
45663 wxString result;
45664 void *argp1 = 0 ;
45665 int res1 = 0 ;
45666 int val2 ;
45667 int ecode2 = 0 ;
45668 PyObject * obj0 = 0 ;
45669 PyObject * obj1 = 0 ;
45670 char * kwnames[] = {
45671 (char *) "self",(char *) "id", NULL
45672 };
45673
45674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
45675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45676 if (!SWIG_IsOK(res1)) {
45677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45678 }
45679 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45680 ecode2 = SWIG_AsVal_int(obj1, &val2);
45681 if (!SWIG_IsOK(ecode2)) {
45682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
45683 }
45684 arg2 = static_cast< int >(val2);
45685 {
45686 PyThreadState* __tstate = wxPyBeginAllowThreads();
45687 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
45688 wxPyEndAllowThreads(__tstate);
45689 if (PyErr_Occurred()) SWIG_fail;
45690 }
45691 {
45692 #if wxUSE_UNICODE
45693 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45694 #else
45695 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45696 #endif
45697 }
45698 return resultobj;
45699 fail:
45700 return NULL;
45701 }
45702
45703
45704 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45705 PyObject *resultobj = 0;
45706 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45707 int arg2 ;
45708 wxString *arg3 = 0 ;
45709 void *argp1 = 0 ;
45710 int res1 = 0 ;
45711 int val2 ;
45712 int ecode2 = 0 ;
45713 bool temp3 = false ;
45714 PyObject * obj0 = 0 ;
45715 PyObject * obj1 = 0 ;
45716 PyObject * obj2 = 0 ;
45717 char * kwnames[] = {
45718 (char *) "self",(char *) "id",(char *) "helpString", NULL
45719 };
45720
45721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45723 if (!SWIG_IsOK(res1)) {
45724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45725 }
45726 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45727 ecode2 = SWIG_AsVal_int(obj1, &val2);
45728 if (!SWIG_IsOK(ecode2)) {
45729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
45730 }
45731 arg2 = static_cast< int >(val2);
45732 {
45733 arg3 = wxString_in_helper(obj2);
45734 if (arg3 == NULL) SWIG_fail;
45735 temp3 = true;
45736 }
45737 {
45738 PyThreadState* __tstate = wxPyBeginAllowThreads();
45739 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
45740 wxPyEndAllowThreads(__tstate);
45741 if (PyErr_Occurred()) SWIG_fail;
45742 }
45743 resultobj = SWIG_Py_Void();
45744 {
45745 if (temp3)
45746 delete arg3;
45747 }
45748 return resultobj;
45749 fail:
45750 {
45751 if (temp3)
45752 delete arg3;
45753 }
45754 return NULL;
45755 }
45756
45757
45758 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45759 PyObject *resultobj = 0;
45760 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45761 int arg2 ;
45762 wxString result;
45763 void *argp1 = 0 ;
45764 int res1 = 0 ;
45765 int val2 ;
45766 int ecode2 = 0 ;
45767 PyObject * obj0 = 0 ;
45768 PyObject * obj1 = 0 ;
45769 char * kwnames[] = {
45770 (char *) "self",(char *) "id", NULL
45771 };
45772
45773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
45774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45775 if (!SWIG_IsOK(res1)) {
45776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45777 }
45778 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45779 ecode2 = SWIG_AsVal_int(obj1, &val2);
45780 if (!SWIG_IsOK(ecode2)) {
45781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
45782 }
45783 arg2 = static_cast< int >(val2);
45784 {
45785 PyThreadState* __tstate = wxPyBeginAllowThreads();
45786 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
45787 wxPyEndAllowThreads(__tstate);
45788 if (PyErr_Occurred()) SWIG_fail;
45789 }
45790 {
45791 #if wxUSE_UNICODE
45792 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45793 #else
45794 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45795 #endif
45796 }
45797 return resultobj;
45798 fail:
45799 return NULL;
45800 }
45801
45802
45803 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45804 PyObject *resultobj = 0;
45805 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45806 wxFrame *result = 0 ;
45807 void *argp1 = 0 ;
45808 int res1 = 0 ;
45809 PyObject *swig_obj[1] ;
45810
45811 if (!args) SWIG_fail;
45812 swig_obj[0] = args;
45813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45814 if (!SWIG_IsOK(res1)) {
45815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45816 }
45817 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45818 {
45819 PyThreadState* __tstate = wxPyBeginAllowThreads();
45820 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
45821 wxPyEndAllowThreads(__tstate);
45822 if (PyErr_Occurred()) SWIG_fail;
45823 }
45824 {
45825 resultobj = wxPyMake_wxObject(result, (bool)0);
45826 }
45827 return resultobj;
45828 fail:
45829 return NULL;
45830 }
45831
45832
45833 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45834 PyObject *resultobj = 0;
45835 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45836 bool result;
45837 void *argp1 = 0 ;
45838 int res1 = 0 ;
45839 PyObject *swig_obj[1] ;
45840
45841 if (!args) SWIG_fail;
45842 swig_obj[0] = args;
45843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45844 if (!SWIG_IsOK(res1)) {
45845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45846 }
45847 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45848 {
45849 PyThreadState* __tstate = wxPyBeginAllowThreads();
45850 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
45851 wxPyEndAllowThreads(__tstate);
45852 if (PyErr_Occurred()) SWIG_fail;
45853 }
45854 {
45855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45856 }
45857 return resultobj;
45858 fail:
45859 return NULL;
45860 }
45861
45862
45863 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45864 PyObject *resultobj = 0;
45865 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45866 wxFrame *arg2 = (wxFrame *) 0 ;
45867 void *argp1 = 0 ;
45868 int res1 = 0 ;
45869 void *argp2 = 0 ;
45870 int res2 = 0 ;
45871 PyObject * obj0 = 0 ;
45872 PyObject * obj1 = 0 ;
45873 char * kwnames[] = {
45874 (char *) "self",(char *) "frame", NULL
45875 };
45876
45877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
45878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45879 if (!SWIG_IsOK(res1)) {
45880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45881 }
45882 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45883 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
45884 if (!SWIG_IsOK(res2)) {
45885 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
45886 }
45887 arg2 = reinterpret_cast< wxFrame * >(argp2);
45888 {
45889 PyThreadState* __tstate = wxPyBeginAllowThreads();
45890 (arg1)->Attach(arg2);
45891 wxPyEndAllowThreads(__tstate);
45892 if (PyErr_Occurred()) SWIG_fail;
45893 }
45894 resultobj = SWIG_Py_Void();
45895 return resultobj;
45896 fail:
45897 return NULL;
45898 }
45899
45900
45901 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45902 PyObject *resultobj = 0;
45903 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45904 void *argp1 = 0 ;
45905 int res1 = 0 ;
45906 PyObject *swig_obj[1] ;
45907
45908 if (!args) SWIG_fail;
45909 swig_obj[0] = args;
45910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45911 if (!SWIG_IsOK(res1)) {
45912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45913 }
45914 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45915 {
45916 PyThreadState* __tstate = wxPyBeginAllowThreads();
45917 (arg1)->Detach();
45918 wxPyEndAllowThreads(__tstate);
45919 if (PyErr_Occurred()) SWIG_fail;
45920 }
45921 resultobj = SWIG_Py_Void();
45922 return resultobj;
45923 fail:
45924 return NULL;
45925 }
45926
45927
45928 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45929 PyObject *resultobj = 0;
45930 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45931 void *argp1 = 0 ;
45932 int res1 = 0 ;
45933 PyObject *swig_obj[1] ;
45934
45935 if (!args) SWIG_fail;
45936 swig_obj[0] = args;
45937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45938 if (!SWIG_IsOK(res1)) {
45939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45940 }
45941 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45942 {
45943 PyThreadState* __tstate = wxPyBeginAllowThreads();
45944 (arg1)->UpdateMenus();
45945 wxPyEndAllowThreads(__tstate);
45946 if (PyErr_Occurred()) SWIG_fail;
45947 }
45948 resultobj = SWIG_Py_Void();
45949 return resultobj;
45950 fail:
45951 return NULL;
45952 }
45953
45954
45955 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45956 PyObject *resultobj = 0;
45957 bool arg1 ;
45958 bool val1 ;
45959 int ecode1 = 0 ;
45960 PyObject * obj0 = 0 ;
45961 char * kwnames[] = {
45962 (char *) "enable", NULL
45963 };
45964
45965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
45966 ecode1 = SWIG_AsVal_bool(obj0, &val1);
45967 if (!SWIG_IsOK(ecode1)) {
45968 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
45969 }
45970 arg1 = static_cast< bool >(val1);
45971 {
45972 PyThreadState* __tstate = wxPyBeginAllowThreads();
45973 wxMenuBar_SetAutoWindowMenu(arg1);
45974 wxPyEndAllowThreads(__tstate);
45975 if (PyErr_Occurred()) SWIG_fail;
45976 }
45977 resultobj = SWIG_Py_Void();
45978 return resultobj;
45979 fail:
45980 return NULL;
45981 }
45982
45983
45984 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45985 PyObject *resultobj = 0;
45986 bool result;
45987
45988 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
45989 {
45990 PyThreadState* __tstate = wxPyBeginAllowThreads();
45991 result = (bool)wxMenuBar_GetAutoWindowMenu();
45992 wxPyEndAllowThreads(__tstate);
45993 if (PyErr_Occurred()) SWIG_fail;
45994 }
45995 {
45996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45997 }
45998 return resultobj;
45999 fail:
46000 return NULL;
46001 }
46002
46003
46004 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46005 PyObject *obj;
46006 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46007 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
46008 return SWIG_Py_Void();
46009 }
46010
46011 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46012 return SWIG_Python_InitShadowInstance(args);
46013 }
46014
46015 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46016 PyObject *resultobj = 0;
46017 wxMenu *arg1 = (wxMenu *) NULL ;
46018 int arg2 = (int) wxID_SEPARATOR ;
46019 wxString const &arg3_defvalue = wxPyEmptyString ;
46020 wxString *arg3 = (wxString *) &arg3_defvalue ;
46021 wxString const &arg4_defvalue = wxPyEmptyString ;
46022 wxString *arg4 = (wxString *) &arg4_defvalue ;
46023 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
46024 wxMenu *arg6 = (wxMenu *) NULL ;
46025 wxMenuItem *result = 0 ;
46026 void *argp1 = 0 ;
46027 int res1 = 0 ;
46028 int val2 ;
46029 int ecode2 = 0 ;
46030 bool temp3 = false ;
46031 bool temp4 = false ;
46032 int val5 ;
46033 int ecode5 = 0 ;
46034 void *argp6 = 0 ;
46035 int res6 = 0 ;
46036 PyObject * obj0 = 0 ;
46037 PyObject * obj1 = 0 ;
46038 PyObject * obj2 = 0 ;
46039 PyObject * obj3 = 0 ;
46040 PyObject * obj4 = 0 ;
46041 PyObject * obj5 = 0 ;
46042 char * kwnames[] = {
46043 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
46044 };
46045
46046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46047 if (obj0) {
46048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
46049 if (!SWIG_IsOK(res1)) {
46050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
46051 }
46052 arg1 = reinterpret_cast< wxMenu * >(argp1);
46053 }
46054 if (obj1) {
46055 ecode2 = SWIG_AsVal_int(obj1, &val2);
46056 if (!SWIG_IsOK(ecode2)) {
46057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
46058 }
46059 arg2 = static_cast< int >(val2);
46060 }
46061 if (obj2) {
46062 {
46063 arg3 = wxString_in_helper(obj2);
46064 if (arg3 == NULL) SWIG_fail;
46065 temp3 = true;
46066 }
46067 }
46068 if (obj3) {
46069 {
46070 arg4 = wxString_in_helper(obj3);
46071 if (arg4 == NULL) SWIG_fail;
46072 temp4 = true;
46073 }
46074 }
46075 if (obj4) {
46076 ecode5 = SWIG_AsVal_int(obj4, &val5);
46077 if (!SWIG_IsOK(ecode5)) {
46078 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
46079 }
46080 arg5 = static_cast< wxItemKind >(val5);
46081 }
46082 if (obj5) {
46083 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
46084 if (!SWIG_IsOK(res6)) {
46085 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
46086 }
46087 arg6 = reinterpret_cast< wxMenu * >(argp6);
46088 }
46089 {
46090 PyThreadState* __tstate = wxPyBeginAllowThreads();
46091 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
46092 wxPyEndAllowThreads(__tstate);
46093 if (PyErr_Occurred()) SWIG_fail;
46094 }
46095 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_NEW | 0 );
46096 {
46097 if (temp3)
46098 delete arg3;
46099 }
46100 {
46101 if (temp4)
46102 delete arg4;
46103 }
46104 return resultobj;
46105 fail:
46106 {
46107 if (temp3)
46108 delete arg3;
46109 }
46110 {
46111 if (temp4)
46112 delete arg4;
46113 }
46114 return NULL;
46115 }
46116
46117
46118 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46119 PyObject *resultobj = 0;
46120 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46121 void *argp1 = 0 ;
46122 int res1 = 0 ;
46123 PyObject *swig_obj[1] ;
46124
46125 if (!args) SWIG_fail;
46126 swig_obj[0] = args;
46127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
46128 if (!SWIG_IsOK(res1)) {
46129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46130 }
46131 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46132 {
46133 PyThreadState* __tstate = wxPyBeginAllowThreads();
46134 delete arg1;
46135
46136 wxPyEndAllowThreads(__tstate);
46137 if (PyErr_Occurred()) SWIG_fail;
46138 }
46139 resultobj = SWIG_Py_Void();
46140 return resultobj;
46141 fail:
46142 return NULL;
46143 }
46144
46145
46146 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46147 PyObject *resultobj = 0;
46148 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46149 wxMenu *result = 0 ;
46150 void *argp1 = 0 ;
46151 int res1 = 0 ;
46152 PyObject *swig_obj[1] ;
46153
46154 if (!args) SWIG_fail;
46155 swig_obj[0] = args;
46156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46157 if (!SWIG_IsOK(res1)) {
46158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46159 }
46160 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46161 {
46162 PyThreadState* __tstate = wxPyBeginAllowThreads();
46163 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
46164 wxPyEndAllowThreads(__tstate);
46165 if (PyErr_Occurred()) SWIG_fail;
46166 }
46167 {
46168 resultobj = wxPyMake_wxObject(result, 0);
46169 }
46170 return resultobj;
46171 fail:
46172 return NULL;
46173 }
46174
46175
46176 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46177 PyObject *resultobj = 0;
46178 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46179 wxMenu *arg2 = (wxMenu *) 0 ;
46180 void *argp1 = 0 ;
46181 int res1 = 0 ;
46182 void *argp2 = 0 ;
46183 int res2 = 0 ;
46184 PyObject * obj0 = 0 ;
46185 PyObject * obj1 = 0 ;
46186 char * kwnames[] = {
46187 (char *) "self",(char *) "menu", NULL
46188 };
46189
46190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
46191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46192 if (!SWIG_IsOK(res1)) {
46193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46194 }
46195 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46196 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
46197 if (!SWIG_IsOK(res2)) {
46198 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
46199 }
46200 arg2 = reinterpret_cast< wxMenu * >(argp2);
46201 {
46202 PyThreadState* __tstate = wxPyBeginAllowThreads();
46203 (arg1)->SetMenu(arg2);
46204 wxPyEndAllowThreads(__tstate);
46205 if (PyErr_Occurred()) SWIG_fail;
46206 }
46207 resultobj = SWIG_Py_Void();
46208 return resultobj;
46209 fail:
46210 return NULL;
46211 }
46212
46213
46214 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46215 PyObject *resultobj = 0;
46216 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46217 int arg2 ;
46218 void *argp1 = 0 ;
46219 int res1 = 0 ;
46220 int val2 ;
46221 int ecode2 = 0 ;
46222 PyObject * obj0 = 0 ;
46223 PyObject * obj1 = 0 ;
46224 char * kwnames[] = {
46225 (char *) "self",(char *) "id", NULL
46226 };
46227
46228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
46229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46230 if (!SWIG_IsOK(res1)) {
46231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46232 }
46233 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46234 ecode2 = SWIG_AsVal_int(obj1, &val2);
46235 if (!SWIG_IsOK(ecode2)) {
46236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
46237 }
46238 arg2 = static_cast< int >(val2);
46239 {
46240 PyThreadState* __tstate = wxPyBeginAllowThreads();
46241 (arg1)->SetId(arg2);
46242 wxPyEndAllowThreads(__tstate);
46243 if (PyErr_Occurred()) SWIG_fail;
46244 }
46245 resultobj = SWIG_Py_Void();
46246 return resultobj;
46247 fail:
46248 return NULL;
46249 }
46250
46251
46252 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46253 PyObject *resultobj = 0;
46254 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46255 int result;
46256 void *argp1 = 0 ;
46257 int res1 = 0 ;
46258 PyObject *swig_obj[1] ;
46259
46260 if (!args) SWIG_fail;
46261 swig_obj[0] = args;
46262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46263 if (!SWIG_IsOK(res1)) {
46264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46265 }
46266 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46267 {
46268 PyThreadState* __tstate = wxPyBeginAllowThreads();
46269 result = (int)((wxMenuItem const *)arg1)->GetId();
46270 wxPyEndAllowThreads(__tstate);
46271 if (PyErr_Occurred()) SWIG_fail;
46272 }
46273 resultobj = SWIG_From_int(static_cast< int >(result));
46274 return resultobj;
46275 fail:
46276 return NULL;
46277 }
46278
46279
46280 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46281 PyObject *resultobj = 0;
46282 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46283 bool result;
46284 void *argp1 = 0 ;
46285 int res1 = 0 ;
46286 PyObject *swig_obj[1] ;
46287
46288 if (!args) SWIG_fail;
46289 swig_obj[0] = args;
46290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46291 if (!SWIG_IsOK(res1)) {
46292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46293 }
46294 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46295 {
46296 PyThreadState* __tstate = wxPyBeginAllowThreads();
46297 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
46298 wxPyEndAllowThreads(__tstate);
46299 if (PyErr_Occurred()) SWIG_fail;
46300 }
46301 {
46302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46303 }
46304 return resultobj;
46305 fail:
46306 return NULL;
46307 }
46308
46309
46310 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46311 PyObject *resultobj = 0;
46312 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46313 wxString *arg2 = 0 ;
46314 void *argp1 = 0 ;
46315 int res1 = 0 ;
46316 bool temp2 = false ;
46317 PyObject * obj0 = 0 ;
46318 PyObject * obj1 = 0 ;
46319 char * kwnames[] = {
46320 (char *) "self",(char *) "str", NULL
46321 };
46322
46323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
46324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46325 if (!SWIG_IsOK(res1)) {
46326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46327 }
46328 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46329 {
46330 arg2 = wxString_in_helper(obj1);
46331 if (arg2 == NULL) SWIG_fail;
46332 temp2 = true;
46333 }
46334 {
46335 PyThreadState* __tstate = wxPyBeginAllowThreads();
46336 (arg1)->SetText((wxString const &)*arg2);
46337 wxPyEndAllowThreads(__tstate);
46338 if (PyErr_Occurred()) SWIG_fail;
46339 }
46340 resultobj = SWIG_Py_Void();
46341 {
46342 if (temp2)
46343 delete arg2;
46344 }
46345 return resultobj;
46346 fail:
46347 {
46348 if (temp2)
46349 delete arg2;
46350 }
46351 return NULL;
46352 }
46353
46354
46355 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46356 PyObject *resultobj = 0;
46357 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46358 wxString result;
46359 void *argp1 = 0 ;
46360 int res1 = 0 ;
46361 PyObject *swig_obj[1] ;
46362
46363 if (!args) SWIG_fail;
46364 swig_obj[0] = args;
46365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46366 if (!SWIG_IsOK(res1)) {
46367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46368 }
46369 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46370 {
46371 PyThreadState* __tstate = wxPyBeginAllowThreads();
46372 result = ((wxMenuItem const *)arg1)->GetLabel();
46373 wxPyEndAllowThreads(__tstate);
46374 if (PyErr_Occurred()) SWIG_fail;
46375 }
46376 {
46377 #if wxUSE_UNICODE
46378 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46379 #else
46380 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46381 #endif
46382 }
46383 return resultobj;
46384 fail:
46385 return NULL;
46386 }
46387
46388
46389 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46390 PyObject *resultobj = 0;
46391 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46392 wxString *result = 0 ;
46393 void *argp1 = 0 ;
46394 int res1 = 0 ;
46395 PyObject *swig_obj[1] ;
46396
46397 if (!args) SWIG_fail;
46398 swig_obj[0] = args;
46399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46400 if (!SWIG_IsOK(res1)) {
46401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46402 }
46403 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46404 {
46405 PyThreadState* __tstate = wxPyBeginAllowThreads();
46406 {
46407 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
46408 result = (wxString *) &_result_ref;
46409 }
46410 wxPyEndAllowThreads(__tstate);
46411 if (PyErr_Occurred()) SWIG_fail;
46412 }
46413 {
46414 #if wxUSE_UNICODE
46415 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46416 #else
46417 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46418 #endif
46419 }
46420 return resultobj;
46421 fail:
46422 return NULL;
46423 }
46424
46425
46426 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46427 PyObject *resultobj = 0;
46428 wxString *arg1 = 0 ;
46429 wxString result;
46430 bool temp1 = false ;
46431 PyObject * obj0 = 0 ;
46432 char * kwnames[] = {
46433 (char *) "text", NULL
46434 };
46435
46436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
46437 {
46438 arg1 = wxString_in_helper(obj0);
46439 if (arg1 == NULL) SWIG_fail;
46440 temp1 = true;
46441 }
46442 {
46443 PyThreadState* __tstate = wxPyBeginAllowThreads();
46444 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
46445 wxPyEndAllowThreads(__tstate);
46446 if (PyErr_Occurred()) SWIG_fail;
46447 }
46448 {
46449 #if wxUSE_UNICODE
46450 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46451 #else
46452 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46453 #endif
46454 }
46455 {
46456 if (temp1)
46457 delete arg1;
46458 }
46459 return resultobj;
46460 fail:
46461 {
46462 if (temp1)
46463 delete arg1;
46464 }
46465 return NULL;
46466 }
46467
46468
46469 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46470 PyObject *resultobj = 0;
46471 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46472 wxItemKind result;
46473 void *argp1 = 0 ;
46474 int res1 = 0 ;
46475 PyObject *swig_obj[1] ;
46476
46477 if (!args) SWIG_fail;
46478 swig_obj[0] = args;
46479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46480 if (!SWIG_IsOK(res1)) {
46481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46482 }
46483 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46484 {
46485 PyThreadState* __tstate = wxPyBeginAllowThreads();
46486 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
46487 wxPyEndAllowThreads(__tstate);
46488 if (PyErr_Occurred()) SWIG_fail;
46489 }
46490 resultobj = SWIG_From_int(static_cast< int >(result));
46491 return resultobj;
46492 fail:
46493 return NULL;
46494 }
46495
46496
46497 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46498 PyObject *resultobj = 0;
46499 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46500 wxItemKind arg2 ;
46501 void *argp1 = 0 ;
46502 int res1 = 0 ;
46503 int val2 ;
46504 int ecode2 = 0 ;
46505 PyObject * obj0 = 0 ;
46506 PyObject * obj1 = 0 ;
46507 char * kwnames[] = {
46508 (char *) "self",(char *) "kind", NULL
46509 };
46510
46511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
46512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46513 if (!SWIG_IsOK(res1)) {
46514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46515 }
46516 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46517 ecode2 = SWIG_AsVal_int(obj1, &val2);
46518 if (!SWIG_IsOK(ecode2)) {
46519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
46520 }
46521 arg2 = static_cast< wxItemKind >(val2);
46522 {
46523 PyThreadState* __tstate = wxPyBeginAllowThreads();
46524 (arg1)->SetKind(arg2);
46525 wxPyEndAllowThreads(__tstate);
46526 if (PyErr_Occurred()) SWIG_fail;
46527 }
46528 resultobj = SWIG_Py_Void();
46529 return resultobj;
46530 fail:
46531 return NULL;
46532 }
46533
46534
46535 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46536 PyObject *resultobj = 0;
46537 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46538 bool arg2 ;
46539 void *argp1 = 0 ;
46540 int res1 = 0 ;
46541 bool val2 ;
46542 int ecode2 = 0 ;
46543 PyObject * obj0 = 0 ;
46544 PyObject * obj1 = 0 ;
46545 char * kwnames[] = {
46546 (char *) "self",(char *) "checkable", NULL
46547 };
46548
46549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
46550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46551 if (!SWIG_IsOK(res1)) {
46552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46553 }
46554 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46555 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46556 if (!SWIG_IsOK(ecode2)) {
46557 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
46558 }
46559 arg2 = static_cast< bool >(val2);
46560 {
46561 PyThreadState* __tstate = wxPyBeginAllowThreads();
46562 (arg1)->SetCheckable(arg2);
46563 wxPyEndAllowThreads(__tstate);
46564 if (PyErr_Occurred()) SWIG_fail;
46565 }
46566 resultobj = SWIG_Py_Void();
46567 return resultobj;
46568 fail:
46569 return NULL;
46570 }
46571
46572
46573 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46574 PyObject *resultobj = 0;
46575 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46576 bool result;
46577 void *argp1 = 0 ;
46578 int res1 = 0 ;
46579 PyObject *swig_obj[1] ;
46580
46581 if (!args) SWIG_fail;
46582 swig_obj[0] = args;
46583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46584 if (!SWIG_IsOK(res1)) {
46585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46586 }
46587 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46588 {
46589 PyThreadState* __tstate = wxPyBeginAllowThreads();
46590 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
46591 wxPyEndAllowThreads(__tstate);
46592 if (PyErr_Occurred()) SWIG_fail;
46593 }
46594 {
46595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46596 }
46597 return resultobj;
46598 fail:
46599 return NULL;
46600 }
46601
46602
46603 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46604 PyObject *resultobj = 0;
46605 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46606 bool result;
46607 void *argp1 = 0 ;
46608 int res1 = 0 ;
46609 PyObject *swig_obj[1] ;
46610
46611 if (!args) SWIG_fail;
46612 swig_obj[0] = args;
46613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46614 if (!SWIG_IsOK(res1)) {
46615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46616 }
46617 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46618 {
46619 PyThreadState* __tstate = wxPyBeginAllowThreads();
46620 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
46621 wxPyEndAllowThreads(__tstate);
46622 if (PyErr_Occurred()) SWIG_fail;
46623 }
46624 {
46625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46626 }
46627 return resultobj;
46628 fail:
46629 return NULL;
46630 }
46631
46632
46633 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46634 PyObject *resultobj = 0;
46635 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46636 wxMenu *arg2 = (wxMenu *) 0 ;
46637 void *argp1 = 0 ;
46638 int res1 = 0 ;
46639 void *argp2 = 0 ;
46640 int res2 = 0 ;
46641 PyObject * obj0 = 0 ;
46642 PyObject * obj1 = 0 ;
46643 char * kwnames[] = {
46644 (char *) "self",(char *) "menu", NULL
46645 };
46646
46647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
46648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46649 if (!SWIG_IsOK(res1)) {
46650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46651 }
46652 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46653 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
46654 if (!SWIG_IsOK(res2)) {
46655 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
46656 }
46657 arg2 = reinterpret_cast< wxMenu * >(argp2);
46658 {
46659 PyThreadState* __tstate = wxPyBeginAllowThreads();
46660 (arg1)->SetSubMenu(arg2);
46661 wxPyEndAllowThreads(__tstate);
46662 if (PyErr_Occurred()) SWIG_fail;
46663 }
46664 resultobj = SWIG_Py_Void();
46665 return resultobj;
46666 fail:
46667 return NULL;
46668 }
46669
46670
46671 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46672 PyObject *resultobj = 0;
46673 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46674 wxMenu *result = 0 ;
46675 void *argp1 = 0 ;
46676 int res1 = 0 ;
46677 PyObject *swig_obj[1] ;
46678
46679 if (!args) SWIG_fail;
46680 swig_obj[0] = args;
46681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46682 if (!SWIG_IsOK(res1)) {
46683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46684 }
46685 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46686 {
46687 PyThreadState* __tstate = wxPyBeginAllowThreads();
46688 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
46689 wxPyEndAllowThreads(__tstate);
46690 if (PyErr_Occurred()) SWIG_fail;
46691 }
46692 {
46693 resultobj = wxPyMake_wxObject(result, 0);
46694 }
46695 return resultobj;
46696 fail:
46697 return NULL;
46698 }
46699
46700
46701 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46702 PyObject *resultobj = 0;
46703 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46704 bool arg2 = (bool) true ;
46705 void *argp1 = 0 ;
46706 int res1 = 0 ;
46707 bool val2 ;
46708 int ecode2 = 0 ;
46709 PyObject * obj0 = 0 ;
46710 PyObject * obj1 = 0 ;
46711 char * kwnames[] = {
46712 (char *) "self",(char *) "enable", NULL
46713 };
46714
46715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
46716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46717 if (!SWIG_IsOK(res1)) {
46718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46719 }
46720 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46721 if (obj1) {
46722 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46723 if (!SWIG_IsOK(ecode2)) {
46724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
46725 }
46726 arg2 = static_cast< bool >(val2);
46727 }
46728 {
46729 PyThreadState* __tstate = wxPyBeginAllowThreads();
46730 (arg1)->Enable(arg2);
46731 wxPyEndAllowThreads(__tstate);
46732 if (PyErr_Occurred()) SWIG_fail;
46733 }
46734 resultobj = SWIG_Py_Void();
46735 return resultobj;
46736 fail:
46737 return NULL;
46738 }
46739
46740
46741 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46742 PyObject *resultobj = 0;
46743 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46744 bool result;
46745 void *argp1 = 0 ;
46746 int res1 = 0 ;
46747 PyObject *swig_obj[1] ;
46748
46749 if (!args) SWIG_fail;
46750 swig_obj[0] = args;
46751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46752 if (!SWIG_IsOK(res1)) {
46753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46754 }
46755 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46756 {
46757 PyThreadState* __tstate = wxPyBeginAllowThreads();
46758 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
46759 wxPyEndAllowThreads(__tstate);
46760 if (PyErr_Occurred()) SWIG_fail;
46761 }
46762 {
46763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46764 }
46765 return resultobj;
46766 fail:
46767 return NULL;
46768 }
46769
46770
46771 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46772 PyObject *resultobj = 0;
46773 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46774 bool arg2 = (bool) true ;
46775 void *argp1 = 0 ;
46776 int res1 = 0 ;
46777 bool val2 ;
46778 int ecode2 = 0 ;
46779 PyObject * obj0 = 0 ;
46780 PyObject * obj1 = 0 ;
46781 char * kwnames[] = {
46782 (char *) "self",(char *) "check", NULL
46783 };
46784
46785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
46786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46787 if (!SWIG_IsOK(res1)) {
46788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46789 }
46790 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46791 if (obj1) {
46792 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46793 if (!SWIG_IsOK(ecode2)) {
46794 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
46795 }
46796 arg2 = static_cast< bool >(val2);
46797 }
46798 {
46799 PyThreadState* __tstate = wxPyBeginAllowThreads();
46800 (arg1)->Check(arg2);
46801 wxPyEndAllowThreads(__tstate);
46802 if (PyErr_Occurred()) SWIG_fail;
46803 }
46804 resultobj = SWIG_Py_Void();
46805 return resultobj;
46806 fail:
46807 return NULL;
46808 }
46809
46810
46811 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46812 PyObject *resultobj = 0;
46813 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46814 bool result;
46815 void *argp1 = 0 ;
46816 int res1 = 0 ;
46817 PyObject *swig_obj[1] ;
46818
46819 if (!args) SWIG_fail;
46820 swig_obj[0] = args;
46821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46822 if (!SWIG_IsOK(res1)) {
46823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46824 }
46825 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46826 {
46827 PyThreadState* __tstate = wxPyBeginAllowThreads();
46828 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
46829 wxPyEndAllowThreads(__tstate);
46830 if (PyErr_Occurred()) SWIG_fail;
46831 }
46832 {
46833 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46834 }
46835 return resultobj;
46836 fail:
46837 return NULL;
46838 }
46839
46840
46841 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46842 PyObject *resultobj = 0;
46843 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46844 void *argp1 = 0 ;
46845 int res1 = 0 ;
46846 PyObject *swig_obj[1] ;
46847
46848 if (!args) SWIG_fail;
46849 swig_obj[0] = args;
46850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46851 if (!SWIG_IsOK(res1)) {
46852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46853 }
46854 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46855 {
46856 PyThreadState* __tstate = wxPyBeginAllowThreads();
46857 (arg1)->Toggle();
46858 wxPyEndAllowThreads(__tstate);
46859 if (PyErr_Occurred()) SWIG_fail;
46860 }
46861 resultobj = SWIG_Py_Void();
46862 return resultobj;
46863 fail:
46864 return NULL;
46865 }
46866
46867
46868 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46869 PyObject *resultobj = 0;
46870 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46871 wxString *arg2 = 0 ;
46872 void *argp1 = 0 ;
46873 int res1 = 0 ;
46874 bool temp2 = false ;
46875 PyObject * obj0 = 0 ;
46876 PyObject * obj1 = 0 ;
46877 char * kwnames[] = {
46878 (char *) "self",(char *) "str", NULL
46879 };
46880
46881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
46882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46883 if (!SWIG_IsOK(res1)) {
46884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46885 }
46886 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46887 {
46888 arg2 = wxString_in_helper(obj1);
46889 if (arg2 == NULL) SWIG_fail;
46890 temp2 = true;
46891 }
46892 {
46893 PyThreadState* __tstate = wxPyBeginAllowThreads();
46894 (arg1)->SetHelp((wxString const &)*arg2);
46895 wxPyEndAllowThreads(__tstate);
46896 if (PyErr_Occurred()) SWIG_fail;
46897 }
46898 resultobj = SWIG_Py_Void();
46899 {
46900 if (temp2)
46901 delete arg2;
46902 }
46903 return resultobj;
46904 fail:
46905 {
46906 if (temp2)
46907 delete arg2;
46908 }
46909 return NULL;
46910 }
46911
46912
46913 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46914 PyObject *resultobj = 0;
46915 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46916 wxString *result = 0 ;
46917 void *argp1 = 0 ;
46918 int res1 = 0 ;
46919 PyObject *swig_obj[1] ;
46920
46921 if (!args) SWIG_fail;
46922 swig_obj[0] = args;
46923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46924 if (!SWIG_IsOK(res1)) {
46925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46926 }
46927 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46928 {
46929 PyThreadState* __tstate = wxPyBeginAllowThreads();
46930 {
46931 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
46932 result = (wxString *) &_result_ref;
46933 }
46934 wxPyEndAllowThreads(__tstate);
46935 if (PyErr_Occurred()) SWIG_fail;
46936 }
46937 {
46938 #if wxUSE_UNICODE
46939 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46940 #else
46941 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46942 #endif
46943 }
46944 return resultobj;
46945 fail:
46946 return NULL;
46947 }
46948
46949
46950 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46951 PyObject *resultobj = 0;
46952 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46953 wxAcceleratorEntry *result = 0 ;
46954 void *argp1 = 0 ;
46955 int res1 = 0 ;
46956 PyObject *swig_obj[1] ;
46957
46958 if (!args) SWIG_fail;
46959 swig_obj[0] = args;
46960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46961 if (!SWIG_IsOK(res1)) {
46962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46963 }
46964 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46965 {
46966 PyThreadState* __tstate = wxPyBeginAllowThreads();
46967 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
46968 wxPyEndAllowThreads(__tstate);
46969 if (PyErr_Occurred()) SWIG_fail;
46970 }
46971 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46972 return resultobj;
46973 fail:
46974 return NULL;
46975 }
46976
46977
46978 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46979 PyObject *resultobj = 0;
46980 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46981 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
46982 void *argp1 = 0 ;
46983 int res1 = 0 ;
46984 void *argp2 = 0 ;
46985 int res2 = 0 ;
46986 PyObject * obj0 = 0 ;
46987 PyObject * obj1 = 0 ;
46988 char * kwnames[] = {
46989 (char *) "self",(char *) "accel", NULL
46990 };
46991
46992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
46993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46994 if (!SWIG_IsOK(res1)) {
46995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46996 }
46997 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46998 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46999 if (!SWIG_IsOK(res2)) {
47000 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
47001 }
47002 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
47003 {
47004 PyThreadState* __tstate = wxPyBeginAllowThreads();
47005 (arg1)->SetAccel(arg2);
47006 wxPyEndAllowThreads(__tstate);
47007 if (PyErr_Occurred()) SWIG_fail;
47008 }
47009 resultobj = SWIG_Py_Void();
47010 return resultobj;
47011 fail:
47012 return NULL;
47013 }
47014
47015
47016 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47017 PyObject *resultobj = 0;
47018 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47019 wxBitmap *arg2 = 0 ;
47020 void *argp1 = 0 ;
47021 int res1 = 0 ;
47022 void *argp2 = 0 ;
47023 int res2 = 0 ;
47024 PyObject * obj0 = 0 ;
47025 PyObject * obj1 = 0 ;
47026 char * kwnames[] = {
47027 (char *) "self",(char *) "bitmap", NULL
47028 };
47029
47030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
47031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47032 if (!SWIG_IsOK(res1)) {
47033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47034 }
47035 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47036 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47037 if (!SWIG_IsOK(res2)) {
47038 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47039 }
47040 if (!argp2) {
47041 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47042 }
47043 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47044 {
47045 PyThreadState* __tstate = wxPyBeginAllowThreads();
47046 (arg1)->SetBitmap((wxBitmap const &)*arg2);
47047 wxPyEndAllowThreads(__tstate);
47048 if (PyErr_Occurred()) SWIG_fail;
47049 }
47050 resultobj = SWIG_Py_Void();
47051 return resultobj;
47052 fail:
47053 return NULL;
47054 }
47055
47056
47057 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47058 PyObject *resultobj = 0;
47059 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47060 wxBitmap *result = 0 ;
47061 void *argp1 = 0 ;
47062 int res1 = 0 ;
47063 PyObject *swig_obj[1] ;
47064
47065 if (!args) SWIG_fail;
47066 swig_obj[0] = args;
47067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47068 if (!SWIG_IsOK(res1)) {
47069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47070 }
47071 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47072 {
47073 PyThreadState* __tstate = wxPyBeginAllowThreads();
47074 {
47075 wxBitmap const &_result_ref = (arg1)->GetBitmap();
47076 result = (wxBitmap *) &_result_ref;
47077 }
47078 wxPyEndAllowThreads(__tstate);
47079 if (PyErr_Occurred()) SWIG_fail;
47080 }
47081 {
47082 wxBitmap* resultptr = new wxBitmap(*result);
47083 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
47084 }
47085 return resultobj;
47086 fail:
47087 return NULL;
47088 }
47089
47090
47091 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47092 PyObject *resultobj = 0;
47093 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47094 wxFont *arg2 = 0 ;
47095 void *argp1 = 0 ;
47096 int res1 = 0 ;
47097 void *argp2 = 0 ;
47098 int res2 = 0 ;
47099 PyObject * obj0 = 0 ;
47100 PyObject * obj1 = 0 ;
47101 char * kwnames[] = {
47102 (char *) "self",(char *) "font", NULL
47103 };
47104
47105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
47106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47107 if (!SWIG_IsOK(res1)) {
47108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47109 }
47110 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47111 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
47112 if (!SWIG_IsOK(res2)) {
47113 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
47114 }
47115 if (!argp2) {
47116 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
47117 }
47118 arg2 = reinterpret_cast< wxFont * >(argp2);
47119 {
47120 PyThreadState* __tstate = wxPyBeginAllowThreads();
47121 (arg1)->SetFont((wxFont const &)*arg2);
47122 wxPyEndAllowThreads(__tstate);
47123 if (PyErr_Occurred()) SWIG_fail;
47124 }
47125 resultobj = SWIG_Py_Void();
47126 return resultobj;
47127 fail:
47128 return NULL;
47129 }
47130
47131
47132 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47133 PyObject *resultobj = 0;
47134 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47135 wxFont result;
47136 void *argp1 = 0 ;
47137 int res1 = 0 ;
47138 PyObject *swig_obj[1] ;
47139
47140 if (!args) SWIG_fail;
47141 swig_obj[0] = args;
47142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47143 if (!SWIG_IsOK(res1)) {
47144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47145 }
47146 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47147 {
47148 PyThreadState* __tstate = wxPyBeginAllowThreads();
47149 result = (arg1)->GetFont();
47150 wxPyEndAllowThreads(__tstate);
47151 if (PyErr_Occurred()) SWIG_fail;
47152 }
47153 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
47154 return resultobj;
47155 fail:
47156 return NULL;
47157 }
47158
47159
47160 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47161 PyObject *resultobj = 0;
47162 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47163 wxColour *arg2 = 0 ;
47164 void *argp1 = 0 ;
47165 int res1 = 0 ;
47166 wxColour temp2 ;
47167 PyObject * obj0 = 0 ;
47168 PyObject * obj1 = 0 ;
47169 char * kwnames[] = {
47170 (char *) "self",(char *) "colText", NULL
47171 };
47172
47173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
47174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47175 if (!SWIG_IsOK(res1)) {
47176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47177 }
47178 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47179 {
47180 arg2 = &temp2;
47181 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
47182 }
47183 {
47184 PyThreadState* __tstate = wxPyBeginAllowThreads();
47185 (arg1)->SetTextColour((wxColour const &)*arg2);
47186 wxPyEndAllowThreads(__tstate);
47187 if (PyErr_Occurred()) SWIG_fail;
47188 }
47189 resultobj = SWIG_Py_Void();
47190 return resultobj;
47191 fail:
47192 return NULL;
47193 }
47194
47195
47196 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47197 PyObject *resultobj = 0;
47198 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47199 wxColour result;
47200 void *argp1 = 0 ;
47201 int res1 = 0 ;
47202 PyObject *swig_obj[1] ;
47203
47204 if (!args) SWIG_fail;
47205 swig_obj[0] = args;
47206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47207 if (!SWIG_IsOK(res1)) {
47208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47209 }
47210 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47211 {
47212 PyThreadState* __tstate = wxPyBeginAllowThreads();
47213 result = (arg1)->GetTextColour();
47214 wxPyEndAllowThreads(__tstate);
47215 if (PyErr_Occurred()) SWIG_fail;
47216 }
47217 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
47218 return resultobj;
47219 fail:
47220 return NULL;
47221 }
47222
47223
47224 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47225 PyObject *resultobj = 0;
47226 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47227 wxColour *arg2 = 0 ;
47228 void *argp1 = 0 ;
47229 int res1 = 0 ;
47230 wxColour temp2 ;
47231 PyObject * obj0 = 0 ;
47232 PyObject * obj1 = 0 ;
47233 char * kwnames[] = {
47234 (char *) "self",(char *) "colBack", NULL
47235 };
47236
47237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
47238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47239 if (!SWIG_IsOK(res1)) {
47240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47241 }
47242 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47243 {
47244 arg2 = &temp2;
47245 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
47246 }
47247 {
47248 PyThreadState* __tstate = wxPyBeginAllowThreads();
47249 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
47250 wxPyEndAllowThreads(__tstate);
47251 if (PyErr_Occurred()) SWIG_fail;
47252 }
47253 resultobj = SWIG_Py_Void();
47254 return resultobj;
47255 fail:
47256 return NULL;
47257 }
47258
47259
47260 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47261 PyObject *resultobj = 0;
47262 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47263 wxColour result;
47264 void *argp1 = 0 ;
47265 int res1 = 0 ;
47266 PyObject *swig_obj[1] ;
47267
47268 if (!args) SWIG_fail;
47269 swig_obj[0] = args;
47270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47271 if (!SWIG_IsOK(res1)) {
47272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47273 }
47274 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47275 {
47276 PyThreadState* __tstate = wxPyBeginAllowThreads();
47277 result = (arg1)->GetBackgroundColour();
47278 wxPyEndAllowThreads(__tstate);
47279 if (PyErr_Occurred()) SWIG_fail;
47280 }
47281 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
47282 return resultobj;
47283 fail:
47284 return NULL;
47285 }
47286
47287
47288 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47289 PyObject *resultobj = 0;
47290 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47291 wxBitmap *arg2 = 0 ;
47292 wxBitmap const &arg3_defvalue = wxNullBitmap ;
47293 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
47294 void *argp1 = 0 ;
47295 int res1 = 0 ;
47296 void *argp2 = 0 ;
47297 int res2 = 0 ;
47298 void *argp3 = 0 ;
47299 int res3 = 0 ;
47300 PyObject * obj0 = 0 ;
47301 PyObject * obj1 = 0 ;
47302 PyObject * obj2 = 0 ;
47303 char * kwnames[] = {
47304 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
47305 };
47306
47307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47309 if (!SWIG_IsOK(res1)) {
47310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47311 }
47312 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47313 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47314 if (!SWIG_IsOK(res2)) {
47315 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47316 }
47317 if (!argp2) {
47318 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47319 }
47320 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47321 if (obj2) {
47322 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
47323 if (!SWIG_IsOK(res3)) {
47324 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
47325 }
47326 if (!argp3) {
47327 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
47328 }
47329 arg3 = reinterpret_cast< wxBitmap * >(argp3);
47330 }
47331 {
47332 PyThreadState* __tstate = wxPyBeginAllowThreads();
47333 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
47334 wxPyEndAllowThreads(__tstate);
47335 if (PyErr_Occurred()) SWIG_fail;
47336 }
47337 resultobj = SWIG_Py_Void();
47338 return resultobj;
47339 fail:
47340 return NULL;
47341 }
47342
47343
47344 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47345 PyObject *resultobj = 0;
47346 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47347 wxBitmap *arg2 = 0 ;
47348 void *argp1 = 0 ;
47349 int res1 = 0 ;
47350 void *argp2 = 0 ;
47351 int res2 = 0 ;
47352 PyObject * obj0 = 0 ;
47353 PyObject * obj1 = 0 ;
47354 char * kwnames[] = {
47355 (char *) "self",(char *) "bmpDisabled", NULL
47356 };
47357
47358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
47359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47360 if (!SWIG_IsOK(res1)) {
47361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47362 }
47363 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47364 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47365 if (!SWIG_IsOK(res2)) {
47366 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47367 }
47368 if (!argp2) {
47369 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47370 }
47371 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47372 {
47373 PyThreadState* __tstate = wxPyBeginAllowThreads();
47374 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
47375 wxPyEndAllowThreads(__tstate);
47376 if (PyErr_Occurred()) SWIG_fail;
47377 }
47378 resultobj = SWIG_Py_Void();
47379 return resultobj;
47380 fail:
47381 return NULL;
47382 }
47383
47384
47385 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47386 PyObject *resultobj = 0;
47387 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47388 wxBitmap *result = 0 ;
47389 void *argp1 = 0 ;
47390 int res1 = 0 ;
47391 PyObject *swig_obj[1] ;
47392
47393 if (!args) SWIG_fail;
47394 swig_obj[0] = args;
47395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47396 if (!SWIG_IsOK(res1)) {
47397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47398 }
47399 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47400 {
47401 PyThreadState* __tstate = wxPyBeginAllowThreads();
47402 {
47403 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
47404 result = (wxBitmap *) &_result_ref;
47405 }
47406 wxPyEndAllowThreads(__tstate);
47407 if (PyErr_Occurred()) SWIG_fail;
47408 }
47409 {
47410 wxBitmap* resultptr = new wxBitmap(*result);
47411 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
47412 }
47413 return resultobj;
47414 fail:
47415 return NULL;
47416 }
47417
47418
47419 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47420 PyObject *resultobj = 0;
47421 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47422 int arg2 ;
47423 void *argp1 = 0 ;
47424 int res1 = 0 ;
47425 int val2 ;
47426 int ecode2 = 0 ;
47427 PyObject * obj0 = 0 ;
47428 PyObject * obj1 = 0 ;
47429 char * kwnames[] = {
47430 (char *) "self",(char *) "nWidth", NULL
47431 };
47432
47433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
47434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47435 if (!SWIG_IsOK(res1)) {
47436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47437 }
47438 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47439 ecode2 = SWIG_AsVal_int(obj1, &val2);
47440 if (!SWIG_IsOK(ecode2)) {
47441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
47442 }
47443 arg2 = static_cast< int >(val2);
47444 {
47445 PyThreadState* __tstate = wxPyBeginAllowThreads();
47446 (arg1)->SetMarginWidth(arg2);
47447 wxPyEndAllowThreads(__tstate);
47448 if (PyErr_Occurred()) SWIG_fail;
47449 }
47450 resultobj = SWIG_Py_Void();
47451 return resultobj;
47452 fail:
47453 return NULL;
47454 }
47455
47456
47457 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47458 PyObject *resultobj = 0;
47459 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47460 int result;
47461 void *argp1 = 0 ;
47462 int res1 = 0 ;
47463 PyObject *swig_obj[1] ;
47464
47465 if (!args) SWIG_fail;
47466 swig_obj[0] = args;
47467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47468 if (!SWIG_IsOK(res1)) {
47469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47470 }
47471 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47472 {
47473 PyThreadState* __tstate = wxPyBeginAllowThreads();
47474 result = (int)(arg1)->GetMarginWidth();
47475 wxPyEndAllowThreads(__tstate);
47476 if (PyErr_Occurred()) SWIG_fail;
47477 }
47478 resultobj = SWIG_From_int(static_cast< int >(result));
47479 return resultobj;
47480 fail:
47481 return NULL;
47482 }
47483
47484
47485 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47486 PyObject *resultobj = 0;
47487 int result;
47488
47489 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
47490 {
47491 PyThreadState* __tstate = wxPyBeginAllowThreads();
47492 result = (int)wxMenuItem::GetDefaultMarginWidth();
47493 wxPyEndAllowThreads(__tstate);
47494 if (PyErr_Occurred()) SWIG_fail;
47495 }
47496 resultobj = SWIG_From_int(static_cast< int >(result));
47497 return resultobj;
47498 fail:
47499 return NULL;
47500 }
47501
47502
47503 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47504 PyObject *resultobj = 0;
47505 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47506 bool result;
47507 void *argp1 = 0 ;
47508 int res1 = 0 ;
47509 PyObject *swig_obj[1] ;
47510
47511 if (!args) SWIG_fail;
47512 swig_obj[0] = args;
47513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47514 if (!SWIG_IsOK(res1)) {
47515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47516 }
47517 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47518 {
47519 PyThreadState* __tstate = wxPyBeginAllowThreads();
47520 result = (bool)(arg1)->IsOwnerDrawn();
47521 wxPyEndAllowThreads(__tstate);
47522 if (PyErr_Occurred()) SWIG_fail;
47523 }
47524 {
47525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47526 }
47527 return resultobj;
47528 fail:
47529 return NULL;
47530 }
47531
47532
47533 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47534 PyObject *resultobj = 0;
47535 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47536 bool arg2 = (bool) true ;
47537 void *argp1 = 0 ;
47538 int res1 = 0 ;
47539 bool val2 ;
47540 int ecode2 = 0 ;
47541 PyObject * obj0 = 0 ;
47542 PyObject * obj1 = 0 ;
47543 char * kwnames[] = {
47544 (char *) "self",(char *) "ownerDrawn", NULL
47545 };
47546
47547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
47548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47549 if (!SWIG_IsOK(res1)) {
47550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47551 }
47552 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47553 if (obj1) {
47554 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47555 if (!SWIG_IsOK(ecode2)) {
47556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
47557 }
47558 arg2 = static_cast< bool >(val2);
47559 }
47560 {
47561 PyThreadState* __tstate = wxPyBeginAllowThreads();
47562 (arg1)->SetOwnerDrawn(arg2);
47563 wxPyEndAllowThreads(__tstate);
47564 if (PyErr_Occurred()) SWIG_fail;
47565 }
47566 resultobj = SWIG_Py_Void();
47567 return resultobj;
47568 fail:
47569 return NULL;
47570 }
47571
47572
47573 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47574 PyObject *resultobj = 0;
47575 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47576 void *argp1 = 0 ;
47577 int res1 = 0 ;
47578 PyObject *swig_obj[1] ;
47579
47580 if (!args) SWIG_fail;
47581 swig_obj[0] = args;
47582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47583 if (!SWIG_IsOK(res1)) {
47584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47585 }
47586 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47587 {
47588 PyThreadState* __tstate = wxPyBeginAllowThreads();
47589 (arg1)->ResetOwnerDrawn();
47590 wxPyEndAllowThreads(__tstate);
47591 if (PyErr_Occurred()) SWIG_fail;
47592 }
47593 resultobj = SWIG_Py_Void();
47594 return resultobj;
47595 fail:
47596 return NULL;
47597 }
47598
47599
47600 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47601 PyObject *obj;
47602 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47603 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
47604 return SWIG_Py_Void();
47605 }
47606
47607 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47608 return SWIG_Python_InitShadowInstance(args);
47609 }
47610
47611 SWIGINTERN int ControlNameStr_set(PyObject *) {
47612 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
47613 return 1;
47614 }
47615
47616
47617 SWIGINTERN PyObject *ControlNameStr_get(void) {
47618 PyObject *pyobj = 0;
47619
47620 {
47621 #if wxUSE_UNICODE
47622 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47623 #else
47624 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47625 #endif
47626 }
47627 return pyobj;
47628 }
47629
47630
47631 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47632 PyObject *resultobj = 0;
47633 wxWindow *arg1 = (wxWindow *) 0 ;
47634 int arg2 = (int) -1 ;
47635 wxPoint const &arg3_defvalue = wxDefaultPosition ;
47636 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
47637 wxSize const &arg4_defvalue = wxDefaultSize ;
47638 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
47639 long arg5 = (long) 0 ;
47640 wxValidator const &arg6_defvalue = wxDefaultValidator ;
47641 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
47642 wxString const &arg7_defvalue = wxPyControlNameStr ;
47643 wxString *arg7 = (wxString *) &arg7_defvalue ;
47644 wxControl *result = 0 ;
47645 void *argp1 = 0 ;
47646 int res1 = 0 ;
47647 int val2 ;
47648 int ecode2 = 0 ;
47649 wxPoint temp3 ;
47650 wxSize temp4 ;
47651 long val5 ;
47652 int ecode5 = 0 ;
47653 void *argp6 = 0 ;
47654 int res6 = 0 ;
47655 bool temp7 = false ;
47656 PyObject * obj0 = 0 ;
47657 PyObject * obj1 = 0 ;
47658 PyObject * obj2 = 0 ;
47659 PyObject * obj3 = 0 ;
47660 PyObject * obj4 = 0 ;
47661 PyObject * obj5 = 0 ;
47662 PyObject * obj6 = 0 ;
47663 char * kwnames[] = {
47664 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47665 };
47666
47667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
47669 if (!SWIG_IsOK(res1)) {
47670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
47671 }
47672 arg1 = reinterpret_cast< wxWindow * >(argp1);
47673 if (obj1) {
47674 ecode2 = SWIG_AsVal_int(obj1, &val2);
47675 if (!SWIG_IsOK(ecode2)) {
47676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
47677 }
47678 arg2 = static_cast< int >(val2);
47679 }
47680 if (obj2) {
47681 {
47682 arg3 = &temp3;
47683 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
47684 }
47685 }
47686 if (obj3) {
47687 {
47688 arg4 = &temp4;
47689 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
47690 }
47691 }
47692 if (obj4) {
47693 ecode5 = SWIG_AsVal_long(obj4, &val5);
47694 if (!SWIG_IsOK(ecode5)) {
47695 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
47696 }
47697 arg5 = static_cast< long >(val5);
47698 }
47699 if (obj5) {
47700 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
47701 if (!SWIG_IsOK(res6)) {
47702 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47703 }
47704 if (!argp6) {
47705 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47706 }
47707 arg6 = reinterpret_cast< wxValidator * >(argp6);
47708 }
47709 if (obj6) {
47710 {
47711 arg7 = wxString_in_helper(obj6);
47712 if (arg7 == NULL) SWIG_fail;
47713 temp7 = true;
47714 }
47715 }
47716 {
47717 if (!wxPyCheckForApp()) SWIG_fail;
47718 PyThreadState* __tstate = wxPyBeginAllowThreads();
47719 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
47720 wxPyEndAllowThreads(__tstate);
47721 if (PyErr_Occurred()) SWIG_fail;
47722 }
47723 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
47724 {
47725 if (temp7)
47726 delete arg7;
47727 }
47728 return resultobj;
47729 fail:
47730 {
47731 if (temp7)
47732 delete arg7;
47733 }
47734 return NULL;
47735 }
47736
47737
47738 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47739 PyObject *resultobj = 0;
47740 wxControl *result = 0 ;
47741
47742 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
47743 {
47744 if (!wxPyCheckForApp()) SWIG_fail;
47745 PyThreadState* __tstate = wxPyBeginAllowThreads();
47746 result = (wxControl *)new wxControl();
47747 wxPyEndAllowThreads(__tstate);
47748 if (PyErr_Occurred()) SWIG_fail;
47749 }
47750 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
47751 return resultobj;
47752 fail:
47753 return NULL;
47754 }
47755
47756
47757 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47758 PyObject *resultobj = 0;
47759 wxControl *arg1 = (wxControl *) 0 ;
47760 wxWindow *arg2 = (wxWindow *) 0 ;
47761 int arg3 = (int) -1 ;
47762 wxPoint const &arg4_defvalue = wxDefaultPosition ;
47763 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
47764 wxSize const &arg5_defvalue = wxDefaultSize ;
47765 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
47766 long arg6 = (long) 0 ;
47767 wxValidator const &arg7_defvalue = wxDefaultValidator ;
47768 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
47769 wxString const &arg8_defvalue = wxPyControlNameStr ;
47770 wxString *arg8 = (wxString *) &arg8_defvalue ;
47771 bool result;
47772 void *argp1 = 0 ;
47773 int res1 = 0 ;
47774 void *argp2 = 0 ;
47775 int res2 = 0 ;
47776 int val3 ;
47777 int ecode3 = 0 ;
47778 wxPoint temp4 ;
47779 wxSize temp5 ;
47780 long val6 ;
47781 int ecode6 = 0 ;
47782 void *argp7 = 0 ;
47783 int res7 = 0 ;
47784 bool temp8 = false ;
47785 PyObject * obj0 = 0 ;
47786 PyObject * obj1 = 0 ;
47787 PyObject * obj2 = 0 ;
47788 PyObject * obj3 = 0 ;
47789 PyObject * obj4 = 0 ;
47790 PyObject * obj5 = 0 ;
47791 PyObject * obj6 = 0 ;
47792 PyObject * obj7 = 0 ;
47793 char * kwnames[] = {
47794 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47795 };
47796
47797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
47798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47799 if (!SWIG_IsOK(res1)) {
47800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
47801 }
47802 arg1 = reinterpret_cast< wxControl * >(argp1);
47803 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47804 if (!SWIG_IsOK(res2)) {
47805 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
47806 }
47807 arg2 = reinterpret_cast< wxWindow * >(argp2);
47808 if (obj2) {
47809 ecode3 = SWIG_AsVal_int(obj2, &val3);
47810 if (!SWIG_IsOK(ecode3)) {
47811 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
47812 }
47813 arg3 = static_cast< int >(val3);
47814 }
47815 if (obj3) {
47816 {
47817 arg4 = &temp4;
47818 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
47819 }
47820 }
47821 if (obj4) {
47822 {
47823 arg5 = &temp5;
47824 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
47825 }
47826 }
47827 if (obj5) {
47828 ecode6 = SWIG_AsVal_long(obj5, &val6);
47829 if (!SWIG_IsOK(ecode6)) {
47830 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
47831 }
47832 arg6 = static_cast< long >(val6);
47833 }
47834 if (obj6) {
47835 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
47836 if (!SWIG_IsOK(res7)) {
47837 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47838 }
47839 if (!argp7) {
47840 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47841 }
47842 arg7 = reinterpret_cast< wxValidator * >(argp7);
47843 }
47844 if (obj7) {
47845 {
47846 arg8 = wxString_in_helper(obj7);
47847 if (arg8 == NULL) SWIG_fail;
47848 temp8 = true;
47849 }
47850 }
47851 {
47852 PyThreadState* __tstate = wxPyBeginAllowThreads();
47853 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
47854 wxPyEndAllowThreads(__tstate);
47855 if (PyErr_Occurred()) SWIG_fail;
47856 }
47857 {
47858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47859 }
47860 {
47861 if (temp8)
47862 delete arg8;
47863 }
47864 return resultobj;
47865 fail:
47866 {
47867 if (temp8)
47868 delete arg8;
47869 }
47870 return NULL;
47871 }
47872
47873
47874 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47875 PyObject *resultobj = 0;
47876 wxControl *arg1 = (wxControl *) 0 ;
47877 int result;
47878 void *argp1 = 0 ;
47879 int res1 = 0 ;
47880 PyObject *swig_obj[1] ;
47881
47882 if (!args) SWIG_fail;
47883 swig_obj[0] = args;
47884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47885 if (!SWIG_IsOK(res1)) {
47886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
47887 }
47888 arg1 = reinterpret_cast< wxControl * >(argp1);
47889 {
47890 PyThreadState* __tstate = wxPyBeginAllowThreads();
47891 result = (int)((wxControl const *)arg1)->GetAlignment();
47892 wxPyEndAllowThreads(__tstate);
47893 if (PyErr_Occurred()) SWIG_fail;
47894 }
47895 resultobj = SWIG_From_int(static_cast< int >(result));
47896 return resultobj;
47897 fail:
47898 return NULL;
47899 }
47900
47901
47902 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47903 PyObject *resultobj = 0;
47904 wxControl *arg1 = (wxControl *) 0 ;
47905 wxString result;
47906 void *argp1 = 0 ;
47907 int res1 = 0 ;
47908 PyObject *swig_obj[1] ;
47909
47910 if (!args) SWIG_fail;
47911 swig_obj[0] = args;
47912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47913 if (!SWIG_IsOK(res1)) {
47914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
47915 }
47916 arg1 = reinterpret_cast< wxControl * >(argp1);
47917 {
47918 PyThreadState* __tstate = wxPyBeginAllowThreads();
47919 result = ((wxControl const *)arg1)->GetLabelText();
47920 wxPyEndAllowThreads(__tstate);
47921 if (PyErr_Occurred()) SWIG_fail;
47922 }
47923 {
47924 #if wxUSE_UNICODE
47925 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
47926 #else
47927 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
47928 #endif
47929 }
47930 return resultobj;
47931 fail:
47932 return NULL;
47933 }
47934
47935
47936 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47937 PyObject *resultobj = 0;
47938 wxControl *arg1 = (wxControl *) 0 ;
47939 wxCommandEvent *arg2 = 0 ;
47940 void *argp1 = 0 ;
47941 int res1 = 0 ;
47942 void *argp2 = 0 ;
47943 int res2 = 0 ;
47944 PyObject * obj0 = 0 ;
47945 PyObject * obj1 = 0 ;
47946 char * kwnames[] = {
47947 (char *) "self",(char *) "event", NULL
47948 };
47949
47950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
47951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47952 if (!SWIG_IsOK(res1)) {
47953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
47954 }
47955 arg1 = reinterpret_cast< wxControl * >(argp1);
47956 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
47957 if (!SWIG_IsOK(res2)) {
47958 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47959 }
47960 if (!argp2) {
47961 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47962 }
47963 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
47964 {
47965 PyThreadState* __tstate = wxPyBeginAllowThreads();
47966 (arg1)->Command(*arg2);
47967 wxPyEndAllowThreads(__tstate);
47968 if (PyErr_Occurred()) SWIG_fail;
47969 }
47970 resultobj = SWIG_Py_Void();
47971 return resultobj;
47972 fail:
47973 return NULL;
47974 }
47975
47976
47977 SWIGINTERN PyObject *_wrap_Control_RemoveMnemonics(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47978 PyObject *resultobj = 0;
47979 wxString *arg1 = 0 ;
47980 wxString result;
47981 bool temp1 = false ;
47982 PyObject * obj0 = 0 ;
47983 char * kwnames[] = {
47984 (char *) "str", NULL
47985 };
47986
47987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_RemoveMnemonics",kwnames,&obj0)) SWIG_fail;
47988 {
47989 arg1 = wxString_in_helper(obj0);
47990 if (arg1 == NULL) SWIG_fail;
47991 temp1 = true;
47992 }
47993 {
47994 PyThreadState* __tstate = wxPyBeginAllowThreads();
47995 result = wxControl::RemoveMnemonics((wxString const &)*arg1);
47996 wxPyEndAllowThreads(__tstate);
47997 if (PyErr_Occurred()) SWIG_fail;
47998 }
47999 {
48000 #if wxUSE_UNICODE
48001 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48002 #else
48003 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48004 #endif
48005 }
48006 {
48007 if (temp1)
48008 delete arg1;
48009 }
48010 return resultobj;
48011 fail:
48012 {
48013 if (temp1)
48014 delete arg1;
48015 }
48016 return NULL;
48017 }
48018
48019
48020 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48021 PyObject *resultobj = 0;
48022 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
48023 SwigValueWrapper<wxVisualAttributes > result;
48024 int val1 ;
48025 int ecode1 = 0 ;
48026 PyObject * obj0 = 0 ;
48027 char * kwnames[] = {
48028 (char *) "variant", NULL
48029 };
48030
48031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
48032 if (obj0) {
48033 ecode1 = SWIG_AsVal_int(obj0, &val1);
48034 if (!SWIG_IsOK(ecode1)) {
48035 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
48036 }
48037 arg1 = static_cast< wxWindowVariant >(val1);
48038 }
48039 {
48040 if (!wxPyCheckForApp()) SWIG_fail;
48041 PyThreadState* __tstate = wxPyBeginAllowThreads();
48042 result = wxControl::GetClassDefaultAttributes(arg1);
48043 wxPyEndAllowThreads(__tstate);
48044 if (PyErr_Occurred()) SWIG_fail;
48045 }
48046 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
48047 return resultobj;
48048 fail:
48049 return NULL;
48050 }
48051
48052
48053 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48054 PyObject *obj;
48055 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48056 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
48057 return SWIG_Py_Void();
48058 }
48059
48060 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48061 return SWIG_Python_InitShadowInstance(args);
48062 }
48063
48064 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48065 PyObject *resultobj = 0;
48066 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48067 wxString *arg2 = 0 ;
48068 PyObject *arg3 = (PyObject *) NULL ;
48069 int result;
48070 void *argp1 = 0 ;
48071 int res1 = 0 ;
48072 bool temp2 = false ;
48073 PyObject * obj0 = 0 ;
48074 PyObject * obj1 = 0 ;
48075 PyObject * obj2 = 0 ;
48076 char * kwnames[] = {
48077 (char *) "self",(char *) "item",(char *) "clientData", NULL
48078 };
48079
48080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48082 if (!SWIG_IsOK(res1)) {
48083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48084 }
48085 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48086 {
48087 arg2 = wxString_in_helper(obj1);
48088 if (arg2 == NULL) SWIG_fail;
48089 temp2 = true;
48090 }
48091 if (obj2) {
48092 arg3 = obj2;
48093 }
48094 {
48095 PyThreadState* __tstate = wxPyBeginAllowThreads();
48096 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
48097 wxPyEndAllowThreads(__tstate);
48098 if (PyErr_Occurred()) SWIG_fail;
48099 }
48100 resultobj = SWIG_From_int(static_cast< int >(result));
48101 {
48102 if (temp2)
48103 delete arg2;
48104 }
48105 return resultobj;
48106 fail:
48107 {
48108 if (temp2)
48109 delete arg2;
48110 }
48111 return NULL;
48112 }
48113
48114
48115 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48116 PyObject *resultobj = 0;
48117 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48118 wxArrayString *arg2 = 0 ;
48119 void *argp1 = 0 ;
48120 int res1 = 0 ;
48121 bool temp2 = false ;
48122 PyObject * obj0 = 0 ;
48123 PyObject * obj1 = 0 ;
48124 char * kwnames[] = {
48125 (char *) "self",(char *) "strings", NULL
48126 };
48127
48128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
48129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48130 if (!SWIG_IsOK(res1)) {
48131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48132 }
48133 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48134 {
48135 if (! PySequence_Check(obj1)) {
48136 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
48137 SWIG_fail;
48138 }
48139 arg2 = new wxArrayString;
48140 temp2 = true;
48141 int i, len=PySequence_Length(obj1);
48142 for (i=0; i<len; i++) {
48143 PyObject* item = PySequence_GetItem(obj1, i);
48144 wxString* s = wxString_in_helper(item);
48145 if (PyErr_Occurred()) SWIG_fail;
48146 arg2->Add(*s);
48147 delete s;
48148 Py_DECREF(item);
48149 }
48150 }
48151 {
48152 PyThreadState* __tstate = wxPyBeginAllowThreads();
48153 (arg1)->Append((wxArrayString const &)*arg2);
48154 wxPyEndAllowThreads(__tstate);
48155 if (PyErr_Occurred()) SWIG_fail;
48156 }
48157 resultobj = SWIG_Py_Void();
48158 {
48159 if (temp2) delete arg2;
48160 }
48161 return resultobj;
48162 fail:
48163 {
48164 if (temp2) delete arg2;
48165 }
48166 return NULL;
48167 }
48168
48169
48170 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48171 PyObject *resultobj = 0;
48172 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48173 wxString *arg2 = 0 ;
48174 int arg3 ;
48175 PyObject *arg4 = (PyObject *) NULL ;
48176 int result;
48177 void *argp1 = 0 ;
48178 int res1 = 0 ;
48179 bool temp2 = false ;
48180 int val3 ;
48181 int ecode3 = 0 ;
48182 PyObject * obj0 = 0 ;
48183 PyObject * obj1 = 0 ;
48184 PyObject * obj2 = 0 ;
48185 PyObject * obj3 = 0 ;
48186 char * kwnames[] = {
48187 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
48188 };
48189
48190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48192 if (!SWIG_IsOK(res1)) {
48193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48194 }
48195 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48196 {
48197 arg2 = wxString_in_helper(obj1);
48198 if (arg2 == NULL) SWIG_fail;
48199 temp2 = true;
48200 }
48201 ecode3 = SWIG_AsVal_int(obj2, &val3);
48202 if (!SWIG_IsOK(ecode3)) {
48203 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "int""'");
48204 }
48205 arg3 = static_cast< int >(val3);
48206 if (obj3) {
48207 arg4 = obj3;
48208 }
48209 {
48210 PyThreadState* __tstate = wxPyBeginAllowThreads();
48211 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
48212 wxPyEndAllowThreads(__tstate);
48213 if (PyErr_Occurred()) SWIG_fail;
48214 }
48215 resultobj = SWIG_From_int(static_cast< int >(result));
48216 {
48217 if (temp2)
48218 delete arg2;
48219 }
48220 return resultobj;
48221 fail:
48222 {
48223 if (temp2)
48224 delete arg2;
48225 }
48226 return NULL;
48227 }
48228
48229
48230 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48231 PyObject *resultobj = 0;
48232 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48233 void *argp1 = 0 ;
48234 int res1 = 0 ;
48235 PyObject *swig_obj[1] ;
48236
48237 if (!args) SWIG_fail;
48238 swig_obj[0] = args;
48239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48240 if (!SWIG_IsOK(res1)) {
48241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48242 }
48243 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48244 {
48245 PyThreadState* __tstate = wxPyBeginAllowThreads();
48246 (arg1)->Clear();
48247 wxPyEndAllowThreads(__tstate);
48248 if (PyErr_Occurred()) SWIG_fail;
48249 }
48250 resultobj = SWIG_Py_Void();
48251 return resultobj;
48252 fail:
48253 return NULL;
48254 }
48255
48256
48257 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48258 PyObject *resultobj = 0;
48259 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48260 int arg2 ;
48261 void *argp1 = 0 ;
48262 int res1 = 0 ;
48263 int val2 ;
48264 int ecode2 = 0 ;
48265 PyObject * obj0 = 0 ;
48266 PyObject * obj1 = 0 ;
48267 char * kwnames[] = {
48268 (char *) "self",(char *) "n", NULL
48269 };
48270
48271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
48272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48273 if (!SWIG_IsOK(res1)) {
48274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48275 }
48276 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48277 ecode2 = SWIG_AsVal_int(obj1, &val2);
48278 if (!SWIG_IsOK(ecode2)) {
48279 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "int""'");
48280 }
48281 arg2 = static_cast< int >(val2);
48282 {
48283 PyThreadState* __tstate = wxPyBeginAllowThreads();
48284 (arg1)->Delete(arg2);
48285 wxPyEndAllowThreads(__tstate);
48286 if (PyErr_Occurred()) SWIG_fail;
48287 }
48288 resultobj = SWIG_Py_Void();
48289 return resultobj;
48290 fail:
48291 return NULL;
48292 }
48293
48294
48295 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48296 PyObject *resultobj = 0;
48297 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48298 int arg2 ;
48299 PyObject *result = 0 ;
48300 void *argp1 = 0 ;
48301 int res1 = 0 ;
48302 int val2 ;
48303 int ecode2 = 0 ;
48304 PyObject * obj0 = 0 ;
48305 PyObject * obj1 = 0 ;
48306 char * kwnames[] = {
48307 (char *) "self",(char *) "n", NULL
48308 };
48309
48310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
48311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48312 if (!SWIG_IsOK(res1)) {
48313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48314 }
48315 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48316 ecode2 = SWIG_AsVal_int(obj1, &val2);
48317 if (!SWIG_IsOK(ecode2)) {
48318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "int""'");
48319 }
48320 arg2 = static_cast< int >(val2);
48321 {
48322 PyThreadState* __tstate = wxPyBeginAllowThreads();
48323 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
48324 wxPyEndAllowThreads(__tstate);
48325 if (PyErr_Occurred()) SWIG_fail;
48326 }
48327 resultobj = result;
48328 return resultobj;
48329 fail:
48330 return NULL;
48331 }
48332
48333
48334 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48335 PyObject *resultobj = 0;
48336 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48337 int arg2 ;
48338 PyObject *arg3 = (PyObject *) 0 ;
48339 void *argp1 = 0 ;
48340 int res1 = 0 ;
48341 int val2 ;
48342 int ecode2 = 0 ;
48343 PyObject * obj0 = 0 ;
48344 PyObject * obj1 = 0 ;
48345 PyObject * obj2 = 0 ;
48346 char * kwnames[] = {
48347 (char *) "self",(char *) "n",(char *) "clientData", NULL
48348 };
48349
48350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48352 if (!SWIG_IsOK(res1)) {
48353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48354 }
48355 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48356 ecode2 = SWIG_AsVal_int(obj1, &val2);
48357 if (!SWIG_IsOK(ecode2)) {
48358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "int""'");
48359 }
48360 arg2 = static_cast< int >(val2);
48361 arg3 = obj2;
48362 {
48363 PyThreadState* __tstate = wxPyBeginAllowThreads();
48364 wxItemContainer_SetClientData(arg1,arg2,arg3);
48365 wxPyEndAllowThreads(__tstate);
48366 if (PyErr_Occurred()) SWIG_fail;
48367 }
48368 resultobj = SWIG_Py_Void();
48369 return resultobj;
48370 fail:
48371 return NULL;
48372 }
48373
48374
48375 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48376 PyObject *resultobj = 0;
48377 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48378 int result;
48379 void *argp1 = 0 ;
48380 int res1 = 0 ;
48381 PyObject *swig_obj[1] ;
48382
48383 if (!args) SWIG_fail;
48384 swig_obj[0] = args;
48385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48386 if (!SWIG_IsOK(res1)) {
48387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48388 }
48389 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48390 {
48391 PyThreadState* __tstate = wxPyBeginAllowThreads();
48392 result = (int)((wxItemContainer const *)arg1)->GetCount();
48393 wxPyEndAllowThreads(__tstate);
48394 if (PyErr_Occurred()) SWIG_fail;
48395 }
48396 resultobj = SWIG_From_int(static_cast< int >(result));
48397 return resultobj;
48398 fail:
48399 return NULL;
48400 }
48401
48402
48403 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48404 PyObject *resultobj = 0;
48405 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48406 bool result;
48407 void *argp1 = 0 ;
48408 int res1 = 0 ;
48409 PyObject *swig_obj[1] ;
48410
48411 if (!args) SWIG_fail;
48412 swig_obj[0] = args;
48413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48414 if (!SWIG_IsOK(res1)) {
48415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48416 }
48417 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48418 {
48419 PyThreadState* __tstate = wxPyBeginAllowThreads();
48420 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
48421 wxPyEndAllowThreads(__tstate);
48422 if (PyErr_Occurred()) SWIG_fail;
48423 }
48424 {
48425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48426 }
48427 return resultobj;
48428 fail:
48429 return NULL;
48430 }
48431
48432
48433 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48434 PyObject *resultobj = 0;
48435 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48436 int arg2 ;
48437 wxString result;
48438 void *argp1 = 0 ;
48439 int res1 = 0 ;
48440 int val2 ;
48441 int ecode2 = 0 ;
48442 PyObject * obj0 = 0 ;
48443 PyObject * obj1 = 0 ;
48444 char * kwnames[] = {
48445 (char *) "self",(char *) "n", NULL
48446 };
48447
48448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
48449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48450 if (!SWIG_IsOK(res1)) {
48451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48452 }
48453 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48454 ecode2 = SWIG_AsVal_int(obj1, &val2);
48455 if (!SWIG_IsOK(ecode2)) {
48456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "int""'");
48457 }
48458 arg2 = static_cast< int >(val2);
48459 {
48460 PyThreadState* __tstate = wxPyBeginAllowThreads();
48461 result = ((wxItemContainer const *)arg1)->GetString(arg2);
48462 wxPyEndAllowThreads(__tstate);
48463 if (PyErr_Occurred()) SWIG_fail;
48464 }
48465 {
48466 #if wxUSE_UNICODE
48467 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48468 #else
48469 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48470 #endif
48471 }
48472 return resultobj;
48473 fail:
48474 return NULL;
48475 }
48476
48477
48478 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48479 PyObject *resultobj = 0;
48480 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48481 wxArrayString result;
48482 void *argp1 = 0 ;
48483 int res1 = 0 ;
48484 PyObject *swig_obj[1] ;
48485
48486 if (!args) SWIG_fail;
48487 swig_obj[0] = args;
48488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48489 if (!SWIG_IsOK(res1)) {
48490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48491 }
48492 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48493 {
48494 PyThreadState* __tstate = wxPyBeginAllowThreads();
48495 result = ((wxItemContainer const *)arg1)->GetStrings();
48496 wxPyEndAllowThreads(__tstate);
48497 if (PyErr_Occurred()) SWIG_fail;
48498 }
48499 {
48500 resultobj = wxArrayString2PyList_helper(result);
48501 }
48502 return resultobj;
48503 fail:
48504 return NULL;
48505 }
48506
48507
48508 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48509 PyObject *resultobj = 0;
48510 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48511 int arg2 ;
48512 wxString *arg3 = 0 ;
48513 void *argp1 = 0 ;
48514 int res1 = 0 ;
48515 int val2 ;
48516 int ecode2 = 0 ;
48517 bool temp3 = false ;
48518 PyObject * obj0 = 0 ;
48519 PyObject * obj1 = 0 ;
48520 PyObject * obj2 = 0 ;
48521 char * kwnames[] = {
48522 (char *) "self",(char *) "n",(char *) "s", NULL
48523 };
48524
48525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48527 if (!SWIG_IsOK(res1)) {
48528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48529 }
48530 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48531 ecode2 = SWIG_AsVal_int(obj1, &val2);
48532 if (!SWIG_IsOK(ecode2)) {
48533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "int""'");
48534 }
48535 arg2 = static_cast< int >(val2);
48536 {
48537 arg3 = wxString_in_helper(obj2);
48538 if (arg3 == NULL) SWIG_fail;
48539 temp3 = true;
48540 }
48541 {
48542 PyThreadState* __tstate = wxPyBeginAllowThreads();
48543 (arg1)->SetString(arg2,(wxString const &)*arg3);
48544 wxPyEndAllowThreads(__tstate);
48545 if (PyErr_Occurred()) SWIG_fail;
48546 }
48547 resultobj = SWIG_Py_Void();
48548 {
48549 if (temp3)
48550 delete arg3;
48551 }
48552 return resultobj;
48553 fail:
48554 {
48555 if (temp3)
48556 delete arg3;
48557 }
48558 return NULL;
48559 }
48560
48561
48562 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48563 PyObject *resultobj = 0;
48564 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48565 wxString *arg2 = 0 ;
48566 int result;
48567 void *argp1 = 0 ;
48568 int res1 = 0 ;
48569 bool temp2 = false ;
48570 PyObject * obj0 = 0 ;
48571 PyObject * obj1 = 0 ;
48572 char * kwnames[] = {
48573 (char *) "self",(char *) "s", NULL
48574 };
48575
48576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
48577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48578 if (!SWIG_IsOK(res1)) {
48579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48580 }
48581 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48582 {
48583 arg2 = wxString_in_helper(obj1);
48584 if (arg2 == NULL) SWIG_fail;
48585 temp2 = true;
48586 }
48587 {
48588 PyThreadState* __tstate = wxPyBeginAllowThreads();
48589 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
48590 wxPyEndAllowThreads(__tstate);
48591 if (PyErr_Occurred()) SWIG_fail;
48592 }
48593 resultobj = SWIG_From_int(static_cast< int >(result));
48594 {
48595 if (temp2)
48596 delete arg2;
48597 }
48598 return resultobj;
48599 fail:
48600 {
48601 if (temp2)
48602 delete arg2;
48603 }
48604 return NULL;
48605 }
48606
48607
48608 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48609 PyObject *resultobj = 0;
48610 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48611 int arg2 ;
48612 void *argp1 = 0 ;
48613 int res1 = 0 ;
48614 int val2 ;
48615 int ecode2 = 0 ;
48616 PyObject * obj0 = 0 ;
48617 PyObject * obj1 = 0 ;
48618 char * kwnames[] = {
48619 (char *) "self",(char *) "n", NULL
48620 };
48621
48622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48624 if (!SWIG_IsOK(res1)) {
48625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48626 }
48627 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48628 ecode2 = SWIG_AsVal_int(obj1, &val2);
48629 if (!SWIG_IsOK(ecode2)) {
48630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
48631 }
48632 arg2 = static_cast< int >(val2);
48633 {
48634 PyThreadState* __tstate = wxPyBeginAllowThreads();
48635 (arg1)->SetSelection(arg2);
48636 wxPyEndAllowThreads(__tstate);
48637 if (PyErr_Occurred()) SWIG_fail;
48638 }
48639 resultobj = SWIG_Py_Void();
48640 return resultobj;
48641 fail:
48642 return NULL;
48643 }
48644
48645
48646 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48647 PyObject *resultobj = 0;
48648 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48649 int result;
48650 void *argp1 = 0 ;
48651 int res1 = 0 ;
48652 PyObject *swig_obj[1] ;
48653
48654 if (!args) SWIG_fail;
48655 swig_obj[0] = args;
48656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48657 if (!SWIG_IsOK(res1)) {
48658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48659 }
48660 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48661 {
48662 PyThreadState* __tstate = wxPyBeginAllowThreads();
48663 result = (int)((wxItemContainer const *)arg1)->GetSelection();
48664 wxPyEndAllowThreads(__tstate);
48665 if (PyErr_Occurred()) SWIG_fail;
48666 }
48667 resultobj = SWIG_From_int(static_cast< int >(result));
48668 return resultobj;
48669 fail:
48670 return NULL;
48671 }
48672
48673
48674 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48675 PyObject *resultobj = 0;
48676 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48677 wxString *arg2 = 0 ;
48678 bool result;
48679 void *argp1 = 0 ;
48680 int res1 = 0 ;
48681 bool temp2 = false ;
48682 PyObject * obj0 = 0 ;
48683 PyObject * obj1 = 0 ;
48684 char * kwnames[] = {
48685 (char *) "self",(char *) "s", NULL
48686 };
48687
48688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48690 if (!SWIG_IsOK(res1)) {
48691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48692 }
48693 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48694 {
48695 arg2 = wxString_in_helper(obj1);
48696 if (arg2 == NULL) SWIG_fail;
48697 temp2 = true;
48698 }
48699 {
48700 PyThreadState* __tstate = wxPyBeginAllowThreads();
48701 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
48702 wxPyEndAllowThreads(__tstate);
48703 if (PyErr_Occurred()) SWIG_fail;
48704 }
48705 {
48706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48707 }
48708 {
48709 if (temp2)
48710 delete arg2;
48711 }
48712 return resultobj;
48713 fail:
48714 {
48715 if (temp2)
48716 delete arg2;
48717 }
48718 return NULL;
48719 }
48720
48721
48722 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48723 PyObject *resultobj = 0;
48724 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48725 wxString result;
48726 void *argp1 = 0 ;
48727 int res1 = 0 ;
48728 PyObject *swig_obj[1] ;
48729
48730 if (!args) SWIG_fail;
48731 swig_obj[0] = args;
48732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48733 if (!SWIG_IsOK(res1)) {
48734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48735 }
48736 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48737 {
48738 PyThreadState* __tstate = wxPyBeginAllowThreads();
48739 result = ((wxItemContainer const *)arg1)->GetStringSelection();
48740 wxPyEndAllowThreads(__tstate);
48741 if (PyErr_Occurred()) SWIG_fail;
48742 }
48743 {
48744 #if wxUSE_UNICODE
48745 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48746 #else
48747 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48748 #endif
48749 }
48750 return resultobj;
48751 fail:
48752 return NULL;
48753 }
48754
48755
48756 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48757 PyObject *resultobj = 0;
48758 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48759 int arg2 ;
48760 void *argp1 = 0 ;
48761 int res1 = 0 ;
48762 int val2 ;
48763 int ecode2 = 0 ;
48764 PyObject * obj0 = 0 ;
48765 PyObject * obj1 = 0 ;
48766 char * kwnames[] = {
48767 (char *) "self",(char *) "n", NULL
48768 };
48769
48770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
48771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48772 if (!SWIG_IsOK(res1)) {
48773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48774 }
48775 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48776 ecode2 = SWIG_AsVal_int(obj1, &val2);
48777 if (!SWIG_IsOK(ecode2)) {
48778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
48779 }
48780 arg2 = static_cast< int >(val2);
48781 {
48782 PyThreadState* __tstate = wxPyBeginAllowThreads();
48783 (arg1)->Select(arg2);
48784 wxPyEndAllowThreads(__tstate);
48785 if (PyErr_Occurred()) SWIG_fail;
48786 }
48787 resultobj = SWIG_Py_Void();
48788 return resultobj;
48789 fail:
48790 return NULL;
48791 }
48792
48793
48794 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48795 PyObject *obj;
48796 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48797 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
48798 return SWIG_Py_Void();
48799 }
48800
48801 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48802 PyObject *obj;
48803 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48804 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
48805 return SWIG_Py_Void();
48806 }
48807
48808 SWIGINTERN PyObject *_wrap_new_SizerFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48809 PyObject *resultobj = 0;
48810 int arg1 = (int) 0 ;
48811 wxSizerFlags *result = 0 ;
48812 int val1 ;
48813 int ecode1 = 0 ;
48814 PyObject * obj0 = 0 ;
48815 char * kwnames[] = {
48816 (char *) "proportion", NULL
48817 };
48818
48819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_SizerFlags",kwnames,&obj0)) SWIG_fail;
48820 if (obj0) {
48821 ecode1 = SWIG_AsVal_int(obj0, &val1);
48822 if (!SWIG_IsOK(ecode1)) {
48823 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerFlags" "', expected argument " "1"" of type '" "int""'");
48824 }
48825 arg1 = static_cast< int >(val1);
48826 }
48827 {
48828 PyThreadState* __tstate = wxPyBeginAllowThreads();
48829 result = (wxSizerFlags *)new wxSizerFlags(arg1);
48830 wxPyEndAllowThreads(__tstate);
48831 if (PyErr_Occurred()) SWIG_fail;
48832 }
48833 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerFlags, SWIG_POINTER_NEW | 0 );
48834 return resultobj;
48835 fail:
48836 return NULL;
48837 }
48838
48839
48840 SWIGINTERN PyObject *_wrap_delete_SizerFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48841 PyObject *resultobj = 0;
48842 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
48843 void *argp1 = 0 ;
48844 int res1 = 0 ;
48845 PyObject *swig_obj[1] ;
48846
48847 if (!args) SWIG_fail;
48848 swig_obj[0] = args;
48849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, SWIG_POINTER_DISOWN | 0 );
48850 if (!SWIG_IsOK(res1)) {
48851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerFlags" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
48852 }
48853 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
48854 {
48855 PyThreadState* __tstate = wxPyBeginAllowThreads();
48856 delete arg1;
48857
48858 wxPyEndAllowThreads(__tstate);
48859 if (PyErr_Occurred()) SWIG_fail;
48860 }
48861 resultobj = SWIG_Py_Void();
48862 return resultobj;
48863 fail:
48864 return NULL;
48865 }
48866
48867
48868 SWIGINTERN PyObject *_wrap_SizerFlags_Proportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48869 PyObject *resultobj = 0;
48870 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
48871 int arg2 ;
48872 wxSizerFlags *result = 0 ;
48873 void *argp1 = 0 ;
48874 int res1 = 0 ;
48875 int val2 ;
48876 int ecode2 = 0 ;
48877 PyObject * obj0 = 0 ;
48878 PyObject * obj1 = 0 ;
48879 char * kwnames[] = {
48880 (char *) "self",(char *) "proportion", NULL
48881 };
48882
48883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerFlags_Proportion",kwnames,&obj0,&obj1)) SWIG_fail;
48884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
48885 if (!SWIG_IsOK(res1)) {
48886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Proportion" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
48887 }
48888 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
48889 ecode2 = SWIG_AsVal_int(obj1, &val2);
48890 if (!SWIG_IsOK(ecode2)) {
48891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_Proportion" "', expected argument " "2"" of type '" "int""'");
48892 }
48893 arg2 = static_cast< int >(val2);
48894 {
48895 PyThreadState* __tstate = wxPyBeginAllowThreads();
48896 {
48897 wxSizerFlags &_result_ref = (arg1)->Proportion(arg2);
48898 result = (wxSizerFlags *) &_result_ref;
48899 }
48900 wxPyEndAllowThreads(__tstate);
48901 if (PyErr_Occurred()) SWIG_fail;
48902 }
48903 {
48904 resultobj = obj0; Py_INCREF(resultobj);
48905 }
48906 return resultobj;
48907 fail:
48908 return NULL;
48909 }
48910
48911
48912 SWIGINTERN PyObject *_wrap_SizerFlags_Align(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48913 PyObject *resultobj = 0;
48914 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
48915 int arg2 ;
48916 wxSizerFlags *result = 0 ;
48917 void *argp1 = 0 ;
48918 int res1 = 0 ;
48919 int val2 ;
48920 int ecode2 = 0 ;
48921 PyObject * obj0 = 0 ;
48922 PyObject * obj1 = 0 ;
48923 char * kwnames[] = {
48924 (char *) "self",(char *) "alignment", NULL
48925 };
48926
48927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerFlags_Align",kwnames,&obj0,&obj1)) SWIG_fail;
48928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
48929 if (!SWIG_IsOK(res1)) {
48930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Align" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
48931 }
48932 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
48933 ecode2 = SWIG_AsVal_int(obj1, &val2);
48934 if (!SWIG_IsOK(ecode2)) {
48935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_Align" "', expected argument " "2"" of type '" "int""'");
48936 }
48937 arg2 = static_cast< int >(val2);
48938 {
48939 PyThreadState* __tstate = wxPyBeginAllowThreads();
48940 {
48941 wxSizerFlags &_result_ref = (arg1)->Align(arg2);
48942 result = (wxSizerFlags *) &_result_ref;
48943 }
48944 wxPyEndAllowThreads(__tstate);
48945 if (PyErr_Occurred()) SWIG_fail;
48946 }
48947 {
48948 resultobj = obj0; Py_INCREF(resultobj);
48949 }
48950 return resultobj;
48951 fail:
48952 return NULL;
48953 }
48954
48955
48956 SWIGINTERN PyObject *_wrap_SizerFlags_Expand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48957 PyObject *resultobj = 0;
48958 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
48959 wxSizerFlags *result = 0 ;
48960 void *argp1 = 0 ;
48961 int res1 = 0 ;
48962 PyObject *swig_obj[1] ;
48963
48964 if (!args) SWIG_fail;
48965 swig_obj[0] = args;
48966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
48967 if (!SWIG_IsOK(res1)) {
48968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Expand" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
48969 }
48970 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
48971 {
48972 PyThreadState* __tstate = wxPyBeginAllowThreads();
48973 {
48974 wxSizerFlags &_result_ref = (arg1)->Expand();
48975 result = (wxSizerFlags *) &_result_ref;
48976 }
48977 wxPyEndAllowThreads(__tstate);
48978 if (PyErr_Occurred()) SWIG_fail;
48979 }
48980 {
48981 resultobj = swig_obj[0]; Py_INCREF(resultobj);
48982 }
48983 return resultobj;
48984 fail:
48985 return NULL;
48986 }
48987
48988
48989 SWIGINTERN PyObject *_wrap_SizerFlags_Centre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48990 PyObject *resultobj = 0;
48991 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
48992 wxSizerFlags *result = 0 ;
48993 void *argp1 = 0 ;
48994 int res1 = 0 ;
48995 PyObject *swig_obj[1] ;
48996
48997 if (!args) SWIG_fail;
48998 swig_obj[0] = args;
48999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49000 if (!SWIG_IsOK(res1)) {
49001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Centre" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49002 }
49003 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49004 {
49005 PyThreadState* __tstate = wxPyBeginAllowThreads();
49006 {
49007 wxSizerFlags &_result_ref = (arg1)->Centre();
49008 result = (wxSizerFlags *) &_result_ref;
49009 }
49010 wxPyEndAllowThreads(__tstate);
49011 if (PyErr_Occurred()) SWIG_fail;
49012 }
49013 {
49014 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49015 }
49016 return resultobj;
49017 fail:
49018 return NULL;
49019 }
49020
49021
49022 SWIGINTERN PyObject *_wrap_SizerFlags_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49023 PyObject *resultobj = 0;
49024 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49025 wxSizerFlags *result = 0 ;
49026 void *argp1 = 0 ;
49027 int res1 = 0 ;
49028 PyObject *swig_obj[1] ;
49029
49030 if (!args) SWIG_fail;
49031 swig_obj[0] = args;
49032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49033 if (!SWIG_IsOK(res1)) {
49034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Center" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49035 }
49036 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49037 {
49038 PyThreadState* __tstate = wxPyBeginAllowThreads();
49039 {
49040 wxSizerFlags &_result_ref = (arg1)->Center();
49041 result = (wxSizerFlags *) &_result_ref;
49042 }
49043 wxPyEndAllowThreads(__tstate);
49044 if (PyErr_Occurred()) SWIG_fail;
49045 }
49046 {
49047 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49048 }
49049 return resultobj;
49050 fail:
49051 return NULL;
49052 }
49053
49054
49055 SWIGINTERN PyObject *_wrap_SizerFlags_Left(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49056 PyObject *resultobj = 0;
49057 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49058 wxSizerFlags *result = 0 ;
49059 void *argp1 = 0 ;
49060 int res1 = 0 ;
49061 PyObject *swig_obj[1] ;
49062
49063 if (!args) SWIG_fail;
49064 swig_obj[0] = args;
49065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49066 if (!SWIG_IsOK(res1)) {
49067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Left" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49068 }
49069 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49070 {
49071 PyThreadState* __tstate = wxPyBeginAllowThreads();
49072 {
49073 wxSizerFlags &_result_ref = (arg1)->Left();
49074 result = (wxSizerFlags *) &_result_ref;
49075 }
49076 wxPyEndAllowThreads(__tstate);
49077 if (PyErr_Occurred()) SWIG_fail;
49078 }
49079 {
49080 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49081 }
49082 return resultobj;
49083 fail:
49084 return NULL;
49085 }
49086
49087
49088 SWIGINTERN PyObject *_wrap_SizerFlags_Right(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49089 PyObject *resultobj = 0;
49090 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49091 wxSizerFlags *result = 0 ;
49092 void *argp1 = 0 ;
49093 int res1 = 0 ;
49094 PyObject *swig_obj[1] ;
49095
49096 if (!args) SWIG_fail;
49097 swig_obj[0] = args;
49098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49099 if (!SWIG_IsOK(res1)) {
49100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Right" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49101 }
49102 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49103 {
49104 PyThreadState* __tstate = wxPyBeginAllowThreads();
49105 {
49106 wxSizerFlags &_result_ref = (arg1)->Right();
49107 result = (wxSizerFlags *) &_result_ref;
49108 }
49109 wxPyEndAllowThreads(__tstate);
49110 if (PyErr_Occurred()) SWIG_fail;
49111 }
49112 {
49113 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49114 }
49115 return resultobj;
49116 fail:
49117 return NULL;
49118 }
49119
49120
49121 SWIGINTERN PyObject *_wrap_SizerFlags_Top(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49122 PyObject *resultobj = 0;
49123 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49124 wxSizerFlags *result = 0 ;
49125 void *argp1 = 0 ;
49126 int res1 = 0 ;
49127 PyObject *swig_obj[1] ;
49128
49129 if (!args) SWIG_fail;
49130 swig_obj[0] = args;
49131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49132 if (!SWIG_IsOK(res1)) {
49133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Top" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49134 }
49135 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49136 {
49137 PyThreadState* __tstate = wxPyBeginAllowThreads();
49138 {
49139 wxSizerFlags &_result_ref = (arg1)->Top();
49140 result = (wxSizerFlags *) &_result_ref;
49141 }
49142 wxPyEndAllowThreads(__tstate);
49143 if (PyErr_Occurred()) SWIG_fail;
49144 }
49145 {
49146 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49147 }
49148 return resultobj;
49149 fail:
49150 return NULL;
49151 }
49152
49153
49154 SWIGINTERN PyObject *_wrap_SizerFlags_Bottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49155 PyObject *resultobj = 0;
49156 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49157 wxSizerFlags *result = 0 ;
49158 void *argp1 = 0 ;
49159 int res1 = 0 ;
49160 PyObject *swig_obj[1] ;
49161
49162 if (!args) SWIG_fail;
49163 swig_obj[0] = args;
49164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49165 if (!SWIG_IsOK(res1)) {
49166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Bottom" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49167 }
49168 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49169 {
49170 PyThreadState* __tstate = wxPyBeginAllowThreads();
49171 {
49172 wxSizerFlags &_result_ref = (arg1)->Bottom();
49173 result = (wxSizerFlags *) &_result_ref;
49174 }
49175 wxPyEndAllowThreads(__tstate);
49176 if (PyErr_Occurred()) SWIG_fail;
49177 }
49178 {
49179 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49180 }
49181 return resultobj;
49182 fail:
49183 return NULL;
49184 }
49185
49186
49187 SWIGINTERN PyObject *_wrap_SizerFlags_Shaped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49188 PyObject *resultobj = 0;
49189 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49190 wxSizerFlags *result = 0 ;
49191 void *argp1 = 0 ;
49192 int res1 = 0 ;
49193 PyObject *swig_obj[1] ;
49194
49195 if (!args) SWIG_fail;
49196 swig_obj[0] = args;
49197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49198 if (!SWIG_IsOK(res1)) {
49199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Shaped" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49200 }
49201 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49202 {
49203 PyThreadState* __tstate = wxPyBeginAllowThreads();
49204 {
49205 wxSizerFlags &_result_ref = (arg1)->Shaped();
49206 result = (wxSizerFlags *) &_result_ref;
49207 }
49208 wxPyEndAllowThreads(__tstate);
49209 if (PyErr_Occurred()) SWIG_fail;
49210 }
49211 {
49212 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49213 }
49214 return resultobj;
49215 fail:
49216 return NULL;
49217 }
49218
49219
49220 SWIGINTERN PyObject *_wrap_SizerFlags_FixedMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49221 PyObject *resultobj = 0;
49222 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49223 wxSizerFlags *result = 0 ;
49224 void *argp1 = 0 ;
49225 int res1 = 0 ;
49226 PyObject *swig_obj[1] ;
49227
49228 if (!args) SWIG_fail;
49229 swig_obj[0] = args;
49230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49231 if (!SWIG_IsOK(res1)) {
49232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_FixedMinSize" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49233 }
49234 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49235 {
49236 PyThreadState* __tstate = wxPyBeginAllowThreads();
49237 {
49238 wxSizerFlags &_result_ref = (arg1)->FixedMinSize();
49239 result = (wxSizerFlags *) &_result_ref;
49240 }
49241 wxPyEndAllowThreads(__tstate);
49242 if (PyErr_Occurred()) SWIG_fail;
49243 }
49244 {
49245 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49246 }
49247 return resultobj;
49248 fail:
49249 return NULL;
49250 }
49251
49252
49253 SWIGINTERN PyObject *_wrap_SizerFlags_Border(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49254 PyObject *resultobj = 0;
49255 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49256 int arg2 = (int) wxALL ;
49257 int arg3 = (int) -1 ;
49258 wxSizerFlags *result = 0 ;
49259 void *argp1 = 0 ;
49260 int res1 = 0 ;
49261 int val2 ;
49262 int ecode2 = 0 ;
49263 int val3 ;
49264 int ecode3 = 0 ;
49265 PyObject * obj0 = 0 ;
49266 PyObject * obj1 = 0 ;
49267 PyObject * obj2 = 0 ;
49268 char * kwnames[] = {
49269 (char *) "self",(char *) "direction",(char *) "borderInPixels", NULL
49270 };
49271
49272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:SizerFlags_Border",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49274 if (!SWIG_IsOK(res1)) {
49275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Border" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49276 }
49277 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49278 if (obj1) {
49279 ecode2 = SWIG_AsVal_int(obj1, &val2);
49280 if (!SWIG_IsOK(ecode2)) {
49281 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_Border" "', expected argument " "2"" of type '" "int""'");
49282 }
49283 arg2 = static_cast< int >(val2);
49284 }
49285 if (obj2) {
49286 ecode3 = SWIG_AsVal_int(obj2, &val3);
49287 if (!SWIG_IsOK(ecode3)) {
49288 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerFlags_Border" "', expected argument " "3"" of type '" "int""'");
49289 }
49290 arg3 = static_cast< int >(val3);
49291 }
49292 {
49293 PyThreadState* __tstate = wxPyBeginAllowThreads();
49294 {
49295 wxSizerFlags &_result_ref = wxSizerFlags_Border(arg1,arg2,arg3);
49296 result = (wxSizerFlags *) &_result_ref;
49297 }
49298 wxPyEndAllowThreads(__tstate);
49299 if (PyErr_Occurred()) SWIG_fail;
49300 }
49301 {
49302 resultobj = obj0; Py_INCREF(resultobj);
49303 }
49304 return resultobj;
49305 fail:
49306 return NULL;
49307 }
49308
49309
49310 SWIGINTERN PyObject *_wrap_SizerFlags_DoubleBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49311 PyObject *resultobj = 0;
49312 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49313 int arg2 = (int) wxALL ;
49314 wxSizerFlags *result = 0 ;
49315 void *argp1 = 0 ;
49316 int res1 = 0 ;
49317 int val2 ;
49318 int ecode2 = 0 ;
49319 PyObject * obj0 = 0 ;
49320 PyObject * obj1 = 0 ;
49321 char * kwnames[] = {
49322 (char *) "self",(char *) "direction", NULL
49323 };
49324
49325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SizerFlags_DoubleBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49327 if (!SWIG_IsOK(res1)) {
49328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_DoubleBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49329 }
49330 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49331 if (obj1) {
49332 ecode2 = SWIG_AsVal_int(obj1, &val2);
49333 if (!SWIG_IsOK(ecode2)) {
49334 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_DoubleBorder" "', expected argument " "2"" of type '" "int""'");
49335 }
49336 arg2 = static_cast< int >(val2);
49337 }
49338 {
49339 PyThreadState* __tstate = wxPyBeginAllowThreads();
49340 {
49341 wxSizerFlags &_result_ref = (arg1)->DoubleBorder(arg2);
49342 result = (wxSizerFlags *) &_result_ref;
49343 }
49344 wxPyEndAllowThreads(__tstate);
49345 if (PyErr_Occurred()) SWIG_fail;
49346 }
49347 {
49348 resultobj = obj0; Py_INCREF(resultobj);
49349 }
49350 return resultobj;
49351 fail:
49352 return NULL;
49353 }
49354
49355
49356 SWIGINTERN PyObject *_wrap_SizerFlags_TripleBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49357 PyObject *resultobj = 0;
49358 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49359 int arg2 = (int) wxALL ;
49360 wxSizerFlags *result = 0 ;
49361 void *argp1 = 0 ;
49362 int res1 = 0 ;
49363 int val2 ;
49364 int ecode2 = 0 ;
49365 PyObject * obj0 = 0 ;
49366 PyObject * obj1 = 0 ;
49367 char * kwnames[] = {
49368 (char *) "self",(char *) "direction", NULL
49369 };
49370
49371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SizerFlags_TripleBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49373 if (!SWIG_IsOK(res1)) {
49374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_TripleBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49375 }
49376 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49377 if (obj1) {
49378 ecode2 = SWIG_AsVal_int(obj1, &val2);
49379 if (!SWIG_IsOK(ecode2)) {
49380 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_TripleBorder" "', expected argument " "2"" of type '" "int""'");
49381 }
49382 arg2 = static_cast< int >(val2);
49383 }
49384 {
49385 PyThreadState* __tstate = wxPyBeginAllowThreads();
49386 {
49387 wxSizerFlags &_result_ref = (arg1)->TripleBorder(arg2);
49388 result = (wxSizerFlags *) &_result_ref;
49389 }
49390 wxPyEndAllowThreads(__tstate);
49391 if (PyErr_Occurred()) SWIG_fail;
49392 }
49393 {
49394 resultobj = obj0; Py_INCREF(resultobj);
49395 }
49396 return resultobj;
49397 fail:
49398 return NULL;
49399 }
49400
49401
49402 SWIGINTERN PyObject *_wrap_SizerFlags_HorzBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49403 PyObject *resultobj = 0;
49404 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49405 wxSizerFlags *result = 0 ;
49406 void *argp1 = 0 ;
49407 int res1 = 0 ;
49408 PyObject *swig_obj[1] ;
49409
49410 if (!args) SWIG_fail;
49411 swig_obj[0] = args;
49412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49413 if (!SWIG_IsOK(res1)) {
49414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_HorzBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49415 }
49416 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49417 {
49418 PyThreadState* __tstate = wxPyBeginAllowThreads();
49419 {
49420 wxSizerFlags &_result_ref = (arg1)->HorzBorder();
49421 result = (wxSizerFlags *) &_result_ref;
49422 }
49423 wxPyEndAllowThreads(__tstate);
49424 if (PyErr_Occurred()) SWIG_fail;
49425 }
49426 {
49427 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49428 }
49429 return resultobj;
49430 fail:
49431 return NULL;
49432 }
49433
49434
49435 SWIGINTERN PyObject *_wrap_SizerFlags_DoubleHorzBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49436 PyObject *resultobj = 0;
49437 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49438 wxSizerFlags *result = 0 ;
49439 void *argp1 = 0 ;
49440 int res1 = 0 ;
49441 PyObject *swig_obj[1] ;
49442
49443 if (!args) SWIG_fail;
49444 swig_obj[0] = args;
49445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49446 if (!SWIG_IsOK(res1)) {
49447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_DoubleHorzBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49448 }
49449 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49450 {
49451 PyThreadState* __tstate = wxPyBeginAllowThreads();
49452 {
49453 wxSizerFlags &_result_ref = (arg1)->DoubleHorzBorder();
49454 result = (wxSizerFlags *) &_result_ref;
49455 }
49456 wxPyEndAllowThreads(__tstate);
49457 if (PyErr_Occurred()) SWIG_fail;
49458 }
49459 {
49460 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49461 }
49462 return resultobj;
49463 fail:
49464 return NULL;
49465 }
49466
49467
49468 SWIGINTERN PyObject *_wrap_SizerFlags_GetDefaultBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49469 PyObject *resultobj = 0;
49470 int result;
49471
49472 if (!SWIG_Python_UnpackTuple(args,"SizerFlags_GetDefaultBorder",0,0,0)) SWIG_fail;
49473 {
49474 PyThreadState* __tstate = wxPyBeginAllowThreads();
49475 result = (int)wxSizerFlags::GetDefaultBorder();
49476 wxPyEndAllowThreads(__tstate);
49477 if (PyErr_Occurred()) SWIG_fail;
49478 }
49479 resultobj = SWIG_From_int(static_cast< int >(result));
49480 return resultobj;
49481 fail:
49482 return NULL;
49483 }
49484
49485
49486 SWIGINTERN PyObject *_wrap_SizerFlags_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49487 PyObject *resultobj = 0;
49488 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49489 int result;
49490 void *argp1 = 0 ;
49491 int res1 = 0 ;
49492 PyObject *swig_obj[1] ;
49493
49494 if (!args) SWIG_fail;
49495 swig_obj[0] = args;
49496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49497 if (!SWIG_IsOK(res1)) {
49498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_GetProportion" "', expected argument " "1"" of type '" "wxSizerFlags const *""'");
49499 }
49500 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49501 {
49502 PyThreadState* __tstate = wxPyBeginAllowThreads();
49503 result = (int)((wxSizerFlags const *)arg1)->GetProportion();
49504 wxPyEndAllowThreads(__tstate);
49505 if (PyErr_Occurred()) SWIG_fail;
49506 }
49507 resultobj = SWIG_From_int(static_cast< int >(result));
49508 return resultobj;
49509 fail:
49510 return NULL;
49511 }
49512
49513
49514 SWIGINTERN PyObject *_wrap_SizerFlags_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49515 PyObject *resultobj = 0;
49516 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49517 int result;
49518 void *argp1 = 0 ;
49519 int res1 = 0 ;
49520 PyObject *swig_obj[1] ;
49521
49522 if (!args) SWIG_fail;
49523 swig_obj[0] = args;
49524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49525 if (!SWIG_IsOK(res1)) {
49526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_GetFlags" "', expected argument " "1"" of type '" "wxSizerFlags const *""'");
49527 }
49528 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49529 {
49530 PyThreadState* __tstate = wxPyBeginAllowThreads();
49531 result = (int)((wxSizerFlags const *)arg1)->GetFlags();
49532 wxPyEndAllowThreads(__tstate);
49533 if (PyErr_Occurred()) SWIG_fail;
49534 }
49535 resultobj = SWIG_From_int(static_cast< int >(result));
49536 return resultobj;
49537 fail:
49538 return NULL;
49539 }
49540
49541
49542 SWIGINTERN PyObject *_wrap_SizerFlags_GetBorderInPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49543 PyObject *resultobj = 0;
49544 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49545 int result;
49546 void *argp1 = 0 ;
49547 int res1 = 0 ;
49548 PyObject *swig_obj[1] ;
49549
49550 if (!args) SWIG_fail;
49551 swig_obj[0] = args;
49552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49553 if (!SWIG_IsOK(res1)) {
49554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_GetBorderInPixels" "', expected argument " "1"" of type '" "wxSizerFlags const *""'");
49555 }
49556 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49557 {
49558 PyThreadState* __tstate = wxPyBeginAllowThreads();
49559 result = (int)((wxSizerFlags const *)arg1)->GetBorderInPixels();
49560 wxPyEndAllowThreads(__tstate);
49561 if (PyErr_Occurred()) SWIG_fail;
49562 }
49563 resultobj = SWIG_From_int(static_cast< int >(result));
49564 return resultobj;
49565 fail:
49566 return NULL;
49567 }
49568
49569
49570 SWIGINTERN PyObject *SizerFlags_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49571 PyObject *obj;
49572 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49573 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerFlags, SWIG_NewClientData(obj));
49574 return SWIG_Py_Void();
49575 }
49576
49577 SWIGINTERN PyObject *SizerFlags_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49578 return SWIG_Python_InitShadowInstance(args);
49579 }
49580
49581 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49582 PyObject *resultobj = 0;
49583 wxSizerItem *result = 0 ;
49584
49585 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
49586 {
49587 PyThreadState* __tstate = wxPyBeginAllowThreads();
49588 result = (wxSizerItem *)new wxSizerItem();
49589 wxPyEndAllowThreads(__tstate);
49590 if (PyErr_Occurred()) SWIG_fail;
49591 }
49592 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
49593 return resultobj;
49594 fail:
49595 return NULL;
49596 }
49597
49598
49599 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49600 PyObject *resultobj = 0;
49601 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49602 void *argp1 = 0 ;
49603 int res1 = 0 ;
49604 PyObject *swig_obj[1] ;
49605
49606 if (!args) SWIG_fail;
49607 swig_obj[0] = args;
49608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
49609 if (!SWIG_IsOK(res1)) {
49610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49611 }
49612 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49613 {
49614 PyThreadState* __tstate = wxPyBeginAllowThreads();
49615 delete arg1;
49616
49617 wxPyEndAllowThreads(__tstate);
49618 if (PyErr_Occurred()) SWIG_fail;
49619 }
49620 resultobj = SWIG_Py_Void();
49621 return resultobj;
49622 fail:
49623 return NULL;
49624 }
49625
49626
49627 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49628 PyObject *resultobj = 0;
49629 wxWindow *arg1 = (wxWindow *) 0 ;
49630 int arg2 ;
49631 int arg3 ;
49632 int arg4 ;
49633 PyObject *arg5 = (PyObject *) NULL ;
49634 wxSizerItem *result = 0 ;
49635 void *argp1 = 0 ;
49636 int res1 = 0 ;
49637 int val2 ;
49638 int ecode2 = 0 ;
49639 int val3 ;
49640 int ecode3 = 0 ;
49641 int val4 ;
49642 int ecode4 = 0 ;
49643 PyObject * obj0 = 0 ;
49644 PyObject * obj1 = 0 ;
49645 PyObject * obj2 = 0 ;
49646 PyObject * obj3 = 0 ;
49647 PyObject * obj4 = 0 ;
49648 char * kwnames[] = {
49649 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49650 };
49651
49652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
49653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49654 if (!SWIG_IsOK(res1)) {
49655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49656 }
49657 arg1 = reinterpret_cast< wxWindow * >(argp1);
49658 ecode2 = SWIG_AsVal_int(obj1, &val2);
49659 if (!SWIG_IsOK(ecode2)) {
49660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
49661 }
49662 arg2 = static_cast< int >(val2);
49663 ecode3 = SWIG_AsVal_int(obj2, &val3);
49664 if (!SWIG_IsOK(ecode3)) {
49665 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
49666 }
49667 arg3 = static_cast< int >(val3);
49668 ecode4 = SWIG_AsVal_int(obj3, &val4);
49669 if (!SWIG_IsOK(ecode4)) {
49670 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49671 }
49672 arg4 = static_cast< int >(val4);
49673 if (obj4) {
49674 arg5 = obj4;
49675 }
49676 {
49677 PyThreadState* __tstate = wxPyBeginAllowThreads();
49678 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
49679 wxPyEndAllowThreads(__tstate);
49680 if (PyErr_Occurred()) SWIG_fail;
49681 }
49682 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
49683 return resultobj;
49684 fail:
49685 return NULL;
49686 }
49687
49688
49689 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49690 PyObject *resultobj = 0;
49691 int arg1 ;
49692 int arg2 ;
49693 int arg3 ;
49694 int arg4 ;
49695 int arg5 ;
49696 PyObject *arg6 = (PyObject *) NULL ;
49697 wxSizerItem *result = 0 ;
49698 int val1 ;
49699 int ecode1 = 0 ;
49700 int val2 ;
49701 int ecode2 = 0 ;
49702 int val3 ;
49703 int ecode3 = 0 ;
49704 int val4 ;
49705 int ecode4 = 0 ;
49706 int val5 ;
49707 int ecode5 = 0 ;
49708 PyObject * obj0 = 0 ;
49709 PyObject * obj1 = 0 ;
49710 PyObject * obj2 = 0 ;
49711 PyObject * obj3 = 0 ;
49712 PyObject * obj4 = 0 ;
49713 PyObject * obj5 = 0 ;
49714 char * kwnames[] = {
49715 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49716 };
49717
49718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49719 ecode1 = SWIG_AsVal_int(obj0, &val1);
49720 if (!SWIG_IsOK(ecode1)) {
49721 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49722 }
49723 arg1 = static_cast< int >(val1);
49724 ecode2 = SWIG_AsVal_int(obj1, &val2);
49725 if (!SWIG_IsOK(ecode2)) {
49726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49727 }
49728 arg2 = static_cast< int >(val2);
49729 ecode3 = SWIG_AsVal_int(obj2, &val3);
49730 if (!SWIG_IsOK(ecode3)) {
49731 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
49732 }
49733 arg3 = static_cast< int >(val3);
49734 ecode4 = SWIG_AsVal_int(obj3, &val4);
49735 if (!SWIG_IsOK(ecode4)) {
49736 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
49737 }
49738 arg4 = static_cast< int >(val4);
49739 ecode5 = SWIG_AsVal_int(obj4, &val5);
49740 if (!SWIG_IsOK(ecode5)) {
49741 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49742 }
49743 arg5 = static_cast< int >(val5);
49744 if (obj5) {
49745 arg6 = obj5;
49746 }
49747 {
49748 PyThreadState* __tstate = wxPyBeginAllowThreads();
49749 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
49750 wxPyEndAllowThreads(__tstate);
49751 if (PyErr_Occurred()) SWIG_fail;
49752 }
49753 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
49754 return resultobj;
49755 fail:
49756 return NULL;
49757 }
49758
49759
49760 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49761 PyObject *resultobj = 0;
49762 wxSizer *arg1 = (wxSizer *) 0 ;
49763 int arg2 ;
49764 int arg3 ;
49765 int arg4 ;
49766 PyObject *arg5 = (PyObject *) NULL ;
49767 wxSizerItem *result = 0 ;
49768 int res1 = 0 ;
49769 int val2 ;
49770 int ecode2 = 0 ;
49771 int val3 ;
49772 int ecode3 = 0 ;
49773 int val4 ;
49774 int ecode4 = 0 ;
49775 PyObject * obj0 = 0 ;
49776 PyObject * obj1 = 0 ;
49777 PyObject * obj2 = 0 ;
49778 PyObject * obj3 = 0 ;
49779 PyObject * obj4 = 0 ;
49780 char * kwnames[] = {
49781 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49782 };
49783
49784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
49785 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49786 if (!SWIG_IsOK(res1)) {
49787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49788 }
49789 ecode2 = SWIG_AsVal_int(obj1, &val2);
49790 if (!SWIG_IsOK(ecode2)) {
49791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
49792 }
49793 arg2 = static_cast< int >(val2);
49794 ecode3 = SWIG_AsVal_int(obj2, &val3);
49795 if (!SWIG_IsOK(ecode3)) {
49796 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
49797 }
49798 arg3 = static_cast< int >(val3);
49799 ecode4 = SWIG_AsVal_int(obj3, &val4);
49800 if (!SWIG_IsOK(ecode4)) {
49801 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49802 }
49803 arg4 = static_cast< int >(val4);
49804 if (obj4) {
49805 arg5 = obj4;
49806 }
49807 {
49808 PyThreadState* __tstate = wxPyBeginAllowThreads();
49809 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
49810 wxPyEndAllowThreads(__tstate);
49811 if (PyErr_Occurred()) SWIG_fail;
49812 }
49813 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
49814 return resultobj;
49815 fail:
49816 return NULL;
49817 }
49818
49819
49820 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49821 PyObject *resultobj = 0;
49822 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49823 void *argp1 = 0 ;
49824 int res1 = 0 ;
49825 PyObject *swig_obj[1] ;
49826
49827 if (!args) SWIG_fail;
49828 swig_obj[0] = args;
49829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49830 if (!SWIG_IsOK(res1)) {
49831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49832 }
49833 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49834 {
49835 PyThreadState* __tstate = wxPyBeginAllowThreads();
49836 (arg1)->DeleteWindows();
49837 wxPyEndAllowThreads(__tstate);
49838 if (PyErr_Occurred()) SWIG_fail;
49839 }
49840 resultobj = SWIG_Py_Void();
49841 return resultobj;
49842 fail:
49843 return NULL;
49844 }
49845
49846
49847 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49848 PyObject *resultobj = 0;
49849 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49850 void *argp1 = 0 ;
49851 int res1 = 0 ;
49852 PyObject *swig_obj[1] ;
49853
49854 if (!args) SWIG_fail;
49855 swig_obj[0] = args;
49856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49857 if (!SWIG_IsOK(res1)) {
49858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49859 }
49860 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49861 {
49862 PyThreadState* __tstate = wxPyBeginAllowThreads();
49863 (arg1)->DetachSizer();
49864 wxPyEndAllowThreads(__tstate);
49865 if (PyErr_Occurred()) SWIG_fail;
49866 }
49867 resultobj = SWIG_Py_Void();
49868 return resultobj;
49869 fail:
49870 return NULL;
49871 }
49872
49873
49874 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49875 PyObject *resultobj = 0;
49876 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49877 wxSize result;
49878 void *argp1 = 0 ;
49879 int res1 = 0 ;
49880 PyObject *swig_obj[1] ;
49881
49882 if (!args) SWIG_fail;
49883 swig_obj[0] = args;
49884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49885 if (!SWIG_IsOK(res1)) {
49886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49887 }
49888 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49889 {
49890 PyThreadState* __tstate = wxPyBeginAllowThreads();
49891 result = (arg1)->GetSize();
49892 wxPyEndAllowThreads(__tstate);
49893 if (PyErr_Occurred()) SWIG_fail;
49894 }
49895 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49896 return resultobj;
49897 fail:
49898 return NULL;
49899 }
49900
49901
49902 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49903 PyObject *resultobj = 0;
49904 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49905 wxSize result;
49906 void *argp1 = 0 ;
49907 int res1 = 0 ;
49908 PyObject *swig_obj[1] ;
49909
49910 if (!args) SWIG_fail;
49911 swig_obj[0] = args;
49912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49913 if (!SWIG_IsOK(res1)) {
49914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49915 }
49916 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49917 {
49918 PyThreadState* __tstate = wxPyBeginAllowThreads();
49919 result = (arg1)->CalcMin();
49920 wxPyEndAllowThreads(__tstate);
49921 if (PyErr_Occurred()) SWIG_fail;
49922 }
49923 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49924 return resultobj;
49925 fail:
49926 return NULL;
49927 }
49928
49929
49930 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49931 PyObject *resultobj = 0;
49932 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49933 wxPoint *arg2 = 0 ;
49934 wxSize *arg3 = 0 ;
49935 void *argp1 = 0 ;
49936 int res1 = 0 ;
49937 wxPoint temp2 ;
49938 wxSize temp3 ;
49939 PyObject * obj0 = 0 ;
49940 PyObject * obj1 = 0 ;
49941 PyObject * obj2 = 0 ;
49942 char * kwnames[] = {
49943 (char *) "self",(char *) "pos",(char *) "size", NULL
49944 };
49945
49946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49948 if (!SWIG_IsOK(res1)) {
49949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49950 }
49951 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49952 {
49953 arg2 = &temp2;
49954 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
49955 }
49956 {
49957 arg3 = &temp3;
49958 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
49959 }
49960 {
49961 PyThreadState* __tstate = wxPyBeginAllowThreads();
49962 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
49963 wxPyEndAllowThreads(__tstate);
49964 if (PyErr_Occurred()) SWIG_fail;
49965 }
49966 resultobj = SWIG_Py_Void();
49967 return resultobj;
49968 fail:
49969 return NULL;
49970 }
49971
49972
49973 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49974 PyObject *resultobj = 0;
49975 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49976 wxSize result;
49977 void *argp1 = 0 ;
49978 int res1 = 0 ;
49979 PyObject *swig_obj[1] ;
49980
49981 if (!args) SWIG_fail;
49982 swig_obj[0] = args;
49983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49984 if (!SWIG_IsOK(res1)) {
49985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49986 }
49987 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49988 {
49989 PyThreadState* __tstate = wxPyBeginAllowThreads();
49990 result = (arg1)->GetMinSize();
49991 wxPyEndAllowThreads(__tstate);
49992 if (PyErr_Occurred()) SWIG_fail;
49993 }
49994 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49995 return resultobj;
49996 fail:
49997 return NULL;
49998 }
49999
50000
50001 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50002 PyObject *resultobj = 0;
50003 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50004 wxSize result;
50005 void *argp1 = 0 ;
50006 int res1 = 0 ;
50007 PyObject *swig_obj[1] ;
50008
50009 if (!args) SWIG_fail;
50010 swig_obj[0] = args;
50011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50012 if (!SWIG_IsOK(res1)) {
50013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
50014 }
50015 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50016 {
50017 PyThreadState* __tstate = wxPyBeginAllowThreads();
50018 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
50019 wxPyEndAllowThreads(__tstate);
50020 if (PyErr_Occurred()) SWIG_fail;
50021 }
50022 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50023 return resultobj;
50024 fail:
50025 return NULL;
50026 }
50027
50028
50029 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50030 PyObject *resultobj = 0;
50031 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50032 int arg2 ;
50033 int arg3 ;
50034 void *argp1 = 0 ;
50035 int res1 = 0 ;
50036 int val2 ;
50037 int ecode2 = 0 ;
50038 int val3 ;
50039 int ecode3 = 0 ;
50040 PyObject * obj0 = 0 ;
50041 PyObject * obj1 = 0 ;
50042 PyObject * obj2 = 0 ;
50043 char * kwnames[] = {
50044 (char *) "self",(char *) "x",(char *) "y", NULL
50045 };
50046
50047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50049 if (!SWIG_IsOK(res1)) {
50050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50051 }
50052 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50053 ecode2 = SWIG_AsVal_int(obj1, &val2);
50054 if (!SWIG_IsOK(ecode2)) {
50055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
50056 }
50057 arg2 = static_cast< int >(val2);
50058 ecode3 = SWIG_AsVal_int(obj2, &val3);
50059 if (!SWIG_IsOK(ecode3)) {
50060 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
50061 }
50062 arg3 = static_cast< int >(val3);
50063 {
50064 PyThreadState* __tstate = wxPyBeginAllowThreads();
50065 (arg1)->SetInitSize(arg2,arg3);
50066 wxPyEndAllowThreads(__tstate);
50067 if (PyErr_Occurred()) SWIG_fail;
50068 }
50069 resultobj = SWIG_Py_Void();
50070 return resultobj;
50071 fail:
50072 return NULL;
50073 }
50074
50075
50076 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50077 PyObject *resultobj = 0;
50078 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50079 int arg2 ;
50080 int arg3 ;
50081 void *argp1 = 0 ;
50082 int res1 = 0 ;
50083 int val2 ;
50084 int ecode2 = 0 ;
50085 int val3 ;
50086 int ecode3 = 0 ;
50087 PyObject * obj0 = 0 ;
50088 PyObject * obj1 = 0 ;
50089 PyObject * obj2 = 0 ;
50090 char * kwnames[] = {
50091 (char *) "self",(char *) "width",(char *) "height", NULL
50092 };
50093
50094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50096 if (!SWIG_IsOK(res1)) {
50097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50098 }
50099 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50100 ecode2 = SWIG_AsVal_int(obj1, &val2);
50101 if (!SWIG_IsOK(ecode2)) {
50102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
50103 }
50104 arg2 = static_cast< int >(val2);
50105 ecode3 = SWIG_AsVal_int(obj2, &val3);
50106 if (!SWIG_IsOK(ecode3)) {
50107 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
50108 }
50109 arg3 = static_cast< int >(val3);
50110 {
50111 PyThreadState* __tstate = wxPyBeginAllowThreads();
50112 (arg1)->SetRatio(arg2,arg3);
50113 wxPyEndAllowThreads(__tstate);
50114 if (PyErr_Occurred()) SWIG_fail;
50115 }
50116 resultobj = SWIG_Py_Void();
50117 return resultobj;
50118 fail:
50119 return NULL;
50120 }
50121
50122
50123 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50124 PyObject *resultobj = 0;
50125 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50126 wxSize *arg2 = 0 ;
50127 void *argp1 = 0 ;
50128 int res1 = 0 ;
50129 wxSize temp2 ;
50130 PyObject * obj0 = 0 ;
50131 PyObject * obj1 = 0 ;
50132 char * kwnames[] = {
50133 (char *) "self",(char *) "size", NULL
50134 };
50135
50136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
50137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50138 if (!SWIG_IsOK(res1)) {
50139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50140 }
50141 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50142 {
50143 arg2 = &temp2;
50144 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50145 }
50146 {
50147 PyThreadState* __tstate = wxPyBeginAllowThreads();
50148 (arg1)->SetRatio((wxSize const &)*arg2);
50149 wxPyEndAllowThreads(__tstate);
50150 if (PyErr_Occurred()) SWIG_fail;
50151 }
50152 resultobj = SWIG_Py_Void();
50153 return resultobj;
50154 fail:
50155 return NULL;
50156 }
50157
50158
50159 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50160 PyObject *resultobj = 0;
50161 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50162 float arg2 ;
50163 void *argp1 = 0 ;
50164 int res1 = 0 ;
50165 float val2 ;
50166 int ecode2 = 0 ;
50167 PyObject * obj0 = 0 ;
50168 PyObject * obj1 = 0 ;
50169 char * kwnames[] = {
50170 (char *) "self",(char *) "ratio", NULL
50171 };
50172
50173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
50174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50175 if (!SWIG_IsOK(res1)) {
50176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50177 }
50178 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50179 ecode2 = SWIG_AsVal_float(obj1, &val2);
50180 if (!SWIG_IsOK(ecode2)) {
50181 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
50182 }
50183 arg2 = static_cast< float >(val2);
50184 {
50185 PyThreadState* __tstate = wxPyBeginAllowThreads();
50186 (arg1)->SetRatio(arg2);
50187 wxPyEndAllowThreads(__tstate);
50188 if (PyErr_Occurred()) SWIG_fail;
50189 }
50190 resultobj = SWIG_Py_Void();
50191 return resultobj;
50192 fail:
50193 return NULL;
50194 }
50195
50196
50197 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50198 PyObject *resultobj = 0;
50199 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50200 float result;
50201 void *argp1 = 0 ;
50202 int res1 = 0 ;
50203 PyObject *swig_obj[1] ;
50204
50205 if (!args) SWIG_fail;
50206 swig_obj[0] = args;
50207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50208 if (!SWIG_IsOK(res1)) {
50209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50210 }
50211 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50212 {
50213 PyThreadState* __tstate = wxPyBeginAllowThreads();
50214 result = (float)(arg1)->GetRatio();
50215 wxPyEndAllowThreads(__tstate);
50216 if (PyErr_Occurred()) SWIG_fail;
50217 }
50218 resultobj = SWIG_From_float(static_cast< float >(result));
50219 return resultobj;
50220 fail:
50221 return NULL;
50222 }
50223
50224
50225 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50226 PyObject *resultobj = 0;
50227 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50228 wxRect result;
50229 void *argp1 = 0 ;
50230 int res1 = 0 ;
50231 PyObject *swig_obj[1] ;
50232
50233 if (!args) SWIG_fail;
50234 swig_obj[0] = args;
50235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50236 if (!SWIG_IsOK(res1)) {
50237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50238 }
50239 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50240 {
50241 PyThreadState* __tstate = wxPyBeginAllowThreads();
50242 result = (arg1)->GetRect();
50243 wxPyEndAllowThreads(__tstate);
50244 if (PyErr_Occurred()) SWIG_fail;
50245 }
50246 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
50247 return resultobj;
50248 fail:
50249 return NULL;
50250 }
50251
50252
50253 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50254 PyObject *resultobj = 0;
50255 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50256 bool result;
50257 void *argp1 = 0 ;
50258 int res1 = 0 ;
50259 PyObject *swig_obj[1] ;
50260
50261 if (!args) SWIG_fail;
50262 swig_obj[0] = args;
50263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50264 if (!SWIG_IsOK(res1)) {
50265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50266 }
50267 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50268 {
50269 PyThreadState* __tstate = wxPyBeginAllowThreads();
50270 result = (bool)(arg1)->IsWindow();
50271 wxPyEndAllowThreads(__tstate);
50272 if (PyErr_Occurred()) SWIG_fail;
50273 }
50274 {
50275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50276 }
50277 return resultobj;
50278 fail:
50279 return NULL;
50280 }
50281
50282
50283 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50284 PyObject *resultobj = 0;
50285 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50286 bool result;
50287 void *argp1 = 0 ;
50288 int res1 = 0 ;
50289 PyObject *swig_obj[1] ;
50290
50291 if (!args) SWIG_fail;
50292 swig_obj[0] = args;
50293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50294 if (!SWIG_IsOK(res1)) {
50295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50296 }
50297 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50298 {
50299 PyThreadState* __tstate = wxPyBeginAllowThreads();
50300 result = (bool)(arg1)->IsSizer();
50301 wxPyEndAllowThreads(__tstate);
50302 if (PyErr_Occurred()) SWIG_fail;
50303 }
50304 {
50305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50306 }
50307 return resultobj;
50308 fail:
50309 return NULL;
50310 }
50311
50312
50313 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50314 PyObject *resultobj = 0;
50315 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50316 bool result;
50317 void *argp1 = 0 ;
50318 int res1 = 0 ;
50319 PyObject *swig_obj[1] ;
50320
50321 if (!args) SWIG_fail;
50322 swig_obj[0] = args;
50323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50324 if (!SWIG_IsOK(res1)) {
50325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50326 }
50327 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50328 {
50329 PyThreadState* __tstate = wxPyBeginAllowThreads();
50330 result = (bool)(arg1)->IsSpacer();
50331 wxPyEndAllowThreads(__tstate);
50332 if (PyErr_Occurred()) SWIG_fail;
50333 }
50334 {
50335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50336 }
50337 return resultobj;
50338 fail:
50339 return NULL;
50340 }
50341
50342
50343 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50344 PyObject *resultobj = 0;
50345 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50346 int arg2 ;
50347 void *argp1 = 0 ;
50348 int res1 = 0 ;
50349 int val2 ;
50350 int ecode2 = 0 ;
50351 PyObject * obj0 = 0 ;
50352 PyObject * obj1 = 0 ;
50353 char * kwnames[] = {
50354 (char *) "self",(char *) "proportion", NULL
50355 };
50356
50357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
50358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50359 if (!SWIG_IsOK(res1)) {
50360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50361 }
50362 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50363 ecode2 = SWIG_AsVal_int(obj1, &val2);
50364 if (!SWIG_IsOK(ecode2)) {
50365 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
50366 }
50367 arg2 = static_cast< int >(val2);
50368 {
50369 PyThreadState* __tstate = wxPyBeginAllowThreads();
50370 (arg1)->SetProportion(arg2);
50371 wxPyEndAllowThreads(__tstate);
50372 if (PyErr_Occurred()) SWIG_fail;
50373 }
50374 resultobj = SWIG_Py_Void();
50375 return resultobj;
50376 fail:
50377 return NULL;
50378 }
50379
50380
50381 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50382 PyObject *resultobj = 0;
50383 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50384 int result;
50385 void *argp1 = 0 ;
50386 int res1 = 0 ;
50387 PyObject *swig_obj[1] ;
50388
50389 if (!args) SWIG_fail;
50390 swig_obj[0] = args;
50391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50392 if (!SWIG_IsOK(res1)) {
50393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50394 }
50395 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50396 {
50397 PyThreadState* __tstate = wxPyBeginAllowThreads();
50398 result = (int)(arg1)->GetProportion();
50399 wxPyEndAllowThreads(__tstate);
50400 if (PyErr_Occurred()) SWIG_fail;
50401 }
50402 resultobj = SWIG_From_int(static_cast< int >(result));
50403 return resultobj;
50404 fail:
50405 return NULL;
50406 }
50407
50408
50409 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50410 PyObject *resultobj = 0;
50411 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50412 int arg2 ;
50413 void *argp1 = 0 ;
50414 int res1 = 0 ;
50415 int val2 ;
50416 int ecode2 = 0 ;
50417 PyObject * obj0 = 0 ;
50418 PyObject * obj1 = 0 ;
50419 char * kwnames[] = {
50420 (char *) "self",(char *) "flag", NULL
50421 };
50422
50423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
50424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50425 if (!SWIG_IsOK(res1)) {
50426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50427 }
50428 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50429 ecode2 = SWIG_AsVal_int(obj1, &val2);
50430 if (!SWIG_IsOK(ecode2)) {
50431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
50432 }
50433 arg2 = static_cast< int >(val2);
50434 {
50435 PyThreadState* __tstate = wxPyBeginAllowThreads();
50436 (arg1)->SetFlag(arg2);
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_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50448 PyObject *resultobj = 0;
50449 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50450 int 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_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50460 }
50461 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50462 {
50463 PyThreadState* __tstate = wxPyBeginAllowThreads();
50464 result = (int)(arg1)->GetFlag();
50465 wxPyEndAllowThreads(__tstate);
50466 if (PyErr_Occurred()) SWIG_fail;
50467 }
50468 resultobj = SWIG_From_int(static_cast< int >(result));
50469 return resultobj;
50470 fail:
50471 return NULL;
50472 }
50473
50474
50475 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50476 PyObject *resultobj = 0;
50477 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50478 int arg2 ;
50479 void *argp1 = 0 ;
50480 int res1 = 0 ;
50481 int val2 ;
50482 int ecode2 = 0 ;
50483 PyObject * obj0 = 0 ;
50484 PyObject * obj1 = 0 ;
50485 char * kwnames[] = {
50486 (char *) "self",(char *) "border", NULL
50487 };
50488
50489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
50490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50491 if (!SWIG_IsOK(res1)) {
50492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50493 }
50494 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50495 ecode2 = SWIG_AsVal_int(obj1, &val2);
50496 if (!SWIG_IsOK(ecode2)) {
50497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
50498 }
50499 arg2 = static_cast< int >(val2);
50500 {
50501 PyThreadState* __tstate = wxPyBeginAllowThreads();
50502 (arg1)->SetBorder(arg2);
50503 wxPyEndAllowThreads(__tstate);
50504 if (PyErr_Occurred()) SWIG_fail;
50505 }
50506 resultobj = SWIG_Py_Void();
50507 return resultobj;
50508 fail:
50509 return NULL;
50510 }
50511
50512
50513 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50514 PyObject *resultobj = 0;
50515 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50516 int result;
50517 void *argp1 = 0 ;
50518 int res1 = 0 ;
50519 PyObject *swig_obj[1] ;
50520
50521 if (!args) SWIG_fail;
50522 swig_obj[0] = args;
50523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50524 if (!SWIG_IsOK(res1)) {
50525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50526 }
50527 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50528 {
50529 PyThreadState* __tstate = wxPyBeginAllowThreads();
50530 result = (int)(arg1)->GetBorder();
50531 wxPyEndAllowThreads(__tstate);
50532 if (PyErr_Occurred()) SWIG_fail;
50533 }
50534 resultobj = SWIG_From_int(static_cast< int >(result));
50535 return resultobj;
50536 fail:
50537 return NULL;
50538 }
50539
50540
50541 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50542 PyObject *resultobj = 0;
50543 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50544 wxWindow *result = 0 ;
50545 void *argp1 = 0 ;
50546 int res1 = 0 ;
50547 PyObject *swig_obj[1] ;
50548
50549 if (!args) SWIG_fail;
50550 swig_obj[0] = args;
50551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50552 if (!SWIG_IsOK(res1)) {
50553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50554 }
50555 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50556 {
50557 PyThreadState* __tstate = wxPyBeginAllowThreads();
50558 result = (wxWindow *)(arg1)->GetWindow();
50559 wxPyEndAllowThreads(__tstate);
50560 if (PyErr_Occurred()) SWIG_fail;
50561 }
50562 {
50563 resultobj = wxPyMake_wxObject(result, 0);
50564 }
50565 return resultobj;
50566 fail:
50567 return NULL;
50568 }
50569
50570
50571 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50572 PyObject *resultobj = 0;
50573 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50574 wxSizer *result = 0 ;
50575 void *argp1 = 0 ;
50576 int res1 = 0 ;
50577 PyObject *swig_obj[1] ;
50578
50579 if (!args) SWIG_fail;
50580 swig_obj[0] = args;
50581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50582 if (!SWIG_IsOK(res1)) {
50583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50584 }
50585 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50586 {
50587 PyThreadState* __tstate = wxPyBeginAllowThreads();
50588 result = (wxSizer *)(arg1)->GetSizer();
50589 wxPyEndAllowThreads(__tstate);
50590 if (PyErr_Occurred()) SWIG_fail;
50591 }
50592 {
50593 resultobj = wxPyMake_wxObject(result, (bool)0);
50594 }
50595 return resultobj;
50596 fail:
50597 return NULL;
50598 }
50599
50600
50601 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50602 PyObject *resultobj = 0;
50603 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50604 wxSize result;
50605 void *argp1 = 0 ;
50606 int res1 = 0 ;
50607 PyObject *swig_obj[1] ;
50608
50609 if (!args) SWIG_fail;
50610 swig_obj[0] = args;
50611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50612 if (!SWIG_IsOK(res1)) {
50613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50614 }
50615 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50616 {
50617 PyThreadState* __tstate = wxPyBeginAllowThreads();
50618 result = (arg1)->GetSpacer();
50619 wxPyEndAllowThreads(__tstate);
50620 if (PyErr_Occurred()) SWIG_fail;
50621 }
50622 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50623 return resultobj;
50624 fail:
50625 return NULL;
50626 }
50627
50628
50629 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50630 PyObject *resultobj = 0;
50631 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50632 wxWindow *arg2 = (wxWindow *) 0 ;
50633 void *argp1 = 0 ;
50634 int res1 = 0 ;
50635 void *argp2 = 0 ;
50636 int res2 = 0 ;
50637 PyObject * obj0 = 0 ;
50638 PyObject * obj1 = 0 ;
50639 char * kwnames[] = {
50640 (char *) "self",(char *) "window", NULL
50641 };
50642
50643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
50644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50645 if (!SWIG_IsOK(res1)) {
50646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50647 }
50648 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50649 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50650 if (!SWIG_IsOK(res2)) {
50651 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
50652 }
50653 arg2 = reinterpret_cast< wxWindow * >(argp2);
50654 {
50655 PyThreadState* __tstate = wxPyBeginAllowThreads();
50656 (arg1)->SetWindow(arg2);
50657 wxPyEndAllowThreads(__tstate);
50658 if (PyErr_Occurred()) SWIG_fail;
50659 }
50660 resultobj = SWIG_Py_Void();
50661 return resultobj;
50662 fail:
50663 return NULL;
50664 }
50665
50666
50667 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50668 PyObject *resultobj = 0;
50669 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50670 wxSizer *arg2 = (wxSizer *) 0 ;
50671 void *argp1 = 0 ;
50672 int res1 = 0 ;
50673 int res2 = 0 ;
50674 PyObject * obj0 = 0 ;
50675 PyObject * obj1 = 0 ;
50676 char * kwnames[] = {
50677 (char *) "self",(char *) "sizer", NULL
50678 };
50679
50680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50682 if (!SWIG_IsOK(res1)) {
50683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50684 }
50685 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50686 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
50687 if (!SWIG_IsOK(res2)) {
50688 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
50689 }
50690 {
50691 PyThreadState* __tstate = wxPyBeginAllowThreads();
50692 (arg1)->SetSizer(arg2);
50693 wxPyEndAllowThreads(__tstate);
50694 if (PyErr_Occurred()) SWIG_fail;
50695 }
50696 resultobj = SWIG_Py_Void();
50697 return resultobj;
50698 fail:
50699 return NULL;
50700 }
50701
50702
50703 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50704 PyObject *resultobj = 0;
50705 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50706 wxSize *arg2 = 0 ;
50707 void *argp1 = 0 ;
50708 int res1 = 0 ;
50709 wxSize temp2 ;
50710 PyObject * obj0 = 0 ;
50711 PyObject * obj1 = 0 ;
50712 char * kwnames[] = {
50713 (char *) "self",(char *) "size", NULL
50714 };
50715
50716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
50717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50718 if (!SWIG_IsOK(res1)) {
50719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50720 }
50721 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50722 {
50723 arg2 = &temp2;
50724 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50725 }
50726 {
50727 PyThreadState* __tstate = wxPyBeginAllowThreads();
50728 (arg1)->SetSpacer((wxSize const &)*arg2);
50729 wxPyEndAllowThreads(__tstate);
50730 if (PyErr_Occurred()) SWIG_fail;
50731 }
50732 resultobj = SWIG_Py_Void();
50733 return resultobj;
50734 fail:
50735 return NULL;
50736 }
50737
50738
50739 SWIGINTERN PyObject *_wrap_SizerItem_AssignWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50740 PyObject *resultobj = 0;
50741 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50742 wxWindow *arg2 = (wxWindow *) 0 ;
50743 void *argp1 = 0 ;
50744 int res1 = 0 ;
50745 void *argp2 = 0 ;
50746 int res2 = 0 ;
50747 PyObject * obj0 = 0 ;
50748 PyObject * obj1 = 0 ;
50749 char * kwnames[] = {
50750 (char *) "self",(char *) "window", NULL
50751 };
50752
50753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_AssignWindow",kwnames,&obj0,&obj1)) SWIG_fail;
50754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50755 if (!SWIG_IsOK(res1)) {
50756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_AssignWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50757 }
50758 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50759 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50760 if (!SWIG_IsOK(res2)) {
50761 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_AssignWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
50762 }
50763 arg2 = reinterpret_cast< wxWindow * >(argp2);
50764 {
50765 PyThreadState* __tstate = wxPyBeginAllowThreads();
50766 (arg1)->AssignWindow(arg2);
50767 wxPyEndAllowThreads(__tstate);
50768 if (PyErr_Occurred()) SWIG_fail;
50769 }
50770 resultobj = SWIG_Py_Void();
50771 return resultobj;
50772 fail:
50773 return NULL;
50774 }
50775
50776
50777 SWIGINTERN PyObject *_wrap_SizerItem_AssignSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50778 PyObject *resultobj = 0;
50779 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50780 wxSizer *arg2 = (wxSizer *) 0 ;
50781 void *argp1 = 0 ;
50782 int res1 = 0 ;
50783 void *argp2 = 0 ;
50784 int res2 = 0 ;
50785 PyObject * obj0 = 0 ;
50786 PyObject * obj1 = 0 ;
50787 char * kwnames[] = {
50788 (char *) "self",(char *) "sizer", NULL
50789 };
50790
50791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_AssignSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50793 if (!SWIG_IsOK(res1)) {
50794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_AssignSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50795 }
50796 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50797 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50798 if (!SWIG_IsOK(res2)) {
50799 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_AssignSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
50800 }
50801 arg2 = reinterpret_cast< wxSizer * >(argp2);
50802 {
50803 PyThreadState* __tstate = wxPyBeginAllowThreads();
50804 (arg1)->AssignSizer(arg2);
50805 wxPyEndAllowThreads(__tstate);
50806 if (PyErr_Occurred()) SWIG_fail;
50807 }
50808 resultobj = SWIG_Py_Void();
50809 return resultobj;
50810 fail:
50811 return NULL;
50812 }
50813
50814
50815 SWIGINTERN PyObject *_wrap_SizerItem_AssignSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50816 PyObject *resultobj = 0;
50817 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50818 wxSize *arg2 = 0 ;
50819 void *argp1 = 0 ;
50820 int res1 = 0 ;
50821 wxSize temp2 ;
50822 PyObject * obj0 = 0 ;
50823 PyObject * obj1 = 0 ;
50824 char * kwnames[] = {
50825 (char *) "self",(char *) "size", NULL
50826 };
50827
50828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_AssignSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
50829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50830 if (!SWIG_IsOK(res1)) {
50831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_AssignSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50832 }
50833 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50834 {
50835 arg2 = &temp2;
50836 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50837 }
50838 {
50839 PyThreadState* __tstate = wxPyBeginAllowThreads();
50840 (arg1)->AssignSpacer((wxSize const &)*arg2);
50841 wxPyEndAllowThreads(__tstate);
50842 if (PyErr_Occurred()) SWIG_fail;
50843 }
50844 resultobj = SWIG_Py_Void();
50845 return resultobj;
50846 fail:
50847 return NULL;
50848 }
50849
50850
50851 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50852 PyObject *resultobj = 0;
50853 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50854 bool arg2 ;
50855 void *argp1 = 0 ;
50856 int res1 = 0 ;
50857 bool val2 ;
50858 int ecode2 = 0 ;
50859 PyObject * obj0 = 0 ;
50860 PyObject * obj1 = 0 ;
50861 char * kwnames[] = {
50862 (char *) "self",(char *) "show", NULL
50863 };
50864
50865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
50866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50867 if (!SWIG_IsOK(res1)) {
50868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50869 }
50870 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50871 ecode2 = SWIG_AsVal_bool(obj1, &val2);
50872 if (!SWIG_IsOK(ecode2)) {
50873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
50874 }
50875 arg2 = static_cast< bool >(val2);
50876 {
50877 PyThreadState* __tstate = wxPyBeginAllowThreads();
50878 (arg1)->Show(arg2);
50879 wxPyEndAllowThreads(__tstate);
50880 if (PyErr_Occurred()) SWIG_fail;
50881 }
50882 resultobj = SWIG_Py_Void();
50883 return resultobj;
50884 fail:
50885 return NULL;
50886 }
50887
50888
50889 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50890 PyObject *resultobj = 0;
50891 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50892 bool result;
50893 void *argp1 = 0 ;
50894 int res1 = 0 ;
50895 PyObject *swig_obj[1] ;
50896
50897 if (!args) SWIG_fail;
50898 swig_obj[0] = args;
50899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50900 if (!SWIG_IsOK(res1)) {
50901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50902 }
50903 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50904 {
50905 PyThreadState* __tstate = wxPyBeginAllowThreads();
50906 result = (bool)(arg1)->IsShown();
50907 wxPyEndAllowThreads(__tstate);
50908 if (PyErr_Occurred()) SWIG_fail;
50909 }
50910 {
50911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50912 }
50913 return resultobj;
50914 fail:
50915 return NULL;
50916 }
50917
50918
50919 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50920 PyObject *resultobj = 0;
50921 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50922 wxPoint result;
50923 void *argp1 = 0 ;
50924 int res1 = 0 ;
50925 PyObject *swig_obj[1] ;
50926
50927 if (!args) SWIG_fail;
50928 swig_obj[0] = args;
50929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50930 if (!SWIG_IsOK(res1)) {
50931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50932 }
50933 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50934 {
50935 PyThreadState* __tstate = wxPyBeginAllowThreads();
50936 result = (arg1)->GetPosition();
50937 wxPyEndAllowThreads(__tstate);
50938 if (PyErr_Occurred()) SWIG_fail;
50939 }
50940 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
50941 return resultobj;
50942 fail:
50943 return NULL;
50944 }
50945
50946
50947 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50948 PyObject *resultobj = 0;
50949 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50950 PyObject *result = 0 ;
50951 void *argp1 = 0 ;
50952 int res1 = 0 ;
50953 PyObject *swig_obj[1] ;
50954
50955 if (!args) SWIG_fail;
50956 swig_obj[0] = args;
50957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50958 if (!SWIG_IsOK(res1)) {
50959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50960 }
50961 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50962 {
50963 PyThreadState* __tstate = wxPyBeginAllowThreads();
50964 result = (PyObject *)wxSizerItem_GetUserData(arg1);
50965 wxPyEndAllowThreads(__tstate);
50966 if (PyErr_Occurred()) SWIG_fail;
50967 }
50968 resultobj = result;
50969 return resultobj;
50970 fail:
50971 return NULL;
50972 }
50973
50974
50975 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50976 PyObject *resultobj = 0;
50977 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50978 PyObject *arg2 = (PyObject *) 0 ;
50979 void *argp1 = 0 ;
50980 int res1 = 0 ;
50981 PyObject * obj0 = 0 ;
50982 PyObject * obj1 = 0 ;
50983 char * kwnames[] = {
50984 (char *) "self",(char *) "userData", NULL
50985 };
50986
50987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
50988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50989 if (!SWIG_IsOK(res1)) {
50990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50991 }
50992 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50993 arg2 = obj1;
50994 {
50995 PyThreadState* __tstate = wxPyBeginAllowThreads();
50996 wxSizerItem_SetUserData(arg1,arg2);
50997 wxPyEndAllowThreads(__tstate);
50998 if (PyErr_Occurred()) SWIG_fail;
50999 }
51000 resultobj = SWIG_Py_Void();
51001 return resultobj;
51002 fail:
51003 return NULL;
51004 }
51005
51006
51007 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51008 PyObject *obj;
51009 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51010 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
51011 return SWIG_Py_Void();
51012 }
51013
51014 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51015 return SWIG_Python_InitShadowInstance(args);
51016 }
51017
51018 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51019 PyObject *resultobj = 0;
51020 wxSizer *arg1 = (wxSizer *) 0 ;
51021 void *argp1 = 0 ;
51022 int res1 = 0 ;
51023 PyObject *swig_obj[1] ;
51024
51025 if (!args) SWIG_fail;
51026 swig_obj[0] = args;
51027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
51028 if (!SWIG_IsOK(res1)) {
51029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
51030 }
51031 arg1 = reinterpret_cast< wxSizer * >(argp1);
51032 {
51033 PyThreadState* __tstate = wxPyBeginAllowThreads();
51034 delete arg1;
51035
51036 wxPyEndAllowThreads(__tstate);
51037 if (PyErr_Occurred()) SWIG_fail;
51038 }
51039 resultobj = SWIG_Py_Void();
51040 return resultobj;
51041 fail:
51042 return NULL;
51043 }
51044
51045
51046 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51047 PyObject *resultobj = 0;
51048 wxSizer *arg1 = (wxSizer *) 0 ;
51049 PyObject *arg2 = (PyObject *) 0 ;
51050 void *argp1 = 0 ;
51051 int res1 = 0 ;
51052 PyObject * obj0 = 0 ;
51053 PyObject * obj1 = 0 ;
51054 char * kwnames[] = {
51055 (char *) "self",(char *) "_self", NULL
51056 };
51057
51058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
51059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51060 if (!SWIG_IsOK(res1)) {
51061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
51062 }
51063 arg1 = reinterpret_cast< wxSizer * >(argp1);
51064 arg2 = obj1;
51065 {
51066 PyThreadState* __tstate = wxPyBeginAllowThreads();
51067 wxSizer__setOORInfo(arg1,arg2);
51068 wxPyEndAllowThreads(__tstate);
51069 if (PyErr_Occurred()) SWIG_fail;
51070 }
51071 resultobj = SWIG_Py_Void();
51072 return resultobj;
51073 fail:
51074 return NULL;
51075 }
51076
51077
51078 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51079 PyObject *resultobj = 0;
51080 wxSizer *arg1 = (wxSizer *) 0 ;
51081 PyObject *arg2 = (PyObject *) 0 ;
51082 int arg3 = (int) 0 ;
51083 int arg4 = (int) 0 ;
51084 int arg5 = (int) 0 ;
51085 PyObject *arg6 = (PyObject *) NULL ;
51086 wxSizerItem *result = 0 ;
51087 void *argp1 = 0 ;
51088 int res1 = 0 ;
51089 int val3 ;
51090 int ecode3 = 0 ;
51091 int val4 ;
51092 int ecode4 = 0 ;
51093 int val5 ;
51094 int ecode5 = 0 ;
51095 PyObject * obj0 = 0 ;
51096 PyObject * obj1 = 0 ;
51097 PyObject * obj2 = 0 ;
51098 PyObject * obj3 = 0 ;
51099 PyObject * obj4 = 0 ;
51100 PyObject * obj5 = 0 ;
51101 char * kwnames[] = {
51102 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
51103 };
51104
51105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51107 if (!SWIG_IsOK(res1)) {
51108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
51109 }
51110 arg1 = reinterpret_cast< wxSizer * >(argp1);
51111 arg2 = obj1;
51112 if (obj2) {
51113 ecode3 = SWIG_AsVal_int(obj2, &val3);
51114 if (!SWIG_IsOK(ecode3)) {
51115 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
51116 }
51117 arg3 = static_cast< int >(val3);
51118 }
51119 if (obj3) {
51120 ecode4 = SWIG_AsVal_int(obj3, &val4);
51121 if (!SWIG_IsOK(ecode4)) {
51122 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
51123 }
51124 arg4 = static_cast< int >(val4);
51125 }
51126 if (obj4) {
51127 ecode5 = SWIG_AsVal_int(obj4, &val5);
51128 if (!SWIG_IsOK(ecode5)) {
51129 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
51130 }
51131 arg5 = static_cast< int >(val5);
51132 }
51133 if (obj5) {
51134 arg6 = obj5;
51135 }
51136 {
51137 PyThreadState* __tstate = wxPyBeginAllowThreads();
51138 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
51139 wxPyEndAllowThreads(__tstate);
51140 if (PyErr_Occurred()) SWIG_fail;
51141 }
51142 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51143 return resultobj;
51144 fail:
51145 return NULL;
51146 }
51147
51148
51149 SWIGINTERN PyObject *_wrap_Sizer_AddF(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51150 PyObject *resultobj = 0;
51151 wxSizer *arg1 = (wxSizer *) 0 ;
51152 PyObject *arg2 = (PyObject *) 0 ;
51153 wxSizerFlags *arg3 = 0 ;
51154 wxSizerItem *result = 0 ;
51155 void *argp1 = 0 ;
51156 int res1 = 0 ;
51157 void *argp3 = 0 ;
51158 int res3 = 0 ;
51159 PyObject * obj0 = 0 ;
51160 PyObject * obj1 = 0 ;
51161 PyObject * obj2 = 0 ;
51162 char * kwnames[] = {
51163 (char *) "self",(char *) "item",(char *) "flags", NULL
51164 };
51165
51166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_AddF",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51168 if (!SWIG_IsOK(res1)) {
51169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddF" "', expected argument " "1"" of type '" "wxSizer *""'");
51170 }
51171 arg1 = reinterpret_cast< wxSizer * >(argp1);
51172 arg2 = obj1;
51173 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxSizerFlags, 0 );
51174 if (!SWIG_IsOK(res3)) {
51175 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_AddF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51176 }
51177 if (!argp3) {
51178 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sizer_AddF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51179 }
51180 arg3 = reinterpret_cast< wxSizerFlags * >(argp3);
51181 {
51182 PyThreadState* __tstate = wxPyBeginAllowThreads();
51183 result = (wxSizerItem *)wxSizer_AddF(arg1,arg2,*arg3);
51184 wxPyEndAllowThreads(__tstate);
51185 if (PyErr_Occurred()) SWIG_fail;
51186 }
51187 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51188 return resultobj;
51189 fail:
51190 return NULL;
51191 }
51192
51193
51194 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51195 PyObject *resultobj = 0;
51196 wxSizer *arg1 = (wxSizer *) 0 ;
51197 int arg2 ;
51198 PyObject *arg3 = (PyObject *) 0 ;
51199 int arg4 = (int) 0 ;
51200 int arg5 = (int) 0 ;
51201 int arg6 = (int) 0 ;
51202 PyObject *arg7 = (PyObject *) NULL ;
51203 wxSizerItem *result = 0 ;
51204 void *argp1 = 0 ;
51205 int res1 = 0 ;
51206 int val2 ;
51207 int ecode2 = 0 ;
51208 int val4 ;
51209 int ecode4 = 0 ;
51210 int val5 ;
51211 int ecode5 = 0 ;
51212 int val6 ;
51213 int ecode6 = 0 ;
51214 PyObject * obj0 = 0 ;
51215 PyObject * obj1 = 0 ;
51216 PyObject * obj2 = 0 ;
51217 PyObject * obj3 = 0 ;
51218 PyObject * obj4 = 0 ;
51219 PyObject * obj5 = 0 ;
51220 PyObject * obj6 = 0 ;
51221 char * kwnames[] = {
51222 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
51223 };
51224
51225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51227 if (!SWIG_IsOK(res1)) {
51228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
51229 }
51230 arg1 = reinterpret_cast< wxSizer * >(argp1);
51231 ecode2 = SWIG_AsVal_int(obj1, &val2);
51232 if (!SWIG_IsOK(ecode2)) {
51233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
51234 }
51235 arg2 = static_cast< int >(val2);
51236 arg3 = obj2;
51237 if (obj3) {
51238 ecode4 = SWIG_AsVal_int(obj3, &val4);
51239 if (!SWIG_IsOK(ecode4)) {
51240 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
51241 }
51242 arg4 = static_cast< int >(val4);
51243 }
51244 if (obj4) {
51245 ecode5 = SWIG_AsVal_int(obj4, &val5);
51246 if (!SWIG_IsOK(ecode5)) {
51247 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
51248 }
51249 arg5 = static_cast< int >(val5);
51250 }
51251 if (obj5) {
51252 ecode6 = SWIG_AsVal_int(obj5, &val6);
51253 if (!SWIG_IsOK(ecode6)) {
51254 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
51255 }
51256 arg6 = static_cast< int >(val6);
51257 }
51258 if (obj6) {
51259 arg7 = obj6;
51260 }
51261 {
51262 PyThreadState* __tstate = wxPyBeginAllowThreads();
51263 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
51264 wxPyEndAllowThreads(__tstate);
51265 if (PyErr_Occurred()) SWIG_fail;
51266 }
51267 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51268 return resultobj;
51269 fail:
51270 return NULL;
51271 }
51272
51273
51274 SWIGINTERN PyObject *_wrap_Sizer_InsertF(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51275 PyObject *resultobj = 0;
51276 wxSizer *arg1 = (wxSizer *) 0 ;
51277 int arg2 ;
51278 PyObject *arg3 = (PyObject *) 0 ;
51279 wxSizerFlags *arg4 = 0 ;
51280 wxSizerItem *result = 0 ;
51281 void *argp1 = 0 ;
51282 int res1 = 0 ;
51283 int val2 ;
51284 int ecode2 = 0 ;
51285 void *argp4 = 0 ;
51286 int res4 = 0 ;
51287 PyObject * obj0 = 0 ;
51288 PyObject * obj1 = 0 ;
51289 PyObject * obj2 = 0 ;
51290 PyObject * obj3 = 0 ;
51291 char * kwnames[] = {
51292 (char *) "self",(char *) "before",(char *) "item",(char *) "flags", NULL
51293 };
51294
51295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Sizer_InsertF",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51297 if (!SWIG_IsOK(res1)) {
51298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertF" "', expected argument " "1"" of type '" "wxSizer *""'");
51299 }
51300 arg1 = reinterpret_cast< wxSizer * >(argp1);
51301 ecode2 = SWIG_AsVal_int(obj1, &val2);
51302 if (!SWIG_IsOK(ecode2)) {
51303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertF" "', expected argument " "2"" of type '" "int""'");
51304 }
51305 arg2 = static_cast< int >(val2);
51306 arg3 = obj2;
51307 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxSizerFlags, 0 );
51308 if (!SWIG_IsOK(res4)) {
51309 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Sizer_InsertF" "', expected argument " "4"" of type '" "wxSizerFlags &""'");
51310 }
51311 if (!argp4) {
51312 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sizer_InsertF" "', expected argument " "4"" of type '" "wxSizerFlags &""'");
51313 }
51314 arg4 = reinterpret_cast< wxSizerFlags * >(argp4);
51315 {
51316 PyThreadState* __tstate = wxPyBeginAllowThreads();
51317 result = (wxSizerItem *)wxSizer_InsertF(arg1,arg2,arg3,*arg4);
51318 wxPyEndAllowThreads(__tstate);
51319 if (PyErr_Occurred()) SWIG_fail;
51320 }
51321 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51322 return resultobj;
51323 fail:
51324 return NULL;
51325 }
51326
51327
51328 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51329 PyObject *resultobj = 0;
51330 wxSizer *arg1 = (wxSizer *) 0 ;
51331 PyObject *arg2 = (PyObject *) 0 ;
51332 int arg3 = (int) 0 ;
51333 int arg4 = (int) 0 ;
51334 int arg5 = (int) 0 ;
51335 PyObject *arg6 = (PyObject *) NULL ;
51336 wxSizerItem *result = 0 ;
51337 void *argp1 = 0 ;
51338 int res1 = 0 ;
51339 int val3 ;
51340 int ecode3 = 0 ;
51341 int val4 ;
51342 int ecode4 = 0 ;
51343 int val5 ;
51344 int ecode5 = 0 ;
51345 PyObject * obj0 = 0 ;
51346 PyObject * obj1 = 0 ;
51347 PyObject * obj2 = 0 ;
51348 PyObject * obj3 = 0 ;
51349 PyObject * obj4 = 0 ;
51350 PyObject * obj5 = 0 ;
51351 char * kwnames[] = {
51352 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
51353 };
51354
51355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51357 if (!SWIG_IsOK(res1)) {
51358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
51359 }
51360 arg1 = reinterpret_cast< wxSizer * >(argp1);
51361 arg2 = obj1;
51362 if (obj2) {
51363 ecode3 = SWIG_AsVal_int(obj2, &val3);
51364 if (!SWIG_IsOK(ecode3)) {
51365 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
51366 }
51367 arg3 = static_cast< int >(val3);
51368 }
51369 if (obj3) {
51370 ecode4 = SWIG_AsVal_int(obj3, &val4);
51371 if (!SWIG_IsOK(ecode4)) {
51372 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
51373 }
51374 arg4 = static_cast< int >(val4);
51375 }
51376 if (obj4) {
51377 ecode5 = SWIG_AsVal_int(obj4, &val5);
51378 if (!SWIG_IsOK(ecode5)) {
51379 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
51380 }
51381 arg5 = static_cast< int >(val5);
51382 }
51383 if (obj5) {
51384 arg6 = obj5;
51385 }
51386 {
51387 PyThreadState* __tstate = wxPyBeginAllowThreads();
51388 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
51389 wxPyEndAllowThreads(__tstate);
51390 if (PyErr_Occurred()) SWIG_fail;
51391 }
51392 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51393 return resultobj;
51394 fail:
51395 return NULL;
51396 }
51397
51398
51399 SWIGINTERN PyObject *_wrap_Sizer_PrependF(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51400 PyObject *resultobj = 0;
51401 wxSizer *arg1 = (wxSizer *) 0 ;
51402 PyObject *arg2 = (PyObject *) 0 ;
51403 wxSizerFlags *arg3 = 0 ;
51404 wxSizerItem *result = 0 ;
51405 void *argp1 = 0 ;
51406 int res1 = 0 ;
51407 void *argp3 = 0 ;
51408 int res3 = 0 ;
51409 PyObject * obj0 = 0 ;
51410 PyObject * obj1 = 0 ;
51411 PyObject * obj2 = 0 ;
51412 char * kwnames[] = {
51413 (char *) "self",(char *) "item",(char *) "flags", NULL
51414 };
51415
51416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_PrependF",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51418 if (!SWIG_IsOK(res1)) {
51419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependF" "', expected argument " "1"" of type '" "wxSizer *""'");
51420 }
51421 arg1 = reinterpret_cast< wxSizer * >(argp1);
51422 arg2 = obj1;
51423 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxSizerFlags, 0 );
51424 if (!SWIG_IsOK(res3)) {
51425 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_PrependF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51426 }
51427 if (!argp3) {
51428 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sizer_PrependF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51429 }
51430 arg3 = reinterpret_cast< wxSizerFlags * >(argp3);
51431 {
51432 PyThreadState* __tstate = wxPyBeginAllowThreads();
51433 result = (wxSizerItem *)wxSizer_PrependF(arg1,arg2,*arg3);
51434 wxPyEndAllowThreads(__tstate);
51435 if (PyErr_Occurred()) SWIG_fail;
51436 }
51437 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51438 return resultobj;
51439 fail:
51440 return NULL;
51441 }
51442
51443
51444 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51445 PyObject *resultobj = 0;
51446 wxSizer *arg1 = (wxSizer *) 0 ;
51447 PyObject *arg2 = (PyObject *) 0 ;
51448 bool result;
51449 void *argp1 = 0 ;
51450 int res1 = 0 ;
51451 PyObject * obj0 = 0 ;
51452 PyObject * obj1 = 0 ;
51453 char * kwnames[] = {
51454 (char *) "self",(char *) "item", NULL
51455 };
51456
51457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
51458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51459 if (!SWIG_IsOK(res1)) {
51460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
51461 }
51462 arg1 = reinterpret_cast< wxSizer * >(argp1);
51463 arg2 = obj1;
51464 {
51465 PyThreadState* __tstate = wxPyBeginAllowThreads();
51466 result = (bool)wxSizer_Remove(arg1,arg2);
51467 wxPyEndAllowThreads(__tstate);
51468 if (PyErr_Occurred()) SWIG_fail;
51469 }
51470 {
51471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51472 }
51473 return resultobj;
51474 fail:
51475 return NULL;
51476 }
51477
51478
51479 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51480 PyObject *resultobj = 0;
51481 wxSizer *arg1 = (wxSizer *) 0 ;
51482 PyObject *arg2 = (PyObject *) 0 ;
51483 bool result;
51484 void *argp1 = 0 ;
51485 int res1 = 0 ;
51486 PyObject * obj0 = 0 ;
51487 PyObject * obj1 = 0 ;
51488 char * kwnames[] = {
51489 (char *) "self",(char *) "item", NULL
51490 };
51491
51492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
51493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51494 if (!SWIG_IsOK(res1)) {
51495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
51496 }
51497 arg1 = reinterpret_cast< wxSizer * >(argp1);
51498 arg2 = obj1;
51499 {
51500 PyThreadState* __tstate = wxPyBeginAllowThreads();
51501 result = (bool)wxSizer_Detach(arg1,arg2);
51502 wxPyEndAllowThreads(__tstate);
51503 if (PyErr_Occurred()) SWIG_fail;
51504 }
51505 {
51506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51507 }
51508 return resultobj;
51509 fail:
51510 return NULL;
51511 }
51512
51513
51514 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51515 PyObject *resultobj = 0;
51516 wxSizer *arg1 = (wxSizer *) 0 ;
51517 PyObject *arg2 = (PyObject *) 0 ;
51518 bool arg3 = (bool) false ;
51519 wxSizerItem *result = 0 ;
51520 void *argp1 = 0 ;
51521 int res1 = 0 ;
51522 bool val3 ;
51523 int ecode3 = 0 ;
51524 PyObject * obj0 = 0 ;
51525 PyObject * obj1 = 0 ;
51526 PyObject * obj2 = 0 ;
51527 char * kwnames[] = {
51528 (char *) "self",(char *) "item",(char *) "recursive", NULL
51529 };
51530
51531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Sizer_GetItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51533 if (!SWIG_IsOK(res1)) {
51534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
51535 }
51536 arg1 = reinterpret_cast< wxSizer * >(argp1);
51537 arg2 = obj1;
51538 if (obj2) {
51539 ecode3 = SWIG_AsVal_bool(obj2, &val3);
51540 if (!SWIG_IsOK(ecode3)) {
51541 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_GetItem" "', expected argument " "3"" of type '" "bool""'");
51542 }
51543 arg3 = static_cast< bool >(val3);
51544 }
51545 {
51546 PyThreadState* __tstate = wxPyBeginAllowThreads();
51547 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2,arg3);
51548 wxPyEndAllowThreads(__tstate);
51549 if (PyErr_Occurred()) SWIG_fail;
51550 }
51551 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51552 return resultobj;
51553 fail:
51554 return NULL;
51555 }
51556
51557
51558 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51559 PyObject *resultobj = 0;
51560 wxSizer *arg1 = (wxSizer *) 0 ;
51561 PyObject *arg2 = (PyObject *) 0 ;
51562 wxSize *arg3 = 0 ;
51563 void *argp1 = 0 ;
51564 int res1 = 0 ;
51565 wxSize temp3 ;
51566 PyObject * obj0 = 0 ;
51567 PyObject * obj1 = 0 ;
51568 PyObject * obj2 = 0 ;
51569 char * kwnames[] = {
51570 (char *) "self",(char *) "item",(char *) "size", NULL
51571 };
51572
51573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51575 if (!SWIG_IsOK(res1)) {
51576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
51577 }
51578 arg1 = reinterpret_cast< wxSizer * >(argp1);
51579 arg2 = obj1;
51580 {
51581 arg3 = &temp3;
51582 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
51583 }
51584 {
51585 PyThreadState* __tstate = wxPyBeginAllowThreads();
51586 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
51587 wxPyEndAllowThreads(__tstate);
51588 if (PyErr_Occurred()) SWIG_fail;
51589 }
51590 resultobj = SWIG_Py_Void();
51591 return resultobj;
51592 fail:
51593 return NULL;
51594 }
51595
51596
51597 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51598 PyObject *resultobj = 0;
51599 wxSizer *arg1 = (wxSizer *) 0 ;
51600 wxWindow *arg2 = (wxWindow *) 0 ;
51601 wxWindow *arg3 = (wxWindow *) 0 ;
51602 bool arg4 = (bool) false ;
51603 bool result;
51604 void *argp1 = 0 ;
51605 int res1 = 0 ;
51606 void *argp2 = 0 ;
51607 int res2 = 0 ;
51608 void *argp3 = 0 ;
51609 int res3 = 0 ;
51610 bool val4 ;
51611 int ecode4 = 0 ;
51612 PyObject * obj0 = 0 ;
51613 PyObject * obj1 = 0 ;
51614 PyObject * obj2 = 0 ;
51615 PyObject * obj3 = 0 ;
51616 char * kwnames[] = {
51617 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
51618 };
51619
51620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51622 if (!SWIG_IsOK(res1)) {
51623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
51624 }
51625 arg1 = reinterpret_cast< wxSizer * >(argp1);
51626 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51627 if (!SWIG_IsOK(res2)) {
51628 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
51629 }
51630 arg2 = reinterpret_cast< wxWindow * >(argp2);
51631 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51632 if (!SWIG_IsOK(res3)) {
51633 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
51634 }
51635 arg3 = reinterpret_cast< wxWindow * >(argp3);
51636 if (obj3) {
51637 ecode4 = SWIG_AsVal_bool(obj3, &val4);
51638 if (!SWIG_IsOK(ecode4)) {
51639 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
51640 }
51641 arg4 = static_cast< bool >(val4);
51642 }
51643 {
51644 PyThreadState* __tstate = wxPyBeginAllowThreads();
51645 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
51646 wxPyEndAllowThreads(__tstate);
51647 if (PyErr_Occurred()) SWIG_fail;
51648 }
51649 {
51650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51651 }
51652 return resultobj;
51653 fail:
51654 return NULL;
51655 }
51656
51657
51658 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51659 PyObject *resultobj = 0;
51660 wxSizer *arg1 = (wxSizer *) 0 ;
51661 wxSizer *arg2 = (wxSizer *) 0 ;
51662 wxSizer *arg3 = (wxSizer *) 0 ;
51663 bool arg4 = (bool) false ;
51664 bool result;
51665 void *argp1 = 0 ;
51666 int res1 = 0 ;
51667 void *argp2 = 0 ;
51668 int res2 = 0 ;
51669 void *argp3 = 0 ;
51670 int res3 = 0 ;
51671 bool val4 ;
51672 int ecode4 = 0 ;
51673 PyObject * obj0 = 0 ;
51674 PyObject * obj1 = 0 ;
51675 PyObject * obj2 = 0 ;
51676 PyObject * obj3 = 0 ;
51677 char * kwnames[] = {
51678 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
51679 };
51680
51681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51683 if (!SWIG_IsOK(res1)) {
51684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
51685 }
51686 arg1 = reinterpret_cast< wxSizer * >(argp1);
51687 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51688 if (!SWIG_IsOK(res2)) {
51689 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
51690 }
51691 arg2 = reinterpret_cast< wxSizer * >(argp2);
51692 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
51693 if (!SWIG_IsOK(res3)) {
51694 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
51695 }
51696 arg3 = reinterpret_cast< wxSizer * >(argp3);
51697 if (obj3) {
51698 ecode4 = SWIG_AsVal_bool(obj3, &val4);
51699 if (!SWIG_IsOK(ecode4)) {
51700 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
51701 }
51702 arg4 = static_cast< bool >(val4);
51703 }
51704 {
51705 PyThreadState* __tstate = wxPyBeginAllowThreads();
51706 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
51707 wxPyEndAllowThreads(__tstate);
51708 if (PyErr_Occurred()) SWIG_fail;
51709 }
51710 {
51711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51712 }
51713 return resultobj;
51714 fail:
51715 return NULL;
51716 }
51717
51718
51719 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51720 PyObject *resultobj = 0;
51721 wxSizer *arg1 = (wxSizer *) 0 ;
51722 size_t arg2 ;
51723 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
51724 bool result;
51725 void *argp1 = 0 ;
51726 int res1 = 0 ;
51727 size_t val2 ;
51728 int ecode2 = 0 ;
51729 void *argp3 = 0 ;
51730 int res3 = 0 ;
51731 PyObject * obj0 = 0 ;
51732 PyObject * obj1 = 0 ;
51733 PyObject * obj2 = 0 ;
51734 char * kwnames[] = {
51735 (char *) "self",(char *) "index",(char *) "newitem", NULL
51736 };
51737
51738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51740 if (!SWIG_IsOK(res1)) {
51741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
51742 }
51743 arg1 = reinterpret_cast< wxSizer * >(argp1);
51744 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51745 if (!SWIG_IsOK(ecode2)) {
51746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
51747 }
51748 arg2 = static_cast< size_t >(val2);
51749 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51750 if (!SWIG_IsOK(res3)) {
51751 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
51752 }
51753 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
51754 {
51755 PyThreadState* __tstate = wxPyBeginAllowThreads();
51756 result = (bool)(arg1)->Replace(arg2,arg3);
51757 wxPyEndAllowThreads(__tstate);
51758 if (PyErr_Occurred()) SWIG_fail;
51759 }
51760 {
51761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51762 }
51763 return resultobj;
51764 fail:
51765 return NULL;
51766 }
51767
51768
51769 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51770 PyObject *resultobj = 0;
51771 wxSizer *arg1 = (wxSizer *) 0 ;
51772 wxWindow *arg2 = (wxWindow *) 0 ;
51773 void *argp1 = 0 ;
51774 int res1 = 0 ;
51775 void *argp2 = 0 ;
51776 int res2 = 0 ;
51777 PyObject * obj0 = 0 ;
51778 PyObject * obj1 = 0 ;
51779 char * kwnames[] = {
51780 (char *) "self",(char *) "window", NULL
51781 };
51782
51783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
51784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51785 if (!SWIG_IsOK(res1)) {
51786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
51787 }
51788 arg1 = reinterpret_cast< wxSizer * >(argp1);
51789 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51790 if (!SWIG_IsOK(res2)) {
51791 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
51792 }
51793 arg2 = reinterpret_cast< wxWindow * >(argp2);
51794 {
51795 PyThreadState* __tstate = wxPyBeginAllowThreads();
51796 (arg1)->SetContainingWindow(arg2);
51797 wxPyEndAllowThreads(__tstate);
51798 if (PyErr_Occurred()) SWIG_fail;
51799 }
51800 resultobj = SWIG_Py_Void();
51801 return resultobj;
51802 fail:
51803 return NULL;
51804 }
51805
51806
51807 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51808 PyObject *resultobj = 0;
51809 wxSizer *arg1 = (wxSizer *) 0 ;
51810 wxWindow *result = 0 ;
51811 void *argp1 = 0 ;
51812 int res1 = 0 ;
51813 PyObject *swig_obj[1] ;
51814
51815 if (!args) SWIG_fail;
51816 swig_obj[0] = args;
51817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51818 if (!SWIG_IsOK(res1)) {
51819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
51820 }
51821 arg1 = reinterpret_cast< wxSizer * >(argp1);
51822 {
51823 PyThreadState* __tstate = wxPyBeginAllowThreads();
51824 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
51825 wxPyEndAllowThreads(__tstate);
51826 if (PyErr_Occurred()) SWIG_fail;
51827 }
51828 {
51829 resultobj = wxPyMake_wxObject(result, 0);
51830 }
51831 return resultobj;
51832 fail:
51833 return NULL;
51834 }
51835
51836
51837 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51838 PyObject *resultobj = 0;
51839 wxSizer *arg1 = (wxSizer *) 0 ;
51840 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
51841 wxSizerItem *result = 0 ;
51842 void *argp1 = 0 ;
51843 int res1 = 0 ;
51844 int res2 = 0 ;
51845 PyObject * obj0 = 0 ;
51846 PyObject * obj1 = 0 ;
51847 char * kwnames[] = {
51848 (char *) "self",(char *) "item", NULL
51849 };
51850
51851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
51852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51853 if (!SWIG_IsOK(res1)) {
51854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
51855 }
51856 arg1 = reinterpret_cast< wxSizer * >(argp1);
51857 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
51858 if (!SWIG_IsOK(res2)) {
51859 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
51860 }
51861 {
51862 PyThreadState* __tstate = wxPyBeginAllowThreads();
51863 result = (wxSizerItem *)(arg1)->Add(arg2);
51864 wxPyEndAllowThreads(__tstate);
51865 if (PyErr_Occurred()) SWIG_fail;
51866 }
51867 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51868 return resultobj;
51869 fail:
51870 return NULL;
51871 }
51872
51873
51874 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51875 PyObject *resultobj = 0;
51876 wxSizer *arg1 = (wxSizer *) 0 ;
51877 size_t arg2 ;
51878 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
51879 wxSizerItem *result = 0 ;
51880 void *argp1 = 0 ;
51881 int res1 = 0 ;
51882 size_t val2 ;
51883 int ecode2 = 0 ;
51884 int res3 = 0 ;
51885 PyObject * obj0 = 0 ;
51886 PyObject * obj1 = 0 ;
51887 PyObject * obj2 = 0 ;
51888 char * kwnames[] = {
51889 (char *) "self",(char *) "index",(char *) "item", NULL
51890 };
51891
51892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51894 if (!SWIG_IsOK(res1)) {
51895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
51896 }
51897 arg1 = reinterpret_cast< wxSizer * >(argp1);
51898 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51899 if (!SWIG_IsOK(ecode2)) {
51900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
51901 }
51902 arg2 = static_cast< size_t >(val2);
51903 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
51904 if (!SWIG_IsOK(res3)) {
51905 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
51906 }
51907 {
51908 PyThreadState* __tstate = wxPyBeginAllowThreads();
51909 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
51910 wxPyEndAllowThreads(__tstate);
51911 if (PyErr_Occurred()) SWIG_fail;
51912 }
51913 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51914 return resultobj;
51915 fail:
51916 return NULL;
51917 }
51918
51919
51920 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51921 PyObject *resultobj = 0;
51922 wxSizer *arg1 = (wxSizer *) 0 ;
51923 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
51924 wxSizerItem *result = 0 ;
51925 void *argp1 = 0 ;
51926 int res1 = 0 ;
51927 int res2 = 0 ;
51928 PyObject * obj0 = 0 ;
51929 PyObject * obj1 = 0 ;
51930 char * kwnames[] = {
51931 (char *) "self",(char *) "item", NULL
51932 };
51933
51934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
51935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51936 if (!SWIG_IsOK(res1)) {
51937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
51938 }
51939 arg1 = reinterpret_cast< wxSizer * >(argp1);
51940 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
51941 if (!SWIG_IsOK(res2)) {
51942 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
51943 }
51944 {
51945 PyThreadState* __tstate = wxPyBeginAllowThreads();
51946 result = (wxSizerItem *)(arg1)->Prepend(arg2);
51947 wxPyEndAllowThreads(__tstate);
51948 if (PyErr_Occurred()) SWIG_fail;
51949 }
51950 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51951 return resultobj;
51952 fail:
51953 return NULL;
51954 }
51955
51956
51957 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51958 PyObject *resultobj = 0;
51959 wxSizer *arg1 = (wxSizer *) 0 ;
51960 int arg2 ;
51961 int arg3 ;
51962 int arg4 ;
51963 int arg5 ;
51964 void *argp1 = 0 ;
51965 int res1 = 0 ;
51966 int val2 ;
51967 int ecode2 = 0 ;
51968 int val3 ;
51969 int ecode3 = 0 ;
51970 int val4 ;
51971 int ecode4 = 0 ;
51972 int val5 ;
51973 int ecode5 = 0 ;
51974 PyObject * obj0 = 0 ;
51975 PyObject * obj1 = 0 ;
51976 PyObject * obj2 = 0 ;
51977 PyObject * obj3 = 0 ;
51978 PyObject * obj4 = 0 ;
51979 char * kwnames[] = {
51980 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
51981 };
51982
51983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
51984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51985 if (!SWIG_IsOK(res1)) {
51986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
51987 }
51988 arg1 = reinterpret_cast< wxSizer * >(argp1);
51989 ecode2 = SWIG_AsVal_int(obj1, &val2);
51990 if (!SWIG_IsOK(ecode2)) {
51991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
51992 }
51993 arg2 = static_cast< int >(val2);
51994 ecode3 = SWIG_AsVal_int(obj2, &val3);
51995 if (!SWIG_IsOK(ecode3)) {
51996 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
51997 }
51998 arg3 = static_cast< int >(val3);
51999 ecode4 = SWIG_AsVal_int(obj3, &val4);
52000 if (!SWIG_IsOK(ecode4)) {
52001 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
52002 }
52003 arg4 = static_cast< int >(val4);
52004 ecode5 = SWIG_AsVal_int(obj4, &val5);
52005 if (!SWIG_IsOK(ecode5)) {
52006 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
52007 }
52008 arg5 = static_cast< int >(val5);
52009 {
52010 PyThreadState* __tstate = wxPyBeginAllowThreads();
52011 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
52012 wxPyEndAllowThreads(__tstate);
52013 if (PyErr_Occurred()) SWIG_fail;
52014 }
52015 resultobj = SWIG_Py_Void();
52016 return resultobj;
52017 fail:
52018 return NULL;
52019 }
52020
52021
52022 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52023 PyObject *resultobj = 0;
52024 wxSizer *arg1 = (wxSizer *) 0 ;
52025 wxSize *arg2 = 0 ;
52026 void *argp1 = 0 ;
52027 int res1 = 0 ;
52028 wxSize temp2 ;
52029 PyObject * obj0 = 0 ;
52030 PyObject * obj1 = 0 ;
52031 char * kwnames[] = {
52032 (char *) "self",(char *) "size", NULL
52033 };
52034
52035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
52036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52037 if (!SWIG_IsOK(res1)) {
52038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
52039 }
52040 arg1 = reinterpret_cast< wxSizer * >(argp1);
52041 {
52042 arg2 = &temp2;
52043 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
52044 }
52045 {
52046 PyThreadState* __tstate = wxPyBeginAllowThreads();
52047 (arg1)->SetMinSize((wxSize const &)*arg2);
52048 wxPyEndAllowThreads(__tstate);
52049 if (PyErr_Occurred()) SWIG_fail;
52050 }
52051 resultobj = SWIG_Py_Void();
52052 return resultobj;
52053 fail:
52054 return NULL;
52055 }
52056
52057
52058 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52059 PyObject *resultobj = 0;
52060 wxSizer *arg1 = (wxSizer *) 0 ;
52061 wxSize result;
52062 void *argp1 = 0 ;
52063 int res1 = 0 ;
52064 PyObject *swig_obj[1] ;
52065
52066 if (!args) SWIG_fail;
52067 swig_obj[0] = args;
52068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52069 if (!SWIG_IsOK(res1)) {
52070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
52071 }
52072 arg1 = reinterpret_cast< wxSizer * >(argp1);
52073 {
52074 PyThreadState* __tstate = wxPyBeginAllowThreads();
52075 result = (arg1)->GetSize();
52076 wxPyEndAllowThreads(__tstate);
52077 if (PyErr_Occurred()) SWIG_fail;
52078 }
52079 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
52080 return resultobj;
52081 fail:
52082 return NULL;
52083 }
52084
52085
52086 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52087 PyObject *resultobj = 0;
52088 wxSizer *arg1 = (wxSizer *) 0 ;
52089 wxPoint result;
52090 void *argp1 = 0 ;
52091 int res1 = 0 ;
52092 PyObject *swig_obj[1] ;
52093
52094 if (!args) SWIG_fail;
52095 swig_obj[0] = args;
52096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52097 if (!SWIG_IsOK(res1)) {
52098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
52099 }
52100 arg1 = reinterpret_cast< wxSizer * >(argp1);
52101 {
52102 PyThreadState* __tstate = wxPyBeginAllowThreads();
52103 result = (arg1)->GetPosition();
52104 wxPyEndAllowThreads(__tstate);
52105 if (PyErr_Occurred()) SWIG_fail;
52106 }
52107 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
52108 return resultobj;
52109 fail:
52110 return NULL;
52111 }
52112
52113
52114 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52115 PyObject *resultobj = 0;
52116 wxSizer *arg1 = (wxSizer *) 0 ;
52117 wxSize result;
52118 void *argp1 = 0 ;
52119 int res1 = 0 ;
52120 PyObject *swig_obj[1] ;
52121
52122 if (!args) SWIG_fail;
52123 swig_obj[0] = args;
52124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52125 if (!SWIG_IsOK(res1)) {
52126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
52127 }
52128 arg1 = reinterpret_cast< wxSizer * >(argp1);
52129 {
52130 PyThreadState* __tstate = wxPyBeginAllowThreads();
52131 result = (arg1)->GetMinSize();
52132 wxPyEndAllowThreads(__tstate);
52133 if (PyErr_Occurred()) SWIG_fail;
52134 }
52135 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
52136 return resultobj;
52137 fail:
52138 return NULL;
52139 }
52140
52141
52142 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52143 PyObject *resultobj = 0;
52144 wxSizer *arg1 = (wxSizer *) 0 ;
52145 void *argp1 = 0 ;
52146 int res1 = 0 ;
52147 PyObject *swig_obj[1] ;
52148
52149 if (!args) SWIG_fail;
52150 swig_obj[0] = args;
52151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52152 if (!SWIG_IsOK(res1)) {
52153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
52154 }
52155 arg1 = reinterpret_cast< wxSizer * >(argp1);
52156 {
52157 PyThreadState* __tstate = wxPyBeginAllowThreads();
52158 (arg1)->RecalcSizes();
52159 wxPyEndAllowThreads(__tstate);
52160 if (PyErr_Occurred()) SWIG_fail;
52161 }
52162 resultobj = SWIG_Py_Void();
52163 return resultobj;
52164 fail:
52165 return NULL;
52166 }
52167
52168
52169 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52170 PyObject *resultobj = 0;
52171 wxSizer *arg1 = (wxSizer *) 0 ;
52172 wxSize result;
52173 void *argp1 = 0 ;
52174 int res1 = 0 ;
52175 PyObject *swig_obj[1] ;
52176
52177 if (!args) SWIG_fail;
52178 swig_obj[0] = args;
52179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52180 if (!SWIG_IsOK(res1)) {
52181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
52182 }
52183 arg1 = reinterpret_cast< wxSizer * >(argp1);
52184 {
52185 PyThreadState* __tstate = wxPyBeginAllowThreads();
52186 result = (arg1)->CalcMin();
52187 wxPyEndAllowThreads(__tstate);
52188 if (PyErr_Occurred()) SWIG_fail;
52189 }
52190 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
52191 return resultobj;
52192 fail:
52193 return NULL;
52194 }
52195
52196
52197 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52198 PyObject *resultobj = 0;
52199 wxSizer *arg1 = (wxSizer *) 0 ;
52200 void *argp1 = 0 ;
52201 int res1 = 0 ;
52202 PyObject *swig_obj[1] ;
52203
52204 if (!args) SWIG_fail;
52205 swig_obj[0] = args;
52206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52207 if (!SWIG_IsOK(res1)) {
52208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
52209 }
52210 arg1 = reinterpret_cast< wxSizer * >(argp1);
52211 {
52212 PyThreadState* __tstate = wxPyBeginAllowThreads();
52213 (arg1)->Layout();
52214 wxPyEndAllowThreads(__tstate);
52215 if (PyErr_Occurred()) SWIG_fail;
52216 }
52217 resultobj = SWIG_Py_Void();
52218 return resultobj;
52219 fail:
52220 return NULL;
52221 }
52222
52223
52224 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52225 PyObject *resultobj = 0;
52226 wxSizer *arg1 = (wxSizer *) 0 ;
52227 wxWindow *arg2 = (wxWindow *) 0 ;
52228 wxSize result;
52229 void *argp1 = 0 ;
52230 int res1 = 0 ;
52231 void *argp2 = 0 ;
52232 int res2 = 0 ;
52233 PyObject * obj0 = 0 ;
52234 PyObject * obj1 = 0 ;
52235 char * kwnames[] = {
52236 (char *) "self",(char *) "window", NULL
52237 };
52238
52239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
52240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52241 if (!SWIG_IsOK(res1)) {
52242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
52243 }
52244 arg1 = reinterpret_cast< wxSizer * >(argp1);
52245 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52246 if (!SWIG_IsOK(res2)) {
52247 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
52248 }
52249 arg2 = reinterpret_cast< wxWindow * >(argp2);
52250 {
52251 PyThreadState* __tstate = wxPyBeginAllowThreads();
52252 result = (arg1)->Fit(arg2);
52253 wxPyEndAllowThreads(__tstate);
52254 if (PyErr_Occurred()) SWIG_fail;
52255 }
52256 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
52257 return resultobj;
52258 fail:
52259 return NULL;
52260 }
52261
52262
52263 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52264 PyObject *resultobj = 0;
52265 wxSizer *arg1 = (wxSizer *) 0 ;
52266 wxWindow *arg2 = (wxWindow *) 0 ;
52267 void *argp1 = 0 ;
52268 int res1 = 0 ;
52269 void *argp2 = 0 ;
52270 int res2 = 0 ;
52271 PyObject * obj0 = 0 ;
52272 PyObject * obj1 = 0 ;
52273 char * kwnames[] = {
52274 (char *) "self",(char *) "window", NULL
52275 };
52276
52277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
52278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52279 if (!SWIG_IsOK(res1)) {
52280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
52281 }
52282 arg1 = reinterpret_cast< wxSizer * >(argp1);
52283 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52284 if (!SWIG_IsOK(res2)) {
52285 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
52286 }
52287 arg2 = reinterpret_cast< wxWindow * >(argp2);
52288 {
52289 PyThreadState* __tstate = wxPyBeginAllowThreads();
52290 (arg1)->FitInside(arg2);
52291 wxPyEndAllowThreads(__tstate);
52292 if (PyErr_Occurred()) SWIG_fail;
52293 }
52294 resultobj = SWIG_Py_Void();
52295 return resultobj;
52296 fail:
52297 return NULL;
52298 }
52299
52300
52301 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52302 PyObject *resultobj = 0;
52303 wxSizer *arg1 = (wxSizer *) 0 ;
52304 wxWindow *arg2 = (wxWindow *) 0 ;
52305 void *argp1 = 0 ;
52306 int res1 = 0 ;
52307 void *argp2 = 0 ;
52308 int res2 = 0 ;
52309 PyObject * obj0 = 0 ;
52310 PyObject * obj1 = 0 ;
52311 char * kwnames[] = {
52312 (char *) "self",(char *) "window", NULL
52313 };
52314
52315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
52316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52317 if (!SWIG_IsOK(res1)) {
52318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
52319 }
52320 arg1 = reinterpret_cast< wxSizer * >(argp1);
52321 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52322 if (!SWIG_IsOK(res2)) {
52323 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
52324 }
52325 arg2 = reinterpret_cast< wxWindow * >(argp2);
52326 {
52327 PyThreadState* __tstate = wxPyBeginAllowThreads();
52328 (arg1)->SetSizeHints(arg2);
52329 wxPyEndAllowThreads(__tstate);
52330 if (PyErr_Occurred()) SWIG_fail;
52331 }
52332 resultobj = SWIG_Py_Void();
52333 return resultobj;
52334 fail:
52335 return NULL;
52336 }
52337
52338
52339 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52340 PyObject *resultobj = 0;
52341 wxSizer *arg1 = (wxSizer *) 0 ;
52342 wxWindow *arg2 = (wxWindow *) 0 ;
52343 void *argp1 = 0 ;
52344 int res1 = 0 ;
52345 void *argp2 = 0 ;
52346 int res2 = 0 ;
52347 PyObject * obj0 = 0 ;
52348 PyObject * obj1 = 0 ;
52349 char * kwnames[] = {
52350 (char *) "self",(char *) "window", NULL
52351 };
52352
52353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
52354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52355 if (!SWIG_IsOK(res1)) {
52356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
52357 }
52358 arg1 = reinterpret_cast< wxSizer * >(argp1);
52359 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52360 if (!SWIG_IsOK(res2)) {
52361 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
52362 }
52363 arg2 = reinterpret_cast< wxWindow * >(argp2);
52364 {
52365 PyThreadState* __tstate = wxPyBeginAllowThreads();
52366 (arg1)->SetVirtualSizeHints(arg2);
52367 wxPyEndAllowThreads(__tstate);
52368 if (PyErr_Occurred()) SWIG_fail;
52369 }
52370 resultobj = SWIG_Py_Void();
52371 return resultobj;
52372 fail:
52373 return NULL;
52374 }
52375
52376
52377 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52378 PyObject *resultobj = 0;
52379 wxSizer *arg1 = (wxSizer *) 0 ;
52380 bool arg2 = (bool) false ;
52381 void *argp1 = 0 ;
52382 int res1 = 0 ;
52383 bool val2 ;
52384 int ecode2 = 0 ;
52385 PyObject * obj0 = 0 ;
52386 PyObject * obj1 = 0 ;
52387 char * kwnames[] = {
52388 (char *) "self",(char *) "deleteWindows", NULL
52389 };
52390
52391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
52392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52393 if (!SWIG_IsOK(res1)) {
52394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
52395 }
52396 arg1 = reinterpret_cast< wxSizer * >(argp1);
52397 if (obj1) {
52398 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52399 if (!SWIG_IsOK(ecode2)) {
52400 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
52401 }
52402 arg2 = static_cast< bool >(val2);
52403 }
52404 {
52405 PyThreadState* __tstate = wxPyBeginAllowThreads();
52406 (arg1)->Clear(arg2);
52407 wxPyEndAllowThreads(__tstate);
52408 if (PyErr_Occurred()) SWIG_fail;
52409 }
52410 resultobj = SWIG_Py_Void();
52411 return resultobj;
52412 fail:
52413 return NULL;
52414 }
52415
52416
52417 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52418 PyObject *resultobj = 0;
52419 wxSizer *arg1 = (wxSizer *) 0 ;
52420 void *argp1 = 0 ;
52421 int res1 = 0 ;
52422 PyObject *swig_obj[1] ;
52423
52424 if (!args) SWIG_fail;
52425 swig_obj[0] = args;
52426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52427 if (!SWIG_IsOK(res1)) {
52428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
52429 }
52430 arg1 = reinterpret_cast< wxSizer * >(argp1);
52431 {
52432 PyThreadState* __tstate = wxPyBeginAllowThreads();
52433 (arg1)->DeleteWindows();
52434 wxPyEndAllowThreads(__tstate);
52435 if (PyErr_Occurred()) SWIG_fail;
52436 }
52437 resultobj = SWIG_Py_Void();
52438 return resultobj;
52439 fail:
52440 return NULL;
52441 }
52442
52443
52444 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52445 PyObject *resultobj = 0;
52446 wxSizer *arg1 = (wxSizer *) 0 ;
52447 PyObject *result = 0 ;
52448 void *argp1 = 0 ;
52449 int res1 = 0 ;
52450 PyObject *swig_obj[1] ;
52451
52452 if (!args) SWIG_fail;
52453 swig_obj[0] = args;
52454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52455 if (!SWIG_IsOK(res1)) {
52456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
52457 }
52458 arg1 = reinterpret_cast< wxSizer * >(argp1);
52459 {
52460 PyThreadState* __tstate = wxPyBeginAllowThreads();
52461 result = (PyObject *)wxSizer_GetChildren(arg1);
52462 wxPyEndAllowThreads(__tstate);
52463 if (PyErr_Occurred()) SWIG_fail;
52464 }
52465 resultobj = result;
52466 return resultobj;
52467 fail:
52468 return NULL;
52469 }
52470
52471
52472 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52473 PyObject *resultobj = 0;
52474 wxSizer *arg1 = (wxSizer *) 0 ;
52475 PyObject *arg2 = (PyObject *) 0 ;
52476 bool arg3 = (bool) true ;
52477 bool arg4 = (bool) false ;
52478 bool result;
52479 void *argp1 = 0 ;
52480 int res1 = 0 ;
52481 bool val3 ;
52482 int ecode3 = 0 ;
52483 bool val4 ;
52484 int ecode4 = 0 ;
52485 PyObject * obj0 = 0 ;
52486 PyObject * obj1 = 0 ;
52487 PyObject * obj2 = 0 ;
52488 PyObject * obj3 = 0 ;
52489 char * kwnames[] = {
52490 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
52491 };
52492
52493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52495 if (!SWIG_IsOK(res1)) {
52496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
52497 }
52498 arg1 = reinterpret_cast< wxSizer * >(argp1);
52499 arg2 = obj1;
52500 if (obj2) {
52501 ecode3 = SWIG_AsVal_bool(obj2, &val3);
52502 if (!SWIG_IsOK(ecode3)) {
52503 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
52504 }
52505 arg3 = static_cast< bool >(val3);
52506 }
52507 if (obj3) {
52508 ecode4 = SWIG_AsVal_bool(obj3, &val4);
52509 if (!SWIG_IsOK(ecode4)) {
52510 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
52511 }
52512 arg4 = static_cast< bool >(val4);
52513 }
52514 {
52515 PyThreadState* __tstate = wxPyBeginAllowThreads();
52516 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
52517 wxPyEndAllowThreads(__tstate);
52518 if (PyErr_Occurred()) SWIG_fail;
52519 }
52520 {
52521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52522 }
52523 return resultobj;
52524 fail:
52525 return NULL;
52526 }
52527
52528
52529 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52530 PyObject *resultobj = 0;
52531 wxSizer *arg1 = (wxSizer *) 0 ;
52532 PyObject *arg2 = (PyObject *) 0 ;
52533 bool result;
52534 void *argp1 = 0 ;
52535 int res1 = 0 ;
52536 PyObject * obj0 = 0 ;
52537 PyObject * obj1 = 0 ;
52538 char * kwnames[] = {
52539 (char *) "self",(char *) "item", NULL
52540 };
52541
52542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
52543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52544 if (!SWIG_IsOK(res1)) {
52545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
52546 }
52547 arg1 = reinterpret_cast< wxSizer * >(argp1);
52548 arg2 = obj1;
52549 {
52550 PyThreadState* __tstate = wxPyBeginAllowThreads();
52551 result = (bool)wxSizer_IsShown(arg1,arg2);
52552 wxPyEndAllowThreads(__tstate);
52553 if (PyErr_Occurred()) SWIG_fail;
52554 }
52555 {
52556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52557 }
52558 return resultobj;
52559 fail:
52560 return NULL;
52561 }
52562
52563
52564 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52565 PyObject *resultobj = 0;
52566 wxSizer *arg1 = (wxSizer *) 0 ;
52567 bool arg2 ;
52568 void *argp1 = 0 ;
52569 int res1 = 0 ;
52570 bool val2 ;
52571 int ecode2 = 0 ;
52572 PyObject * obj0 = 0 ;
52573 PyObject * obj1 = 0 ;
52574 char * kwnames[] = {
52575 (char *) "self",(char *) "show", NULL
52576 };
52577
52578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
52579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52580 if (!SWIG_IsOK(res1)) {
52581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
52582 }
52583 arg1 = reinterpret_cast< wxSizer * >(argp1);
52584 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52585 if (!SWIG_IsOK(ecode2)) {
52586 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
52587 }
52588 arg2 = static_cast< bool >(val2);
52589 {
52590 PyThreadState* __tstate = wxPyBeginAllowThreads();
52591 (arg1)->ShowItems(arg2);
52592 wxPyEndAllowThreads(__tstate);
52593 if (PyErr_Occurred()) SWIG_fail;
52594 }
52595 resultobj = SWIG_Py_Void();
52596 return resultobj;
52597 fail:
52598 return NULL;
52599 }
52600
52601
52602 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52603 PyObject *obj;
52604 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52605 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
52606 return SWIG_Py_Void();
52607 }
52608
52609 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52610 PyObject *resultobj = 0;
52611 wxPySizer *result = 0 ;
52612
52613 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
52614 {
52615 PyThreadState* __tstate = wxPyBeginAllowThreads();
52616 result = (wxPySizer *)new wxPySizer();
52617 wxPyEndAllowThreads(__tstate);
52618 if (PyErr_Occurred()) SWIG_fail;
52619 }
52620 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
52621 return resultobj;
52622 fail:
52623 return NULL;
52624 }
52625
52626
52627 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52628 PyObject *resultobj = 0;
52629 wxPySizer *arg1 = (wxPySizer *) 0 ;
52630 PyObject *arg2 = (PyObject *) 0 ;
52631 PyObject *arg3 = (PyObject *) 0 ;
52632 void *argp1 = 0 ;
52633 int res1 = 0 ;
52634 PyObject * obj0 = 0 ;
52635 PyObject * obj1 = 0 ;
52636 PyObject * obj2 = 0 ;
52637 char * kwnames[] = {
52638 (char *) "self",(char *) "self",(char *) "_class", NULL
52639 };
52640
52641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
52643 if (!SWIG_IsOK(res1)) {
52644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
52645 }
52646 arg1 = reinterpret_cast< wxPySizer * >(argp1);
52647 arg2 = obj1;
52648 arg3 = obj2;
52649 {
52650 PyThreadState* __tstate = wxPyBeginAllowThreads();
52651 (arg1)->_setCallbackInfo(arg2,arg3);
52652 wxPyEndAllowThreads(__tstate);
52653 if (PyErr_Occurred()) SWIG_fail;
52654 }
52655 resultobj = SWIG_Py_Void();
52656 return resultobj;
52657 fail:
52658 return NULL;
52659 }
52660
52661
52662 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52663 PyObject *obj;
52664 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52665 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
52666 return SWIG_Py_Void();
52667 }
52668
52669 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52670 return SWIG_Python_InitShadowInstance(args);
52671 }
52672
52673 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52674 PyObject *resultobj = 0;
52675 int arg1 = (int) wxHORIZONTAL ;
52676 wxBoxSizer *result = 0 ;
52677 int val1 ;
52678 int ecode1 = 0 ;
52679 PyObject * obj0 = 0 ;
52680 char * kwnames[] = {
52681 (char *) "orient", NULL
52682 };
52683
52684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
52685 if (obj0) {
52686 ecode1 = SWIG_AsVal_int(obj0, &val1);
52687 if (!SWIG_IsOK(ecode1)) {
52688 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
52689 }
52690 arg1 = static_cast< int >(val1);
52691 }
52692 {
52693 PyThreadState* __tstate = wxPyBeginAllowThreads();
52694 result = (wxBoxSizer *)new wxBoxSizer(arg1);
52695 wxPyEndAllowThreads(__tstate);
52696 if (PyErr_Occurred()) SWIG_fail;
52697 }
52698 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
52699 return resultobj;
52700 fail:
52701 return NULL;
52702 }
52703
52704
52705 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52706 PyObject *resultobj = 0;
52707 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
52708 int result;
52709 void *argp1 = 0 ;
52710 int res1 = 0 ;
52711 PyObject *swig_obj[1] ;
52712
52713 if (!args) SWIG_fail;
52714 swig_obj[0] = args;
52715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
52716 if (!SWIG_IsOK(res1)) {
52717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
52718 }
52719 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
52720 {
52721 PyThreadState* __tstate = wxPyBeginAllowThreads();
52722 result = (int)(arg1)->GetOrientation();
52723 wxPyEndAllowThreads(__tstate);
52724 if (PyErr_Occurred()) SWIG_fail;
52725 }
52726 resultobj = SWIG_From_int(static_cast< int >(result));
52727 return resultobj;
52728 fail:
52729 return NULL;
52730 }
52731
52732
52733 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52734 PyObject *resultobj = 0;
52735 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
52736 int arg2 ;
52737 void *argp1 = 0 ;
52738 int res1 = 0 ;
52739 int val2 ;
52740 int ecode2 = 0 ;
52741 PyObject * obj0 = 0 ;
52742 PyObject * obj1 = 0 ;
52743 char * kwnames[] = {
52744 (char *) "self",(char *) "orient", NULL
52745 };
52746
52747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
52748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
52749 if (!SWIG_IsOK(res1)) {
52750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
52751 }
52752 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
52753 ecode2 = SWIG_AsVal_int(obj1, &val2);
52754 if (!SWIG_IsOK(ecode2)) {
52755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
52756 }
52757 arg2 = static_cast< int >(val2);
52758 {
52759 PyThreadState* __tstate = wxPyBeginAllowThreads();
52760 (arg1)->SetOrientation(arg2);
52761 wxPyEndAllowThreads(__tstate);
52762 if (PyErr_Occurred()) SWIG_fail;
52763 }
52764 resultobj = SWIG_Py_Void();
52765 return resultobj;
52766 fail:
52767 return NULL;
52768 }
52769
52770
52771 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52772 PyObject *obj;
52773 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52774 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
52775 return SWIG_Py_Void();
52776 }
52777
52778 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52779 return SWIG_Python_InitShadowInstance(args);
52780 }
52781
52782 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52783 PyObject *resultobj = 0;
52784 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
52785 int arg2 = (int) wxHORIZONTAL ;
52786 wxStaticBoxSizer *result = 0 ;
52787 void *argp1 = 0 ;
52788 int res1 = 0 ;
52789 int val2 ;
52790 int ecode2 = 0 ;
52791 PyObject * obj0 = 0 ;
52792 PyObject * obj1 = 0 ;
52793 char * kwnames[] = {
52794 (char *) "box",(char *) "orient", NULL
52795 };
52796
52797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
52798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
52799 if (!SWIG_IsOK(res1)) {
52800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
52801 }
52802 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
52803 if (obj1) {
52804 ecode2 = SWIG_AsVal_int(obj1, &val2);
52805 if (!SWIG_IsOK(ecode2)) {
52806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
52807 }
52808 arg2 = static_cast< int >(val2);
52809 }
52810 {
52811 PyThreadState* __tstate = wxPyBeginAllowThreads();
52812 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
52813 wxPyEndAllowThreads(__tstate);
52814 if (PyErr_Occurred()) SWIG_fail;
52815 }
52816 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
52817 return resultobj;
52818 fail:
52819 return NULL;
52820 }
52821
52822
52823 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52824 PyObject *resultobj = 0;
52825 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
52826 wxStaticBox *result = 0 ;
52827 void *argp1 = 0 ;
52828 int res1 = 0 ;
52829 PyObject *swig_obj[1] ;
52830
52831 if (!args) SWIG_fail;
52832 swig_obj[0] = args;
52833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
52834 if (!SWIG_IsOK(res1)) {
52835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
52836 }
52837 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
52838 {
52839 PyThreadState* __tstate = wxPyBeginAllowThreads();
52840 result = (wxStaticBox *)(arg1)->GetStaticBox();
52841 wxPyEndAllowThreads(__tstate);
52842 if (PyErr_Occurred()) SWIG_fail;
52843 }
52844 {
52845 resultobj = wxPyMake_wxObject(result, (bool)0);
52846 }
52847 return resultobj;
52848 fail:
52849 return NULL;
52850 }
52851
52852
52853 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52854 PyObject *obj;
52855 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52856 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
52857 return SWIG_Py_Void();
52858 }
52859
52860 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52861 return SWIG_Python_InitShadowInstance(args);
52862 }
52863
52864 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52865 PyObject *resultobj = 0;
52866 int arg1 = (int) 1 ;
52867 int arg2 = (int) 0 ;
52868 int arg3 = (int) 0 ;
52869 int arg4 = (int) 0 ;
52870 wxGridSizer *result = 0 ;
52871 int val1 ;
52872 int ecode1 = 0 ;
52873 int val2 ;
52874 int ecode2 = 0 ;
52875 int val3 ;
52876 int ecode3 = 0 ;
52877 int val4 ;
52878 int ecode4 = 0 ;
52879 PyObject * obj0 = 0 ;
52880 PyObject * obj1 = 0 ;
52881 PyObject * obj2 = 0 ;
52882 PyObject * obj3 = 0 ;
52883 char * kwnames[] = {
52884 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
52885 };
52886
52887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52888 if (obj0) {
52889 ecode1 = SWIG_AsVal_int(obj0, &val1);
52890 if (!SWIG_IsOK(ecode1)) {
52891 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
52892 }
52893 arg1 = static_cast< int >(val1);
52894 }
52895 if (obj1) {
52896 ecode2 = SWIG_AsVal_int(obj1, &val2);
52897 if (!SWIG_IsOK(ecode2)) {
52898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
52899 }
52900 arg2 = static_cast< int >(val2);
52901 }
52902 if (obj2) {
52903 ecode3 = SWIG_AsVal_int(obj2, &val3);
52904 if (!SWIG_IsOK(ecode3)) {
52905 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
52906 }
52907 arg3 = static_cast< int >(val3);
52908 }
52909 if (obj3) {
52910 ecode4 = SWIG_AsVal_int(obj3, &val4);
52911 if (!SWIG_IsOK(ecode4)) {
52912 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
52913 }
52914 arg4 = static_cast< int >(val4);
52915 }
52916 {
52917 PyThreadState* __tstate = wxPyBeginAllowThreads();
52918 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
52919 wxPyEndAllowThreads(__tstate);
52920 if (PyErr_Occurred()) SWIG_fail;
52921 }
52922 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
52923 return resultobj;
52924 fail:
52925 return NULL;
52926 }
52927
52928
52929 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52930 PyObject *resultobj = 0;
52931 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
52932 int arg2 ;
52933 void *argp1 = 0 ;
52934 int res1 = 0 ;
52935 int val2 ;
52936 int ecode2 = 0 ;
52937 PyObject * obj0 = 0 ;
52938 PyObject * obj1 = 0 ;
52939 char * kwnames[] = {
52940 (char *) "self",(char *) "cols", NULL
52941 };
52942
52943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
52944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
52945 if (!SWIG_IsOK(res1)) {
52946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
52947 }
52948 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
52949 ecode2 = SWIG_AsVal_int(obj1, &val2);
52950 if (!SWIG_IsOK(ecode2)) {
52951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
52952 }
52953 arg2 = static_cast< int >(val2);
52954 {
52955 PyThreadState* __tstate = wxPyBeginAllowThreads();
52956 (arg1)->SetCols(arg2);
52957 wxPyEndAllowThreads(__tstate);
52958 if (PyErr_Occurred()) SWIG_fail;
52959 }
52960 resultobj = SWIG_Py_Void();
52961 return resultobj;
52962 fail:
52963 return NULL;
52964 }
52965
52966
52967 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52968 PyObject *resultobj = 0;
52969 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
52970 int arg2 ;
52971 void *argp1 = 0 ;
52972 int res1 = 0 ;
52973 int val2 ;
52974 int ecode2 = 0 ;
52975 PyObject * obj0 = 0 ;
52976 PyObject * obj1 = 0 ;
52977 char * kwnames[] = {
52978 (char *) "self",(char *) "rows", NULL
52979 };
52980
52981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
52982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
52983 if (!SWIG_IsOK(res1)) {
52984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
52985 }
52986 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
52987 ecode2 = SWIG_AsVal_int(obj1, &val2);
52988 if (!SWIG_IsOK(ecode2)) {
52989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
52990 }
52991 arg2 = static_cast< int >(val2);
52992 {
52993 PyThreadState* __tstate = wxPyBeginAllowThreads();
52994 (arg1)->SetRows(arg2);
52995 wxPyEndAllowThreads(__tstate);
52996 if (PyErr_Occurred()) SWIG_fail;
52997 }
52998 resultobj = SWIG_Py_Void();
52999 return resultobj;
53000 fail:
53001 return NULL;
53002 }
53003
53004
53005 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53006 PyObject *resultobj = 0;
53007 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53008 int arg2 ;
53009 void *argp1 = 0 ;
53010 int res1 = 0 ;
53011 int val2 ;
53012 int ecode2 = 0 ;
53013 PyObject * obj0 = 0 ;
53014 PyObject * obj1 = 0 ;
53015 char * kwnames[] = {
53016 (char *) "self",(char *) "gap", NULL
53017 };
53018
53019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
53020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53021 if (!SWIG_IsOK(res1)) {
53022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53023 }
53024 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53025 ecode2 = SWIG_AsVal_int(obj1, &val2);
53026 if (!SWIG_IsOK(ecode2)) {
53027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
53028 }
53029 arg2 = static_cast< int >(val2);
53030 {
53031 PyThreadState* __tstate = wxPyBeginAllowThreads();
53032 (arg1)->SetVGap(arg2);
53033 wxPyEndAllowThreads(__tstate);
53034 if (PyErr_Occurred()) SWIG_fail;
53035 }
53036 resultobj = SWIG_Py_Void();
53037 return resultobj;
53038 fail:
53039 return NULL;
53040 }
53041
53042
53043 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53044 PyObject *resultobj = 0;
53045 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53046 int arg2 ;
53047 void *argp1 = 0 ;
53048 int res1 = 0 ;
53049 int val2 ;
53050 int ecode2 = 0 ;
53051 PyObject * obj0 = 0 ;
53052 PyObject * obj1 = 0 ;
53053 char * kwnames[] = {
53054 (char *) "self",(char *) "gap", NULL
53055 };
53056
53057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
53058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53059 if (!SWIG_IsOK(res1)) {
53060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53061 }
53062 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53063 ecode2 = SWIG_AsVal_int(obj1, &val2);
53064 if (!SWIG_IsOK(ecode2)) {
53065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
53066 }
53067 arg2 = static_cast< int >(val2);
53068 {
53069 PyThreadState* __tstate = wxPyBeginAllowThreads();
53070 (arg1)->SetHGap(arg2);
53071 wxPyEndAllowThreads(__tstate);
53072 if (PyErr_Occurred()) SWIG_fail;
53073 }
53074 resultobj = SWIG_Py_Void();
53075 return resultobj;
53076 fail:
53077 return NULL;
53078 }
53079
53080
53081 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53082 PyObject *resultobj = 0;
53083 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53084 int result;
53085 void *argp1 = 0 ;
53086 int res1 = 0 ;
53087 PyObject *swig_obj[1] ;
53088
53089 if (!args) SWIG_fail;
53090 swig_obj[0] = args;
53091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53092 if (!SWIG_IsOK(res1)) {
53093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53094 }
53095 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53096 {
53097 PyThreadState* __tstate = wxPyBeginAllowThreads();
53098 result = (int)(arg1)->GetCols();
53099 wxPyEndAllowThreads(__tstate);
53100 if (PyErr_Occurred()) SWIG_fail;
53101 }
53102 resultobj = SWIG_From_int(static_cast< int >(result));
53103 return resultobj;
53104 fail:
53105 return NULL;
53106 }
53107
53108
53109 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53110 PyObject *resultobj = 0;
53111 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53112 int result;
53113 void *argp1 = 0 ;
53114 int res1 = 0 ;
53115 PyObject *swig_obj[1] ;
53116
53117 if (!args) SWIG_fail;
53118 swig_obj[0] = args;
53119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53120 if (!SWIG_IsOK(res1)) {
53121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53122 }
53123 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53124 {
53125 PyThreadState* __tstate = wxPyBeginAllowThreads();
53126 result = (int)(arg1)->GetRows();
53127 wxPyEndAllowThreads(__tstate);
53128 if (PyErr_Occurred()) SWIG_fail;
53129 }
53130 resultobj = SWIG_From_int(static_cast< int >(result));
53131 return resultobj;
53132 fail:
53133 return NULL;
53134 }
53135
53136
53137 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53138 PyObject *resultobj = 0;
53139 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53140 int result;
53141 void *argp1 = 0 ;
53142 int res1 = 0 ;
53143 PyObject *swig_obj[1] ;
53144
53145 if (!args) SWIG_fail;
53146 swig_obj[0] = args;
53147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53148 if (!SWIG_IsOK(res1)) {
53149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53150 }
53151 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53152 {
53153 PyThreadState* __tstate = wxPyBeginAllowThreads();
53154 result = (int)(arg1)->GetVGap();
53155 wxPyEndAllowThreads(__tstate);
53156 if (PyErr_Occurred()) SWIG_fail;
53157 }
53158 resultobj = SWIG_From_int(static_cast< int >(result));
53159 return resultobj;
53160 fail:
53161 return NULL;
53162 }
53163
53164
53165 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53166 PyObject *resultobj = 0;
53167 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53168 int result;
53169 void *argp1 = 0 ;
53170 int res1 = 0 ;
53171 PyObject *swig_obj[1] ;
53172
53173 if (!args) SWIG_fail;
53174 swig_obj[0] = args;
53175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53176 if (!SWIG_IsOK(res1)) {
53177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53178 }
53179 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53180 {
53181 PyThreadState* __tstate = wxPyBeginAllowThreads();
53182 result = (int)(arg1)->GetHGap();
53183 wxPyEndAllowThreads(__tstate);
53184 if (PyErr_Occurred()) SWIG_fail;
53185 }
53186 resultobj = SWIG_From_int(static_cast< int >(result));
53187 return resultobj;
53188 fail:
53189 return NULL;
53190 }
53191
53192
53193 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53194 PyObject *obj;
53195 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53196 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
53197 return SWIG_Py_Void();
53198 }
53199
53200 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53201 return SWIG_Python_InitShadowInstance(args);
53202 }
53203
53204 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53205 PyObject *resultobj = 0;
53206 int arg1 = (int) 1 ;
53207 int arg2 = (int) 0 ;
53208 int arg3 = (int) 0 ;
53209 int arg4 = (int) 0 ;
53210 wxFlexGridSizer *result = 0 ;
53211 int val1 ;
53212 int ecode1 = 0 ;
53213 int val2 ;
53214 int ecode2 = 0 ;
53215 int val3 ;
53216 int ecode3 = 0 ;
53217 int val4 ;
53218 int ecode4 = 0 ;
53219 PyObject * obj0 = 0 ;
53220 PyObject * obj1 = 0 ;
53221 PyObject * obj2 = 0 ;
53222 PyObject * obj3 = 0 ;
53223 char * kwnames[] = {
53224 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
53225 };
53226
53227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53228 if (obj0) {
53229 ecode1 = SWIG_AsVal_int(obj0, &val1);
53230 if (!SWIG_IsOK(ecode1)) {
53231 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
53232 }
53233 arg1 = static_cast< int >(val1);
53234 }
53235 if (obj1) {
53236 ecode2 = SWIG_AsVal_int(obj1, &val2);
53237 if (!SWIG_IsOK(ecode2)) {
53238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
53239 }
53240 arg2 = static_cast< int >(val2);
53241 }
53242 if (obj2) {
53243 ecode3 = SWIG_AsVal_int(obj2, &val3);
53244 if (!SWIG_IsOK(ecode3)) {
53245 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
53246 }
53247 arg3 = static_cast< int >(val3);
53248 }
53249 if (obj3) {
53250 ecode4 = SWIG_AsVal_int(obj3, &val4);
53251 if (!SWIG_IsOK(ecode4)) {
53252 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
53253 }
53254 arg4 = static_cast< int >(val4);
53255 }
53256 {
53257 PyThreadState* __tstate = wxPyBeginAllowThreads();
53258 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
53259 wxPyEndAllowThreads(__tstate);
53260 if (PyErr_Occurred()) SWIG_fail;
53261 }
53262 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
53263 return resultobj;
53264 fail:
53265 return NULL;
53266 }
53267
53268
53269 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53270 PyObject *resultobj = 0;
53271 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53272 size_t arg2 ;
53273 int arg3 = (int) 0 ;
53274 void *argp1 = 0 ;
53275 int res1 = 0 ;
53276 size_t val2 ;
53277 int ecode2 = 0 ;
53278 int val3 ;
53279 int ecode3 = 0 ;
53280 PyObject * obj0 = 0 ;
53281 PyObject * obj1 = 0 ;
53282 PyObject * obj2 = 0 ;
53283 char * kwnames[] = {
53284 (char *) "self",(char *) "idx",(char *) "proportion", NULL
53285 };
53286
53287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53289 if (!SWIG_IsOK(res1)) {
53290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53291 }
53292 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53293 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53294 if (!SWIG_IsOK(ecode2)) {
53295 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
53296 }
53297 arg2 = static_cast< size_t >(val2);
53298 if (obj2) {
53299 ecode3 = SWIG_AsVal_int(obj2, &val3);
53300 if (!SWIG_IsOK(ecode3)) {
53301 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
53302 }
53303 arg3 = static_cast< int >(val3);
53304 }
53305 {
53306 PyThreadState* __tstate = wxPyBeginAllowThreads();
53307 (arg1)->AddGrowableRow(arg2,arg3);
53308 wxPyEndAllowThreads(__tstate);
53309 if (PyErr_Occurred()) SWIG_fail;
53310 }
53311 resultobj = SWIG_Py_Void();
53312 return resultobj;
53313 fail:
53314 return NULL;
53315 }
53316
53317
53318 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53319 PyObject *resultobj = 0;
53320 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53321 size_t arg2 ;
53322 void *argp1 = 0 ;
53323 int res1 = 0 ;
53324 size_t val2 ;
53325 int ecode2 = 0 ;
53326 PyObject * obj0 = 0 ;
53327 PyObject * obj1 = 0 ;
53328 char * kwnames[] = {
53329 (char *) "self",(char *) "idx", NULL
53330 };
53331
53332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
53333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53334 if (!SWIG_IsOK(res1)) {
53335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53336 }
53337 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53338 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53339 if (!SWIG_IsOK(ecode2)) {
53340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
53341 }
53342 arg2 = static_cast< size_t >(val2);
53343 {
53344 PyThreadState* __tstate = wxPyBeginAllowThreads();
53345 (arg1)->RemoveGrowableRow(arg2);
53346 wxPyEndAllowThreads(__tstate);
53347 if (PyErr_Occurred()) SWIG_fail;
53348 }
53349 resultobj = SWIG_Py_Void();
53350 return resultobj;
53351 fail:
53352 return NULL;
53353 }
53354
53355
53356 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53357 PyObject *resultobj = 0;
53358 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53359 size_t arg2 ;
53360 int arg3 = (int) 0 ;
53361 void *argp1 = 0 ;
53362 int res1 = 0 ;
53363 size_t val2 ;
53364 int ecode2 = 0 ;
53365 int val3 ;
53366 int ecode3 = 0 ;
53367 PyObject * obj0 = 0 ;
53368 PyObject * obj1 = 0 ;
53369 PyObject * obj2 = 0 ;
53370 char * kwnames[] = {
53371 (char *) "self",(char *) "idx",(char *) "proportion", NULL
53372 };
53373
53374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53376 if (!SWIG_IsOK(res1)) {
53377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53378 }
53379 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53380 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53381 if (!SWIG_IsOK(ecode2)) {
53382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
53383 }
53384 arg2 = static_cast< size_t >(val2);
53385 if (obj2) {
53386 ecode3 = SWIG_AsVal_int(obj2, &val3);
53387 if (!SWIG_IsOK(ecode3)) {
53388 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
53389 }
53390 arg3 = static_cast< int >(val3);
53391 }
53392 {
53393 PyThreadState* __tstate = wxPyBeginAllowThreads();
53394 (arg1)->AddGrowableCol(arg2,arg3);
53395 wxPyEndAllowThreads(__tstate);
53396 if (PyErr_Occurred()) SWIG_fail;
53397 }
53398 resultobj = SWIG_Py_Void();
53399 return resultobj;
53400 fail:
53401 return NULL;
53402 }
53403
53404
53405 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53406 PyObject *resultobj = 0;
53407 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53408 size_t arg2 ;
53409 void *argp1 = 0 ;
53410 int res1 = 0 ;
53411 size_t val2 ;
53412 int ecode2 = 0 ;
53413 PyObject * obj0 = 0 ;
53414 PyObject * obj1 = 0 ;
53415 char * kwnames[] = {
53416 (char *) "self",(char *) "idx", NULL
53417 };
53418
53419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
53420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53421 if (!SWIG_IsOK(res1)) {
53422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53423 }
53424 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53425 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53426 if (!SWIG_IsOK(ecode2)) {
53427 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
53428 }
53429 arg2 = static_cast< size_t >(val2);
53430 {
53431 PyThreadState* __tstate = wxPyBeginAllowThreads();
53432 (arg1)->RemoveGrowableCol(arg2);
53433 wxPyEndAllowThreads(__tstate);
53434 if (PyErr_Occurred()) SWIG_fail;
53435 }
53436 resultobj = SWIG_Py_Void();
53437 return resultobj;
53438 fail:
53439 return NULL;
53440 }
53441
53442
53443 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53444 PyObject *resultobj = 0;
53445 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53446 int arg2 ;
53447 void *argp1 = 0 ;
53448 int res1 = 0 ;
53449 int val2 ;
53450 int ecode2 = 0 ;
53451 PyObject * obj0 = 0 ;
53452 PyObject * obj1 = 0 ;
53453 char * kwnames[] = {
53454 (char *) "self",(char *) "direction", NULL
53455 };
53456
53457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
53458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53459 if (!SWIG_IsOK(res1)) {
53460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53461 }
53462 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53463 ecode2 = SWIG_AsVal_int(obj1, &val2);
53464 if (!SWIG_IsOK(ecode2)) {
53465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
53466 }
53467 arg2 = static_cast< int >(val2);
53468 {
53469 PyThreadState* __tstate = wxPyBeginAllowThreads();
53470 (arg1)->SetFlexibleDirection(arg2);
53471 wxPyEndAllowThreads(__tstate);
53472 if (PyErr_Occurred()) SWIG_fail;
53473 }
53474 resultobj = SWIG_Py_Void();
53475 return resultobj;
53476 fail:
53477 return NULL;
53478 }
53479
53480
53481 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53482 PyObject *resultobj = 0;
53483 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53484 int result;
53485 void *argp1 = 0 ;
53486 int res1 = 0 ;
53487 PyObject *swig_obj[1] ;
53488
53489 if (!args) SWIG_fail;
53490 swig_obj[0] = args;
53491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53492 if (!SWIG_IsOK(res1)) {
53493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53494 }
53495 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53496 {
53497 PyThreadState* __tstate = wxPyBeginAllowThreads();
53498 result = (int)(arg1)->GetFlexibleDirection();
53499 wxPyEndAllowThreads(__tstate);
53500 if (PyErr_Occurred()) SWIG_fail;
53501 }
53502 resultobj = SWIG_From_int(static_cast< int >(result));
53503 return resultobj;
53504 fail:
53505 return NULL;
53506 }
53507
53508
53509 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53510 PyObject *resultobj = 0;
53511 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53512 wxFlexSizerGrowMode arg2 ;
53513 void *argp1 = 0 ;
53514 int res1 = 0 ;
53515 int val2 ;
53516 int ecode2 = 0 ;
53517 PyObject * obj0 = 0 ;
53518 PyObject * obj1 = 0 ;
53519 char * kwnames[] = {
53520 (char *) "self",(char *) "mode", NULL
53521 };
53522
53523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
53524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53525 if (!SWIG_IsOK(res1)) {
53526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53527 }
53528 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53529 ecode2 = SWIG_AsVal_int(obj1, &val2);
53530 if (!SWIG_IsOK(ecode2)) {
53531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
53532 }
53533 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
53534 {
53535 PyThreadState* __tstate = wxPyBeginAllowThreads();
53536 (arg1)->SetNonFlexibleGrowMode(arg2);
53537 wxPyEndAllowThreads(__tstate);
53538 if (PyErr_Occurred()) SWIG_fail;
53539 }
53540 resultobj = SWIG_Py_Void();
53541 return resultobj;
53542 fail:
53543 return NULL;
53544 }
53545
53546
53547 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53548 PyObject *resultobj = 0;
53549 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53550 wxFlexSizerGrowMode result;
53551 void *argp1 = 0 ;
53552 int res1 = 0 ;
53553 PyObject *swig_obj[1] ;
53554
53555 if (!args) SWIG_fail;
53556 swig_obj[0] = args;
53557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53558 if (!SWIG_IsOK(res1)) {
53559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53560 }
53561 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53562 {
53563 PyThreadState* __tstate = wxPyBeginAllowThreads();
53564 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
53565 wxPyEndAllowThreads(__tstate);
53566 if (PyErr_Occurred()) SWIG_fail;
53567 }
53568 resultobj = SWIG_From_int(static_cast< int >(result));
53569 return resultobj;
53570 fail:
53571 return NULL;
53572 }
53573
53574
53575 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53576 PyObject *resultobj = 0;
53577 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53578 wxArrayInt *result = 0 ;
53579 void *argp1 = 0 ;
53580 int res1 = 0 ;
53581 PyObject *swig_obj[1] ;
53582
53583 if (!args) SWIG_fail;
53584 swig_obj[0] = args;
53585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53586 if (!SWIG_IsOK(res1)) {
53587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
53588 }
53589 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53590 {
53591 PyThreadState* __tstate = wxPyBeginAllowThreads();
53592 {
53593 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
53594 result = (wxArrayInt *) &_result_ref;
53595 }
53596 wxPyEndAllowThreads(__tstate);
53597 if (PyErr_Occurred()) SWIG_fail;
53598 }
53599 {
53600 resultobj = wxArrayInt2PyList_helper(*result);
53601 }
53602 return resultobj;
53603 fail:
53604 return NULL;
53605 }
53606
53607
53608 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53609 PyObject *resultobj = 0;
53610 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53611 wxArrayInt *result = 0 ;
53612 void *argp1 = 0 ;
53613 int res1 = 0 ;
53614 PyObject *swig_obj[1] ;
53615
53616 if (!args) SWIG_fail;
53617 swig_obj[0] = args;
53618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53619 if (!SWIG_IsOK(res1)) {
53620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
53621 }
53622 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53623 {
53624 PyThreadState* __tstate = wxPyBeginAllowThreads();
53625 {
53626 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
53627 result = (wxArrayInt *) &_result_ref;
53628 }
53629 wxPyEndAllowThreads(__tstate);
53630 if (PyErr_Occurred()) SWIG_fail;
53631 }
53632 {
53633 resultobj = wxArrayInt2PyList_helper(*result);
53634 }
53635 return resultobj;
53636 fail:
53637 return NULL;
53638 }
53639
53640
53641 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53642 PyObject *obj;
53643 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53644 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
53645 return SWIG_Py_Void();
53646 }
53647
53648 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53649 return SWIG_Python_InitShadowInstance(args);
53650 }
53651
53652 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53653 PyObject *resultobj = 0;
53654 wxStdDialogButtonSizer *result = 0 ;
53655
53656 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
53657 {
53658 PyThreadState* __tstate = wxPyBeginAllowThreads();
53659 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
53660 wxPyEndAllowThreads(__tstate);
53661 if (PyErr_Occurred()) SWIG_fail;
53662 }
53663 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
53664 return resultobj;
53665 fail:
53666 return NULL;
53667 }
53668
53669
53670 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53671 PyObject *resultobj = 0;
53672 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53673 wxButton *arg2 = (wxButton *) 0 ;
53674 void *argp1 = 0 ;
53675 int res1 = 0 ;
53676 void *argp2 = 0 ;
53677 int res2 = 0 ;
53678 PyObject * obj0 = 0 ;
53679 PyObject * obj1 = 0 ;
53680 char * kwnames[] = {
53681 (char *) "self",(char *) "button", NULL
53682 };
53683
53684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
53685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53686 if (!SWIG_IsOK(res1)) {
53687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
53688 }
53689 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53690 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
53691 if (!SWIG_IsOK(res2)) {
53692 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
53693 }
53694 arg2 = reinterpret_cast< wxButton * >(argp2);
53695 {
53696 PyThreadState* __tstate = wxPyBeginAllowThreads();
53697 (arg1)->AddButton(arg2);
53698 wxPyEndAllowThreads(__tstate);
53699 if (PyErr_Occurred()) SWIG_fail;
53700 }
53701 resultobj = SWIG_Py_Void();
53702 return resultobj;
53703 fail:
53704 return NULL;
53705 }
53706
53707
53708 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53709 PyObject *resultobj = 0;
53710 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53711 void *argp1 = 0 ;
53712 int res1 = 0 ;
53713 PyObject *swig_obj[1] ;
53714
53715 if (!args) SWIG_fail;
53716 swig_obj[0] = args;
53717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53718 if (!SWIG_IsOK(res1)) {
53719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
53720 }
53721 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53722 {
53723 PyThreadState* __tstate = wxPyBeginAllowThreads();
53724 (arg1)->Realize();
53725 wxPyEndAllowThreads(__tstate);
53726 if (PyErr_Occurred()) SWIG_fail;
53727 }
53728 resultobj = SWIG_Py_Void();
53729 return resultobj;
53730 fail:
53731 return NULL;
53732 }
53733
53734
53735 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53736 PyObject *resultobj = 0;
53737 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53738 wxButton *arg2 = (wxButton *) 0 ;
53739 void *argp1 = 0 ;
53740 int res1 = 0 ;
53741 void *argp2 = 0 ;
53742 int res2 = 0 ;
53743 PyObject * obj0 = 0 ;
53744 PyObject * obj1 = 0 ;
53745 char * kwnames[] = {
53746 (char *) "self",(char *) "button", NULL
53747 };
53748
53749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
53750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53751 if (!SWIG_IsOK(res1)) {
53752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
53753 }
53754 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53755 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
53756 if (!SWIG_IsOK(res2)) {
53757 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
53758 }
53759 arg2 = reinterpret_cast< wxButton * >(argp2);
53760 {
53761 PyThreadState* __tstate = wxPyBeginAllowThreads();
53762 (arg1)->SetAffirmativeButton(arg2);
53763 wxPyEndAllowThreads(__tstate);
53764 if (PyErr_Occurred()) SWIG_fail;
53765 }
53766 resultobj = SWIG_Py_Void();
53767 return resultobj;
53768 fail:
53769 return NULL;
53770 }
53771
53772
53773 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53774 PyObject *resultobj = 0;
53775 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53776 wxButton *arg2 = (wxButton *) 0 ;
53777 void *argp1 = 0 ;
53778 int res1 = 0 ;
53779 void *argp2 = 0 ;
53780 int res2 = 0 ;
53781 PyObject * obj0 = 0 ;
53782 PyObject * obj1 = 0 ;
53783 char * kwnames[] = {
53784 (char *) "self",(char *) "button", NULL
53785 };
53786
53787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
53788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53789 if (!SWIG_IsOK(res1)) {
53790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
53791 }
53792 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53793 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
53794 if (!SWIG_IsOK(res2)) {
53795 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
53796 }
53797 arg2 = reinterpret_cast< wxButton * >(argp2);
53798 {
53799 PyThreadState* __tstate = wxPyBeginAllowThreads();
53800 (arg1)->SetNegativeButton(arg2);
53801 wxPyEndAllowThreads(__tstate);
53802 if (PyErr_Occurred()) SWIG_fail;
53803 }
53804 resultobj = SWIG_Py_Void();
53805 return resultobj;
53806 fail:
53807 return NULL;
53808 }
53809
53810
53811 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53812 PyObject *resultobj = 0;
53813 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53814 wxButton *arg2 = (wxButton *) 0 ;
53815 void *argp1 = 0 ;
53816 int res1 = 0 ;
53817 void *argp2 = 0 ;
53818 int res2 = 0 ;
53819 PyObject * obj0 = 0 ;
53820 PyObject * obj1 = 0 ;
53821 char * kwnames[] = {
53822 (char *) "self",(char *) "button", NULL
53823 };
53824
53825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
53826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53827 if (!SWIG_IsOK(res1)) {
53828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
53829 }
53830 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53831 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
53832 if (!SWIG_IsOK(res2)) {
53833 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
53834 }
53835 arg2 = reinterpret_cast< wxButton * >(argp2);
53836 {
53837 PyThreadState* __tstate = wxPyBeginAllowThreads();
53838 (arg1)->SetCancelButton(arg2);
53839 wxPyEndAllowThreads(__tstate);
53840 if (PyErr_Occurred()) SWIG_fail;
53841 }
53842 resultobj = SWIG_Py_Void();
53843 return resultobj;
53844 fail:
53845 return NULL;
53846 }
53847
53848
53849 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53850 PyObject *resultobj = 0;
53851 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53852 wxButton *result = 0 ;
53853 void *argp1 = 0 ;
53854 int res1 = 0 ;
53855 PyObject *swig_obj[1] ;
53856
53857 if (!args) SWIG_fail;
53858 swig_obj[0] = args;
53859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53860 if (!SWIG_IsOK(res1)) {
53861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
53862 }
53863 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53864 {
53865 PyThreadState* __tstate = wxPyBeginAllowThreads();
53866 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
53867 wxPyEndAllowThreads(__tstate);
53868 if (PyErr_Occurred()) SWIG_fail;
53869 }
53870 {
53871 resultobj = wxPyMake_wxObject(result, (bool)0);
53872 }
53873 return resultobj;
53874 fail:
53875 return NULL;
53876 }
53877
53878
53879 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53880 PyObject *resultobj = 0;
53881 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53882 wxButton *result = 0 ;
53883 void *argp1 = 0 ;
53884 int res1 = 0 ;
53885 PyObject *swig_obj[1] ;
53886
53887 if (!args) SWIG_fail;
53888 swig_obj[0] = args;
53889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53890 if (!SWIG_IsOK(res1)) {
53891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
53892 }
53893 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53894 {
53895 PyThreadState* __tstate = wxPyBeginAllowThreads();
53896 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
53897 wxPyEndAllowThreads(__tstate);
53898 if (PyErr_Occurred()) SWIG_fail;
53899 }
53900 {
53901 resultobj = wxPyMake_wxObject(result, (bool)0);
53902 }
53903 return resultobj;
53904 fail:
53905 return NULL;
53906 }
53907
53908
53909 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53910 PyObject *resultobj = 0;
53911 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53912 wxButton *result = 0 ;
53913 void *argp1 = 0 ;
53914 int res1 = 0 ;
53915 PyObject *swig_obj[1] ;
53916
53917 if (!args) SWIG_fail;
53918 swig_obj[0] = args;
53919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53920 if (!SWIG_IsOK(res1)) {
53921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
53922 }
53923 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53924 {
53925 PyThreadState* __tstate = wxPyBeginAllowThreads();
53926 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
53927 wxPyEndAllowThreads(__tstate);
53928 if (PyErr_Occurred()) SWIG_fail;
53929 }
53930 {
53931 resultobj = wxPyMake_wxObject(result, (bool)0);
53932 }
53933 return resultobj;
53934 fail:
53935 return NULL;
53936 }
53937
53938
53939 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53940 PyObject *resultobj = 0;
53941 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53942 wxButton *result = 0 ;
53943 void *argp1 = 0 ;
53944 int res1 = 0 ;
53945 PyObject *swig_obj[1] ;
53946
53947 if (!args) SWIG_fail;
53948 swig_obj[0] = args;
53949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53950 if (!SWIG_IsOK(res1)) {
53951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
53952 }
53953 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53954 {
53955 PyThreadState* __tstate = wxPyBeginAllowThreads();
53956 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
53957 wxPyEndAllowThreads(__tstate);
53958 if (PyErr_Occurred()) SWIG_fail;
53959 }
53960 {
53961 resultobj = wxPyMake_wxObject(result, (bool)0);
53962 }
53963 return resultobj;
53964 fail:
53965 return NULL;
53966 }
53967
53968
53969 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53970 PyObject *resultobj = 0;
53971 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
53972 wxButton *result = 0 ;
53973 void *argp1 = 0 ;
53974 int res1 = 0 ;
53975 PyObject *swig_obj[1] ;
53976
53977 if (!args) SWIG_fail;
53978 swig_obj[0] = args;
53979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
53980 if (!SWIG_IsOK(res1)) {
53981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
53982 }
53983 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
53984 {
53985 PyThreadState* __tstate = wxPyBeginAllowThreads();
53986 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
53987 wxPyEndAllowThreads(__tstate);
53988 if (PyErr_Occurred()) SWIG_fail;
53989 }
53990 {
53991 resultobj = wxPyMake_wxObject(result, (bool)0);
53992 }
53993 return resultobj;
53994 fail:
53995 return NULL;
53996 }
53997
53998
53999 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54000 PyObject *obj;
54001 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54002 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
54003 return SWIG_Py_Void();
54004 }
54005
54006 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54007 return SWIG_Python_InitShadowInstance(args);
54008 }
54009
54010 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54011 PyObject *resultobj = 0;
54012 int arg1 = (int) 0 ;
54013 int arg2 = (int) 0 ;
54014 wxGBPosition *result = 0 ;
54015 int val1 ;
54016 int ecode1 = 0 ;
54017 int val2 ;
54018 int ecode2 = 0 ;
54019 PyObject * obj0 = 0 ;
54020 PyObject * obj1 = 0 ;
54021 char * kwnames[] = {
54022 (char *) "row",(char *) "col", NULL
54023 };
54024
54025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
54026 if (obj0) {
54027 ecode1 = SWIG_AsVal_int(obj0, &val1);
54028 if (!SWIG_IsOK(ecode1)) {
54029 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
54030 }
54031 arg1 = static_cast< int >(val1);
54032 }
54033 if (obj1) {
54034 ecode2 = SWIG_AsVal_int(obj1, &val2);
54035 if (!SWIG_IsOK(ecode2)) {
54036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
54037 }
54038 arg2 = static_cast< int >(val2);
54039 }
54040 {
54041 PyThreadState* __tstate = wxPyBeginAllowThreads();
54042 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
54043 wxPyEndAllowThreads(__tstate);
54044 if (PyErr_Occurred()) SWIG_fail;
54045 }
54046 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
54047 return resultobj;
54048 fail:
54049 return NULL;
54050 }
54051
54052
54053 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54054 PyObject *resultobj = 0;
54055 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54056 void *argp1 = 0 ;
54057 int res1 = 0 ;
54058 PyObject *swig_obj[1] ;
54059
54060 if (!args) SWIG_fail;
54061 swig_obj[0] = args;
54062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
54063 if (!SWIG_IsOK(res1)) {
54064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54065 }
54066 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54067 {
54068 PyThreadState* __tstate = wxPyBeginAllowThreads();
54069 delete arg1;
54070
54071 wxPyEndAllowThreads(__tstate);
54072 if (PyErr_Occurred()) SWIG_fail;
54073 }
54074 resultobj = SWIG_Py_Void();
54075 return resultobj;
54076 fail:
54077 return NULL;
54078 }
54079
54080
54081 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54082 PyObject *resultobj = 0;
54083 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54084 int result;
54085 void *argp1 = 0 ;
54086 int res1 = 0 ;
54087 PyObject *swig_obj[1] ;
54088
54089 if (!args) SWIG_fail;
54090 swig_obj[0] = args;
54091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54092 if (!SWIG_IsOK(res1)) {
54093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
54094 }
54095 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54096 {
54097 PyThreadState* __tstate = wxPyBeginAllowThreads();
54098 result = (int)((wxGBPosition const *)arg1)->GetRow();
54099 wxPyEndAllowThreads(__tstate);
54100 if (PyErr_Occurred()) SWIG_fail;
54101 }
54102 resultobj = SWIG_From_int(static_cast< int >(result));
54103 return resultobj;
54104 fail:
54105 return NULL;
54106 }
54107
54108
54109 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54110 PyObject *resultobj = 0;
54111 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54112 int result;
54113 void *argp1 = 0 ;
54114 int res1 = 0 ;
54115 PyObject *swig_obj[1] ;
54116
54117 if (!args) SWIG_fail;
54118 swig_obj[0] = args;
54119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54120 if (!SWIG_IsOK(res1)) {
54121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
54122 }
54123 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54124 {
54125 PyThreadState* __tstate = wxPyBeginAllowThreads();
54126 result = (int)((wxGBPosition const *)arg1)->GetCol();
54127 wxPyEndAllowThreads(__tstate);
54128 if (PyErr_Occurred()) SWIG_fail;
54129 }
54130 resultobj = SWIG_From_int(static_cast< int >(result));
54131 return resultobj;
54132 fail:
54133 return NULL;
54134 }
54135
54136
54137 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54138 PyObject *resultobj = 0;
54139 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54140 int arg2 ;
54141 void *argp1 = 0 ;
54142 int res1 = 0 ;
54143 int val2 ;
54144 int ecode2 = 0 ;
54145 PyObject * obj0 = 0 ;
54146 PyObject * obj1 = 0 ;
54147 char * kwnames[] = {
54148 (char *) "self",(char *) "row", NULL
54149 };
54150
54151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
54152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54153 if (!SWIG_IsOK(res1)) {
54154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54155 }
54156 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54157 ecode2 = SWIG_AsVal_int(obj1, &val2);
54158 if (!SWIG_IsOK(ecode2)) {
54159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
54160 }
54161 arg2 = static_cast< int >(val2);
54162 {
54163 PyThreadState* __tstate = wxPyBeginAllowThreads();
54164 (arg1)->SetRow(arg2);
54165 wxPyEndAllowThreads(__tstate);
54166 if (PyErr_Occurred()) SWIG_fail;
54167 }
54168 resultobj = SWIG_Py_Void();
54169 return resultobj;
54170 fail:
54171 return NULL;
54172 }
54173
54174
54175 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54176 PyObject *resultobj = 0;
54177 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54178 int arg2 ;
54179 void *argp1 = 0 ;
54180 int res1 = 0 ;
54181 int val2 ;
54182 int ecode2 = 0 ;
54183 PyObject * obj0 = 0 ;
54184 PyObject * obj1 = 0 ;
54185 char * kwnames[] = {
54186 (char *) "self",(char *) "col", NULL
54187 };
54188
54189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
54190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54191 if (!SWIG_IsOK(res1)) {
54192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54193 }
54194 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54195 ecode2 = SWIG_AsVal_int(obj1, &val2);
54196 if (!SWIG_IsOK(ecode2)) {
54197 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
54198 }
54199 arg2 = static_cast< int >(val2);
54200 {
54201 PyThreadState* __tstate = wxPyBeginAllowThreads();
54202 (arg1)->SetCol(arg2);
54203 wxPyEndAllowThreads(__tstate);
54204 if (PyErr_Occurred()) SWIG_fail;
54205 }
54206 resultobj = SWIG_Py_Void();
54207 return resultobj;
54208 fail:
54209 return NULL;
54210 }
54211
54212
54213 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54214 PyObject *resultobj = 0;
54215 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54216 PyObject *arg2 = (PyObject *) 0 ;
54217 bool result;
54218 void *argp1 = 0 ;
54219 int res1 = 0 ;
54220 PyObject * obj0 = 0 ;
54221 PyObject * obj1 = 0 ;
54222 char * kwnames[] = {
54223 (char *) "self",(char *) "other", NULL
54224 };
54225
54226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
54227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54228 if (!SWIG_IsOK(res1)) {
54229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54230 }
54231 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54232 arg2 = obj1;
54233 {
54234 result = (bool)wxGBPosition___eq__(arg1,arg2);
54235 if (PyErr_Occurred()) SWIG_fail;
54236 }
54237 {
54238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54239 }
54240 return resultobj;
54241 fail:
54242 return NULL;
54243 }
54244
54245
54246 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54247 PyObject *resultobj = 0;
54248 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54249 PyObject *arg2 = (PyObject *) 0 ;
54250 bool result;
54251 void *argp1 = 0 ;
54252 int res1 = 0 ;
54253 PyObject * obj0 = 0 ;
54254 PyObject * obj1 = 0 ;
54255 char * kwnames[] = {
54256 (char *) "self",(char *) "other", NULL
54257 };
54258
54259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
54260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54261 if (!SWIG_IsOK(res1)) {
54262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54263 }
54264 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54265 arg2 = obj1;
54266 {
54267 result = (bool)wxGBPosition___ne__(arg1,arg2);
54268 if (PyErr_Occurred()) SWIG_fail;
54269 }
54270 {
54271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54272 }
54273 return resultobj;
54274 fail:
54275 return NULL;
54276 }
54277
54278
54279 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54280 PyObject *resultobj = 0;
54281 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54282 int arg2 = (int) 0 ;
54283 int arg3 = (int) 0 ;
54284 void *argp1 = 0 ;
54285 int res1 = 0 ;
54286 int val2 ;
54287 int ecode2 = 0 ;
54288 int val3 ;
54289 int ecode3 = 0 ;
54290 PyObject * obj0 = 0 ;
54291 PyObject * obj1 = 0 ;
54292 PyObject * obj2 = 0 ;
54293 char * kwnames[] = {
54294 (char *) "self",(char *) "row",(char *) "col", NULL
54295 };
54296
54297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54299 if (!SWIG_IsOK(res1)) {
54300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54301 }
54302 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54303 if (obj1) {
54304 ecode2 = SWIG_AsVal_int(obj1, &val2);
54305 if (!SWIG_IsOK(ecode2)) {
54306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
54307 }
54308 arg2 = static_cast< int >(val2);
54309 }
54310 if (obj2) {
54311 ecode3 = SWIG_AsVal_int(obj2, &val3);
54312 if (!SWIG_IsOK(ecode3)) {
54313 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
54314 }
54315 arg3 = static_cast< int >(val3);
54316 }
54317 {
54318 PyThreadState* __tstate = wxPyBeginAllowThreads();
54319 wxGBPosition_Set(arg1,arg2,arg3);
54320 wxPyEndAllowThreads(__tstate);
54321 if (PyErr_Occurred()) SWIG_fail;
54322 }
54323 resultobj = SWIG_Py_Void();
54324 return resultobj;
54325 fail:
54326 return NULL;
54327 }
54328
54329
54330 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54331 PyObject *resultobj = 0;
54332 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54333 PyObject *result = 0 ;
54334 void *argp1 = 0 ;
54335 int res1 = 0 ;
54336 PyObject *swig_obj[1] ;
54337
54338 if (!args) SWIG_fail;
54339 swig_obj[0] = args;
54340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54341 if (!SWIG_IsOK(res1)) {
54342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54343 }
54344 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54345 {
54346 PyThreadState* __tstate = wxPyBeginAllowThreads();
54347 result = (PyObject *)wxGBPosition_Get(arg1);
54348 wxPyEndAllowThreads(__tstate);
54349 if (PyErr_Occurred()) SWIG_fail;
54350 }
54351 resultobj = result;
54352 return resultobj;
54353 fail:
54354 return NULL;
54355 }
54356
54357
54358 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54359 PyObject *obj;
54360 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54361 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
54362 return SWIG_Py_Void();
54363 }
54364
54365 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54366 return SWIG_Python_InitShadowInstance(args);
54367 }
54368
54369 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54370 PyObject *resultobj = 0;
54371 int arg1 = (int) 1 ;
54372 int arg2 = (int) 1 ;
54373 wxGBSpan *result = 0 ;
54374 int val1 ;
54375 int ecode1 = 0 ;
54376 int val2 ;
54377 int ecode2 = 0 ;
54378 PyObject * obj0 = 0 ;
54379 PyObject * obj1 = 0 ;
54380 char * kwnames[] = {
54381 (char *) "rowspan",(char *) "colspan", NULL
54382 };
54383
54384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
54385 if (obj0) {
54386 ecode1 = SWIG_AsVal_int(obj0, &val1);
54387 if (!SWIG_IsOK(ecode1)) {
54388 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
54389 }
54390 arg1 = static_cast< int >(val1);
54391 }
54392 if (obj1) {
54393 ecode2 = SWIG_AsVal_int(obj1, &val2);
54394 if (!SWIG_IsOK(ecode2)) {
54395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
54396 }
54397 arg2 = static_cast< int >(val2);
54398 }
54399 {
54400 PyThreadState* __tstate = wxPyBeginAllowThreads();
54401 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
54402 wxPyEndAllowThreads(__tstate);
54403 if (PyErr_Occurred()) SWIG_fail;
54404 }
54405 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
54406 return resultobj;
54407 fail:
54408 return NULL;
54409 }
54410
54411
54412 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54413 PyObject *resultobj = 0;
54414 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54415 void *argp1 = 0 ;
54416 int res1 = 0 ;
54417 PyObject *swig_obj[1] ;
54418
54419 if (!args) SWIG_fail;
54420 swig_obj[0] = args;
54421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
54422 if (!SWIG_IsOK(res1)) {
54423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54424 }
54425 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54426 {
54427 PyThreadState* __tstate = wxPyBeginAllowThreads();
54428 delete arg1;
54429
54430 wxPyEndAllowThreads(__tstate);
54431 if (PyErr_Occurred()) SWIG_fail;
54432 }
54433 resultobj = SWIG_Py_Void();
54434 return resultobj;
54435 fail:
54436 return NULL;
54437 }
54438
54439
54440 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54441 PyObject *resultobj = 0;
54442 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54443 int result;
54444 void *argp1 = 0 ;
54445 int res1 = 0 ;
54446 PyObject *swig_obj[1] ;
54447
54448 if (!args) SWIG_fail;
54449 swig_obj[0] = args;
54450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54451 if (!SWIG_IsOK(res1)) {
54452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
54453 }
54454 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54455 {
54456 PyThreadState* __tstate = wxPyBeginAllowThreads();
54457 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
54458 wxPyEndAllowThreads(__tstate);
54459 if (PyErr_Occurred()) SWIG_fail;
54460 }
54461 resultobj = SWIG_From_int(static_cast< int >(result));
54462 return resultobj;
54463 fail:
54464 return NULL;
54465 }
54466
54467
54468 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54469 PyObject *resultobj = 0;
54470 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54471 int result;
54472 void *argp1 = 0 ;
54473 int res1 = 0 ;
54474 PyObject *swig_obj[1] ;
54475
54476 if (!args) SWIG_fail;
54477 swig_obj[0] = args;
54478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54479 if (!SWIG_IsOK(res1)) {
54480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
54481 }
54482 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54483 {
54484 PyThreadState* __tstate = wxPyBeginAllowThreads();
54485 result = (int)((wxGBSpan const *)arg1)->GetColspan();
54486 wxPyEndAllowThreads(__tstate);
54487 if (PyErr_Occurred()) SWIG_fail;
54488 }
54489 resultobj = SWIG_From_int(static_cast< int >(result));
54490 return resultobj;
54491 fail:
54492 return NULL;
54493 }
54494
54495
54496 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54497 PyObject *resultobj = 0;
54498 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54499 int arg2 ;
54500 void *argp1 = 0 ;
54501 int res1 = 0 ;
54502 int val2 ;
54503 int ecode2 = 0 ;
54504 PyObject * obj0 = 0 ;
54505 PyObject * obj1 = 0 ;
54506 char * kwnames[] = {
54507 (char *) "self",(char *) "rowspan", NULL
54508 };
54509
54510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
54511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54512 if (!SWIG_IsOK(res1)) {
54513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54514 }
54515 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54516 ecode2 = SWIG_AsVal_int(obj1, &val2);
54517 if (!SWIG_IsOK(ecode2)) {
54518 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
54519 }
54520 arg2 = static_cast< int >(val2);
54521 {
54522 PyThreadState* __tstate = wxPyBeginAllowThreads();
54523 (arg1)->SetRowspan(arg2);
54524 wxPyEndAllowThreads(__tstate);
54525 if (PyErr_Occurred()) SWIG_fail;
54526 }
54527 resultobj = SWIG_Py_Void();
54528 return resultobj;
54529 fail:
54530 return NULL;
54531 }
54532
54533
54534 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54535 PyObject *resultobj = 0;
54536 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54537 int arg2 ;
54538 void *argp1 = 0 ;
54539 int res1 = 0 ;
54540 int val2 ;
54541 int ecode2 = 0 ;
54542 PyObject * obj0 = 0 ;
54543 PyObject * obj1 = 0 ;
54544 char * kwnames[] = {
54545 (char *) "self",(char *) "colspan", NULL
54546 };
54547
54548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
54549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54550 if (!SWIG_IsOK(res1)) {
54551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54552 }
54553 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54554 ecode2 = SWIG_AsVal_int(obj1, &val2);
54555 if (!SWIG_IsOK(ecode2)) {
54556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
54557 }
54558 arg2 = static_cast< int >(val2);
54559 {
54560 PyThreadState* __tstate = wxPyBeginAllowThreads();
54561 (arg1)->SetColspan(arg2);
54562 wxPyEndAllowThreads(__tstate);
54563 if (PyErr_Occurred()) SWIG_fail;
54564 }
54565 resultobj = SWIG_Py_Void();
54566 return resultobj;
54567 fail:
54568 return NULL;
54569 }
54570
54571
54572 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54573 PyObject *resultobj = 0;
54574 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54575 PyObject *arg2 = (PyObject *) 0 ;
54576 bool result;
54577 void *argp1 = 0 ;
54578 int res1 = 0 ;
54579 PyObject * obj0 = 0 ;
54580 PyObject * obj1 = 0 ;
54581 char * kwnames[] = {
54582 (char *) "self",(char *) "other", NULL
54583 };
54584
54585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
54586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54587 if (!SWIG_IsOK(res1)) {
54588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54589 }
54590 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54591 arg2 = obj1;
54592 {
54593 result = (bool)wxGBSpan___eq__(arg1,arg2);
54594 if (PyErr_Occurred()) SWIG_fail;
54595 }
54596 {
54597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54598 }
54599 return resultobj;
54600 fail:
54601 return NULL;
54602 }
54603
54604
54605 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54606 PyObject *resultobj = 0;
54607 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54608 PyObject *arg2 = (PyObject *) 0 ;
54609 bool result;
54610 void *argp1 = 0 ;
54611 int res1 = 0 ;
54612 PyObject * obj0 = 0 ;
54613 PyObject * obj1 = 0 ;
54614 char * kwnames[] = {
54615 (char *) "self",(char *) "other", NULL
54616 };
54617
54618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
54619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54620 if (!SWIG_IsOK(res1)) {
54621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54622 }
54623 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54624 arg2 = obj1;
54625 {
54626 result = (bool)wxGBSpan___ne__(arg1,arg2);
54627 if (PyErr_Occurred()) SWIG_fail;
54628 }
54629 {
54630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54631 }
54632 return resultobj;
54633 fail:
54634 return NULL;
54635 }
54636
54637
54638 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54639 PyObject *resultobj = 0;
54640 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54641 int arg2 = (int) 1 ;
54642 int arg3 = (int) 1 ;
54643 void *argp1 = 0 ;
54644 int res1 = 0 ;
54645 int val2 ;
54646 int ecode2 = 0 ;
54647 int val3 ;
54648 int ecode3 = 0 ;
54649 PyObject * obj0 = 0 ;
54650 PyObject * obj1 = 0 ;
54651 PyObject * obj2 = 0 ;
54652 char * kwnames[] = {
54653 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
54654 };
54655
54656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54658 if (!SWIG_IsOK(res1)) {
54659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54660 }
54661 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54662 if (obj1) {
54663 ecode2 = SWIG_AsVal_int(obj1, &val2);
54664 if (!SWIG_IsOK(ecode2)) {
54665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
54666 }
54667 arg2 = static_cast< int >(val2);
54668 }
54669 if (obj2) {
54670 ecode3 = SWIG_AsVal_int(obj2, &val3);
54671 if (!SWIG_IsOK(ecode3)) {
54672 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
54673 }
54674 arg3 = static_cast< int >(val3);
54675 }
54676 {
54677 PyThreadState* __tstate = wxPyBeginAllowThreads();
54678 wxGBSpan_Set(arg1,arg2,arg3);
54679 wxPyEndAllowThreads(__tstate);
54680 if (PyErr_Occurred()) SWIG_fail;
54681 }
54682 resultobj = SWIG_Py_Void();
54683 return resultobj;
54684 fail:
54685 return NULL;
54686 }
54687
54688
54689 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54690 PyObject *resultobj = 0;
54691 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54692 PyObject *result = 0 ;
54693 void *argp1 = 0 ;
54694 int res1 = 0 ;
54695 PyObject *swig_obj[1] ;
54696
54697 if (!args) SWIG_fail;
54698 swig_obj[0] = args;
54699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54700 if (!SWIG_IsOK(res1)) {
54701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54702 }
54703 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54704 {
54705 PyThreadState* __tstate = wxPyBeginAllowThreads();
54706 result = (PyObject *)wxGBSpan_Get(arg1);
54707 wxPyEndAllowThreads(__tstate);
54708 if (PyErr_Occurred()) SWIG_fail;
54709 }
54710 resultobj = result;
54711 return resultobj;
54712 fail:
54713 return NULL;
54714 }
54715
54716
54717 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54718 PyObject *obj;
54719 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54720 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
54721 return SWIG_Py_Void();
54722 }
54723
54724 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54725 return SWIG_Python_InitShadowInstance(args);
54726 }
54727
54728 SWIGINTERN int DefaultSpan_set(PyObject *) {
54729 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
54730 return 1;
54731 }
54732
54733
54734 SWIGINTERN PyObject *DefaultSpan_get(void) {
54735 PyObject *pyobj = 0;
54736
54737 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
54738 return pyobj;
54739 }
54740
54741
54742 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54743 PyObject *resultobj = 0;
54744 wxGBSizerItem *result = 0 ;
54745
54746 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
54747 {
54748 PyThreadState* __tstate = wxPyBeginAllowThreads();
54749 result = (wxGBSizerItem *)new wxGBSizerItem();
54750 wxPyEndAllowThreads(__tstate);
54751 if (PyErr_Occurred()) SWIG_fail;
54752 }
54753 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
54754 return resultobj;
54755 fail:
54756 return NULL;
54757 }
54758
54759
54760 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54761 PyObject *resultobj = 0;
54762 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
54763 void *argp1 = 0 ;
54764 int res1 = 0 ;
54765 PyObject *swig_obj[1] ;
54766
54767 if (!args) SWIG_fail;
54768 swig_obj[0] = args;
54769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
54770 if (!SWIG_IsOK(res1)) {
54771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
54772 }
54773 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
54774 {
54775 PyThreadState* __tstate = wxPyBeginAllowThreads();
54776 delete arg1;
54777
54778 wxPyEndAllowThreads(__tstate);
54779 if (PyErr_Occurred()) SWIG_fail;
54780 }
54781 resultobj = SWIG_Py_Void();
54782 return resultobj;
54783 fail:
54784 return NULL;
54785 }
54786
54787
54788 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54789 PyObject *resultobj = 0;
54790 wxWindow *arg1 = (wxWindow *) 0 ;
54791 wxGBPosition *arg2 = 0 ;
54792 wxGBSpan *arg3 = 0 ;
54793 int arg4 ;
54794 int arg5 ;
54795 PyObject *arg6 = (PyObject *) NULL ;
54796 wxGBSizerItem *result = 0 ;
54797 void *argp1 = 0 ;
54798 int res1 = 0 ;
54799 wxGBPosition temp2 ;
54800 wxGBSpan temp3 ;
54801 int val4 ;
54802 int ecode4 = 0 ;
54803 int val5 ;
54804 int ecode5 = 0 ;
54805 PyObject * obj0 = 0 ;
54806 PyObject * obj1 = 0 ;
54807 PyObject * obj2 = 0 ;
54808 PyObject * obj3 = 0 ;
54809 PyObject * obj4 = 0 ;
54810 PyObject * obj5 = 0 ;
54811 char * kwnames[] = {
54812 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
54813 };
54814
54815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
54816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
54817 if (!SWIG_IsOK(res1)) {
54818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
54819 }
54820 arg1 = reinterpret_cast< wxWindow * >(argp1);
54821 {
54822 arg2 = &temp2;
54823 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54824 }
54825 {
54826 arg3 = &temp3;
54827 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
54828 }
54829 ecode4 = SWIG_AsVal_int(obj3, &val4);
54830 if (!SWIG_IsOK(ecode4)) {
54831 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
54832 }
54833 arg4 = static_cast< int >(val4);
54834 ecode5 = SWIG_AsVal_int(obj4, &val5);
54835 if (!SWIG_IsOK(ecode5)) {
54836 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
54837 }
54838 arg5 = static_cast< int >(val5);
54839 if (obj5) {
54840 arg6 = obj5;
54841 }
54842 {
54843 PyThreadState* __tstate = wxPyBeginAllowThreads();
54844 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
54845 wxPyEndAllowThreads(__tstate);
54846 if (PyErr_Occurred()) SWIG_fail;
54847 }
54848 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
54849 return resultobj;
54850 fail:
54851 return NULL;
54852 }
54853
54854
54855 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54856 PyObject *resultobj = 0;
54857 wxSizer *arg1 = (wxSizer *) 0 ;
54858 wxGBPosition *arg2 = 0 ;
54859 wxGBSpan *arg3 = 0 ;
54860 int arg4 ;
54861 int arg5 ;
54862 PyObject *arg6 = (PyObject *) NULL ;
54863 wxGBSizerItem *result = 0 ;
54864 int res1 = 0 ;
54865 wxGBPosition temp2 ;
54866 wxGBSpan temp3 ;
54867 int val4 ;
54868 int ecode4 = 0 ;
54869 int val5 ;
54870 int ecode5 = 0 ;
54871 PyObject * obj0 = 0 ;
54872 PyObject * obj1 = 0 ;
54873 PyObject * obj2 = 0 ;
54874 PyObject * obj3 = 0 ;
54875 PyObject * obj4 = 0 ;
54876 PyObject * obj5 = 0 ;
54877 char * kwnames[] = {
54878 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
54879 };
54880
54881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
54882 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
54883 if (!SWIG_IsOK(res1)) {
54884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
54885 }
54886 {
54887 arg2 = &temp2;
54888 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54889 }
54890 {
54891 arg3 = &temp3;
54892 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
54893 }
54894 ecode4 = SWIG_AsVal_int(obj3, &val4);
54895 if (!SWIG_IsOK(ecode4)) {
54896 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
54897 }
54898 arg4 = static_cast< int >(val4);
54899 ecode5 = SWIG_AsVal_int(obj4, &val5);
54900 if (!SWIG_IsOK(ecode5)) {
54901 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
54902 }
54903 arg5 = static_cast< int >(val5);
54904 if (obj5) {
54905 arg6 = obj5;
54906 }
54907 {
54908 PyThreadState* __tstate = wxPyBeginAllowThreads();
54909 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
54910 wxPyEndAllowThreads(__tstate);
54911 if (PyErr_Occurred()) SWIG_fail;
54912 }
54913 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
54914 return resultobj;
54915 fail:
54916 return NULL;
54917 }
54918
54919
54920 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54921 PyObject *resultobj = 0;
54922 int arg1 ;
54923 int arg2 ;
54924 wxGBPosition *arg3 = 0 ;
54925 wxGBSpan *arg4 = 0 ;
54926 int arg5 ;
54927 int arg6 ;
54928 PyObject *arg7 = (PyObject *) NULL ;
54929 wxGBSizerItem *result = 0 ;
54930 int val1 ;
54931 int ecode1 = 0 ;
54932 int val2 ;
54933 int ecode2 = 0 ;
54934 wxGBPosition temp3 ;
54935 wxGBSpan temp4 ;
54936 int val5 ;
54937 int ecode5 = 0 ;
54938 int val6 ;
54939 int ecode6 = 0 ;
54940 PyObject * obj0 = 0 ;
54941 PyObject * obj1 = 0 ;
54942 PyObject * obj2 = 0 ;
54943 PyObject * obj3 = 0 ;
54944 PyObject * obj4 = 0 ;
54945 PyObject * obj5 = 0 ;
54946 PyObject * obj6 = 0 ;
54947 char * kwnames[] = {
54948 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
54949 };
54950
54951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
54952 ecode1 = SWIG_AsVal_int(obj0, &val1);
54953 if (!SWIG_IsOK(ecode1)) {
54954 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
54955 }
54956 arg1 = static_cast< int >(val1);
54957 ecode2 = SWIG_AsVal_int(obj1, &val2);
54958 if (!SWIG_IsOK(ecode2)) {
54959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
54960 }
54961 arg2 = static_cast< int >(val2);
54962 {
54963 arg3 = &temp3;
54964 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
54965 }
54966 {
54967 arg4 = &temp4;
54968 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
54969 }
54970 ecode5 = SWIG_AsVal_int(obj4, &val5);
54971 if (!SWIG_IsOK(ecode5)) {
54972 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
54973 }
54974 arg5 = static_cast< int >(val5);
54975 ecode6 = SWIG_AsVal_int(obj5, &val6);
54976 if (!SWIG_IsOK(ecode6)) {
54977 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
54978 }
54979 arg6 = static_cast< int >(val6);
54980 if (obj6) {
54981 arg7 = obj6;
54982 }
54983 {
54984 PyThreadState* __tstate = wxPyBeginAllowThreads();
54985 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
54986 wxPyEndAllowThreads(__tstate);
54987 if (PyErr_Occurred()) SWIG_fail;
54988 }
54989 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
54990 return resultobj;
54991 fail:
54992 return NULL;
54993 }
54994
54995
54996 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54997 PyObject *resultobj = 0;
54998 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
54999 wxGBPosition result;
55000 void *argp1 = 0 ;
55001 int res1 = 0 ;
55002 PyObject *swig_obj[1] ;
55003
55004 if (!args) SWIG_fail;
55005 swig_obj[0] = args;
55006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55007 if (!SWIG_IsOK(res1)) {
55008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
55009 }
55010 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55011 {
55012 PyThreadState* __tstate = wxPyBeginAllowThreads();
55013 result = ((wxGBSizerItem const *)arg1)->GetPos();
55014 wxPyEndAllowThreads(__tstate);
55015 if (PyErr_Occurred()) SWIG_fail;
55016 }
55017 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
55018 return resultobj;
55019 fail:
55020 return NULL;
55021 }
55022
55023
55024 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55025 PyObject *resultobj = 0;
55026 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55027 wxGBSpan result;
55028 void *argp1 = 0 ;
55029 int res1 = 0 ;
55030 PyObject *swig_obj[1] ;
55031
55032 if (!args) SWIG_fail;
55033 swig_obj[0] = args;
55034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55035 if (!SWIG_IsOK(res1)) {
55036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
55037 }
55038 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55039 {
55040 PyThreadState* __tstate = wxPyBeginAllowThreads();
55041 result = ((wxGBSizerItem const *)arg1)->GetSpan();
55042 wxPyEndAllowThreads(__tstate);
55043 if (PyErr_Occurred()) SWIG_fail;
55044 }
55045 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
55046 return resultobj;
55047 fail:
55048 return NULL;
55049 }
55050
55051
55052 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55053 PyObject *resultobj = 0;
55054 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55055 wxGBPosition *arg2 = 0 ;
55056 bool result;
55057 void *argp1 = 0 ;
55058 int res1 = 0 ;
55059 wxGBPosition temp2 ;
55060 PyObject * obj0 = 0 ;
55061 PyObject * obj1 = 0 ;
55062 char * kwnames[] = {
55063 (char *) "self",(char *) "pos", NULL
55064 };
55065
55066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
55067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55068 if (!SWIG_IsOK(res1)) {
55069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55070 }
55071 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55072 {
55073 arg2 = &temp2;
55074 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55075 }
55076 {
55077 PyThreadState* __tstate = wxPyBeginAllowThreads();
55078 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
55079 wxPyEndAllowThreads(__tstate);
55080 if (PyErr_Occurred()) SWIG_fail;
55081 }
55082 {
55083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55084 }
55085 return resultobj;
55086 fail:
55087 return NULL;
55088 }
55089
55090
55091 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55092 PyObject *resultobj = 0;
55093 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55094 wxGBSpan *arg2 = 0 ;
55095 bool result;
55096 void *argp1 = 0 ;
55097 int res1 = 0 ;
55098 wxGBSpan temp2 ;
55099 PyObject * obj0 = 0 ;
55100 PyObject * obj1 = 0 ;
55101 char * kwnames[] = {
55102 (char *) "self",(char *) "span", NULL
55103 };
55104
55105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
55106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55107 if (!SWIG_IsOK(res1)) {
55108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55109 }
55110 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55111 {
55112 arg2 = &temp2;
55113 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
55114 }
55115 {
55116 PyThreadState* __tstate = wxPyBeginAllowThreads();
55117 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
55118 wxPyEndAllowThreads(__tstate);
55119 if (PyErr_Occurred()) SWIG_fail;
55120 }
55121 {
55122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55123 }
55124 return resultobj;
55125 fail:
55126 return NULL;
55127 }
55128
55129
55130 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55131 PyObject *resultobj = 0;
55132 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55133 wxGBSizerItem *arg2 = 0 ;
55134 bool result;
55135 void *argp1 = 0 ;
55136 int res1 = 0 ;
55137 void *argp2 = 0 ;
55138 int res2 = 0 ;
55139 PyObject * obj0 = 0 ;
55140 PyObject * obj1 = 0 ;
55141 char * kwnames[] = {
55142 (char *) "self",(char *) "other", NULL
55143 };
55144
55145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
55146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55147 if (!SWIG_IsOK(res1)) {
55148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55149 }
55150 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55151 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
55152 if (!SWIG_IsOK(res2)) {
55153 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
55154 }
55155 if (!argp2) {
55156 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
55157 }
55158 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
55159 {
55160 PyThreadState* __tstate = wxPyBeginAllowThreads();
55161 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
55162 wxPyEndAllowThreads(__tstate);
55163 if (PyErr_Occurred()) SWIG_fail;
55164 }
55165 {
55166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55167 }
55168 return resultobj;
55169 fail:
55170 return NULL;
55171 }
55172
55173
55174 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55175 PyObject *resultobj = 0;
55176 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55177 wxGBPosition *arg2 = 0 ;
55178 wxGBSpan *arg3 = 0 ;
55179 bool result;
55180 void *argp1 = 0 ;
55181 int res1 = 0 ;
55182 wxGBPosition temp2 ;
55183 wxGBSpan temp3 ;
55184 PyObject * obj0 = 0 ;
55185 PyObject * obj1 = 0 ;
55186 PyObject * obj2 = 0 ;
55187 char * kwnames[] = {
55188 (char *) "self",(char *) "pos",(char *) "span", NULL
55189 };
55190
55191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55193 if (!SWIG_IsOK(res1)) {
55194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55195 }
55196 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55197 {
55198 arg2 = &temp2;
55199 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55200 }
55201 {
55202 arg3 = &temp3;
55203 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
55204 }
55205 {
55206 PyThreadState* __tstate = wxPyBeginAllowThreads();
55207 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
55208 wxPyEndAllowThreads(__tstate);
55209 if (PyErr_Occurred()) SWIG_fail;
55210 }
55211 {
55212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55213 }
55214 return resultobj;
55215 fail:
55216 return NULL;
55217 }
55218
55219
55220 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55221 PyObject *resultobj = 0;
55222 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55223 wxGBPosition result;
55224 void *argp1 = 0 ;
55225 int res1 = 0 ;
55226 PyObject *swig_obj[1] ;
55227
55228 if (!args) SWIG_fail;
55229 swig_obj[0] = args;
55230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55231 if (!SWIG_IsOK(res1)) {
55232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55233 }
55234 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55235 {
55236 PyThreadState* __tstate = wxPyBeginAllowThreads();
55237 result = wxGBSizerItem_GetEndPos(arg1);
55238 wxPyEndAllowThreads(__tstate);
55239 if (PyErr_Occurred()) SWIG_fail;
55240 }
55241 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
55242 return resultobj;
55243 fail:
55244 return NULL;
55245 }
55246
55247
55248 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55249 PyObject *resultobj = 0;
55250 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55251 wxGridBagSizer *result = 0 ;
55252 void *argp1 = 0 ;
55253 int res1 = 0 ;
55254 PyObject *swig_obj[1] ;
55255
55256 if (!args) SWIG_fail;
55257 swig_obj[0] = args;
55258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55259 if (!SWIG_IsOK(res1)) {
55260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
55261 }
55262 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55263 {
55264 PyThreadState* __tstate = wxPyBeginAllowThreads();
55265 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
55266 wxPyEndAllowThreads(__tstate);
55267 if (PyErr_Occurred()) SWIG_fail;
55268 }
55269 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55270 return resultobj;
55271 fail:
55272 return NULL;
55273 }
55274
55275
55276 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55277 PyObject *resultobj = 0;
55278 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55279 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
55280 void *argp1 = 0 ;
55281 int res1 = 0 ;
55282 void *argp2 = 0 ;
55283 int res2 = 0 ;
55284 PyObject * obj0 = 0 ;
55285 PyObject * obj1 = 0 ;
55286 char * kwnames[] = {
55287 (char *) "self",(char *) "sizer", NULL
55288 };
55289
55290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
55291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55292 if (!SWIG_IsOK(res1)) {
55293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55294 }
55295 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55296 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55297 if (!SWIG_IsOK(res2)) {
55298 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
55299 }
55300 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
55301 {
55302 PyThreadState* __tstate = wxPyBeginAllowThreads();
55303 (arg1)->SetGBSizer(arg2);
55304 wxPyEndAllowThreads(__tstate);
55305 if (PyErr_Occurred()) SWIG_fail;
55306 }
55307 resultobj = SWIG_Py_Void();
55308 return resultobj;
55309 fail:
55310 return NULL;
55311 }
55312
55313
55314 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55315 PyObject *obj;
55316 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
55317 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
55318 return SWIG_Py_Void();
55319 }
55320
55321 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55322 return SWIG_Python_InitShadowInstance(args);
55323 }
55324
55325 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55326 PyObject *resultobj = 0;
55327 int arg1 = (int) 0 ;
55328 int arg2 = (int) 0 ;
55329 wxGridBagSizer *result = 0 ;
55330 int val1 ;
55331 int ecode1 = 0 ;
55332 int val2 ;
55333 int ecode2 = 0 ;
55334 PyObject * obj0 = 0 ;
55335 PyObject * obj1 = 0 ;
55336 char * kwnames[] = {
55337 (char *) "vgap",(char *) "hgap", NULL
55338 };
55339
55340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
55341 if (obj0) {
55342 ecode1 = SWIG_AsVal_int(obj0, &val1);
55343 if (!SWIG_IsOK(ecode1)) {
55344 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
55345 }
55346 arg1 = static_cast< int >(val1);
55347 }
55348 if (obj1) {
55349 ecode2 = SWIG_AsVal_int(obj1, &val2);
55350 if (!SWIG_IsOK(ecode2)) {
55351 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
55352 }
55353 arg2 = static_cast< int >(val2);
55354 }
55355 {
55356 PyThreadState* __tstate = wxPyBeginAllowThreads();
55357 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
55358 wxPyEndAllowThreads(__tstate);
55359 if (PyErr_Occurred()) SWIG_fail;
55360 }
55361 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
55362 return resultobj;
55363 fail:
55364 return NULL;
55365 }
55366
55367
55368 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55369 PyObject *resultobj = 0;
55370 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55371 PyObject *arg2 = (PyObject *) 0 ;
55372 wxGBPosition *arg3 = 0 ;
55373 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
55374 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
55375 int arg5 = (int) 0 ;
55376 int arg6 = (int) 0 ;
55377 PyObject *arg7 = (PyObject *) NULL ;
55378 wxGBSizerItem *result = 0 ;
55379 void *argp1 = 0 ;
55380 int res1 = 0 ;
55381 wxGBPosition temp3 ;
55382 wxGBSpan temp4 ;
55383 int val5 ;
55384 int ecode5 = 0 ;
55385 int val6 ;
55386 int ecode6 = 0 ;
55387 PyObject * obj0 = 0 ;
55388 PyObject * obj1 = 0 ;
55389 PyObject * obj2 = 0 ;
55390 PyObject * obj3 = 0 ;
55391 PyObject * obj4 = 0 ;
55392 PyObject * obj5 = 0 ;
55393 PyObject * obj6 = 0 ;
55394 char * kwnames[] = {
55395 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
55396 };
55397
55398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
55399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55400 if (!SWIG_IsOK(res1)) {
55401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55402 }
55403 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55404 arg2 = obj1;
55405 {
55406 arg3 = &temp3;
55407 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
55408 }
55409 if (obj3) {
55410 {
55411 arg4 = &temp4;
55412 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
55413 }
55414 }
55415 if (obj4) {
55416 ecode5 = SWIG_AsVal_int(obj4, &val5);
55417 if (!SWIG_IsOK(ecode5)) {
55418 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
55419 }
55420 arg5 = static_cast< int >(val5);
55421 }
55422 if (obj5) {
55423 ecode6 = SWIG_AsVal_int(obj5, &val6);
55424 if (!SWIG_IsOK(ecode6)) {
55425 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
55426 }
55427 arg6 = static_cast< int >(val6);
55428 }
55429 if (obj6) {
55430 arg7 = obj6;
55431 }
55432 {
55433 PyThreadState* __tstate = wxPyBeginAllowThreads();
55434 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
55435 wxPyEndAllowThreads(__tstate);
55436 if (PyErr_Occurred()) SWIG_fail;
55437 }
55438 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55439 return resultobj;
55440 fail:
55441 return NULL;
55442 }
55443
55444
55445 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55446 PyObject *resultobj = 0;
55447 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55448 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
55449 wxGBSizerItem *result = 0 ;
55450 void *argp1 = 0 ;
55451 int res1 = 0 ;
55452 int res2 = 0 ;
55453 PyObject * obj0 = 0 ;
55454 PyObject * obj1 = 0 ;
55455 char * kwnames[] = {
55456 (char *) "self",(char *) "item", NULL
55457 };
55458
55459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
55460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55461 if (!SWIG_IsOK(res1)) {
55462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55463 }
55464 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55465 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
55466 if (!SWIG_IsOK(res2)) {
55467 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
55468 }
55469 {
55470 PyThreadState* __tstate = wxPyBeginAllowThreads();
55471 result = (wxGBSizerItem *)(arg1)->Add(arg2);
55472 wxPyEndAllowThreads(__tstate);
55473 if (PyErr_Occurred()) SWIG_fail;
55474 }
55475 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55476 return resultobj;
55477 fail:
55478 return NULL;
55479 }
55480
55481
55482 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55483 PyObject *resultobj = 0;
55484 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55485 int arg2 ;
55486 int arg3 ;
55487 wxSize result;
55488 void *argp1 = 0 ;
55489 int res1 = 0 ;
55490 int val2 ;
55491 int ecode2 = 0 ;
55492 int val3 ;
55493 int ecode3 = 0 ;
55494 PyObject * obj0 = 0 ;
55495 PyObject * obj1 = 0 ;
55496 PyObject * obj2 = 0 ;
55497 char * kwnames[] = {
55498 (char *) "self",(char *) "row",(char *) "col", NULL
55499 };
55500
55501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55503 if (!SWIG_IsOK(res1)) {
55504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
55505 }
55506 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55507 ecode2 = SWIG_AsVal_int(obj1, &val2);
55508 if (!SWIG_IsOK(ecode2)) {
55509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
55510 }
55511 arg2 = static_cast< int >(val2);
55512 ecode3 = SWIG_AsVal_int(obj2, &val3);
55513 if (!SWIG_IsOK(ecode3)) {
55514 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
55515 }
55516 arg3 = static_cast< int >(val3);
55517 {
55518 PyThreadState* __tstate = wxPyBeginAllowThreads();
55519 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
55520 wxPyEndAllowThreads(__tstate);
55521 if (PyErr_Occurred()) SWIG_fail;
55522 }
55523 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
55524 return resultobj;
55525 fail:
55526 return NULL;
55527 }
55528
55529
55530 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55531 PyObject *resultobj = 0;
55532 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55533 wxSize result;
55534 void *argp1 = 0 ;
55535 int res1 = 0 ;
55536 PyObject *swig_obj[1] ;
55537
55538 if (!args) SWIG_fail;
55539 swig_obj[0] = args;
55540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55541 if (!SWIG_IsOK(res1)) {
55542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
55543 }
55544 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55545 {
55546 PyThreadState* __tstate = wxPyBeginAllowThreads();
55547 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
55548 wxPyEndAllowThreads(__tstate);
55549 if (PyErr_Occurred()) SWIG_fail;
55550 }
55551 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
55552 return resultobj;
55553 fail:
55554 return NULL;
55555 }
55556
55557
55558 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55559 PyObject *resultobj = 0;
55560 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55561 wxSize *arg2 = 0 ;
55562 void *argp1 = 0 ;
55563 int res1 = 0 ;
55564 wxSize temp2 ;
55565 PyObject * obj0 = 0 ;
55566 PyObject * obj1 = 0 ;
55567 char * kwnames[] = {
55568 (char *) "self",(char *) "sz", NULL
55569 };
55570
55571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
55572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55573 if (!SWIG_IsOK(res1)) {
55574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55575 }
55576 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55577 {
55578 arg2 = &temp2;
55579 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
55580 }
55581 {
55582 PyThreadState* __tstate = wxPyBeginAllowThreads();
55583 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
55584 wxPyEndAllowThreads(__tstate);
55585 if (PyErr_Occurred()) SWIG_fail;
55586 }
55587 resultobj = SWIG_Py_Void();
55588 return resultobj;
55589 fail:
55590 return NULL;
55591 }
55592
55593
55594 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55595 PyObject *resultobj = 0;
55596 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55597 wxWindow *arg2 = (wxWindow *) 0 ;
55598 wxGBPosition result;
55599 void *argp1 = 0 ;
55600 int res1 = 0 ;
55601 void *argp2 = 0 ;
55602 int res2 = 0 ;
55603
55604 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
55605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55606 if (!SWIG_IsOK(res1)) {
55607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55608 }
55609 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55610 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55611 if (!SWIG_IsOK(res2)) {
55612 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
55613 }
55614 arg2 = reinterpret_cast< wxWindow * >(argp2);
55615 {
55616 PyThreadState* __tstate = wxPyBeginAllowThreads();
55617 result = (arg1)->GetItemPosition(arg2);
55618 wxPyEndAllowThreads(__tstate);
55619 if (PyErr_Occurred()) SWIG_fail;
55620 }
55621 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
55622 return resultobj;
55623 fail:
55624 return NULL;
55625 }
55626
55627
55628 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55629 PyObject *resultobj = 0;
55630 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55631 wxSizer *arg2 = (wxSizer *) 0 ;
55632 wxGBPosition result;
55633 void *argp1 = 0 ;
55634 int res1 = 0 ;
55635 void *argp2 = 0 ;
55636 int res2 = 0 ;
55637
55638 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
55639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55640 if (!SWIG_IsOK(res1)) {
55641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55642 }
55643 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55644 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
55645 if (!SWIG_IsOK(res2)) {
55646 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
55647 }
55648 arg2 = reinterpret_cast< wxSizer * >(argp2);
55649 {
55650 PyThreadState* __tstate = wxPyBeginAllowThreads();
55651 result = (arg1)->GetItemPosition(arg2);
55652 wxPyEndAllowThreads(__tstate);
55653 if (PyErr_Occurred()) SWIG_fail;
55654 }
55655 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
55656 return resultobj;
55657 fail:
55658 return NULL;
55659 }
55660
55661
55662 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55663 PyObject *resultobj = 0;
55664 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55665 size_t arg2 ;
55666 wxGBPosition result;
55667 void *argp1 = 0 ;
55668 int res1 = 0 ;
55669 size_t val2 ;
55670 int ecode2 = 0 ;
55671
55672 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
55673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55674 if (!SWIG_IsOK(res1)) {
55675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55676 }
55677 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55678 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
55679 if (!SWIG_IsOK(ecode2)) {
55680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
55681 }
55682 arg2 = static_cast< size_t >(val2);
55683 {
55684 PyThreadState* __tstate = wxPyBeginAllowThreads();
55685 result = (arg1)->GetItemPosition(arg2);
55686 wxPyEndAllowThreads(__tstate);
55687 if (PyErr_Occurred()) SWIG_fail;
55688 }
55689 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
55690 return resultobj;
55691 fail:
55692 return NULL;
55693 }
55694
55695
55696 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
55697 int argc;
55698 PyObject *argv[3];
55699
55700 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
55701 --argc;
55702 if (argc == 2) {
55703 int _v = 0;
55704 {
55705 void *vptr = 0;
55706 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
55707 _v = SWIG_CheckState(res);
55708 }
55709 if (!_v) goto check_1;
55710 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
55711 }
55712 check_1:
55713
55714 if (argc == 2) {
55715 int _v = 0;
55716 {
55717 void *vptr = 0;
55718 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
55719 _v = SWIG_CheckState(res);
55720 }
55721 if (!_v) goto check_2;
55722 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
55723 }
55724 check_2:
55725
55726 if (argc == 2) {
55727 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
55728 }
55729
55730 fail:
55731 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
55732 return NULL;
55733 }
55734
55735
55736 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55737 PyObject *resultobj = 0;
55738 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55739 wxWindow *arg2 = (wxWindow *) 0 ;
55740 wxGBPosition *arg3 = 0 ;
55741 bool result;
55742 void *argp1 = 0 ;
55743 int res1 = 0 ;
55744 void *argp2 = 0 ;
55745 int res2 = 0 ;
55746 wxGBPosition temp3 ;
55747
55748 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
55749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55750 if (!SWIG_IsOK(res1)) {
55751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55752 }
55753 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55754 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55755 if (!SWIG_IsOK(res2)) {
55756 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
55757 }
55758 arg2 = reinterpret_cast< wxWindow * >(argp2);
55759 {
55760 arg3 = &temp3;
55761 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
55762 }
55763 {
55764 PyThreadState* __tstate = wxPyBeginAllowThreads();
55765 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
55766 wxPyEndAllowThreads(__tstate);
55767 if (PyErr_Occurred()) SWIG_fail;
55768 }
55769 {
55770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55771 }
55772 return resultobj;
55773 fail:
55774 return NULL;
55775 }
55776
55777
55778 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55779 PyObject *resultobj = 0;
55780 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55781 wxSizer *arg2 = (wxSizer *) 0 ;
55782 wxGBPosition *arg3 = 0 ;
55783 bool result;
55784 void *argp1 = 0 ;
55785 int res1 = 0 ;
55786 void *argp2 = 0 ;
55787 int res2 = 0 ;
55788 wxGBPosition temp3 ;
55789
55790 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
55791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55792 if (!SWIG_IsOK(res1)) {
55793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55794 }
55795 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55796 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
55797 if (!SWIG_IsOK(res2)) {
55798 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
55799 }
55800 arg2 = reinterpret_cast< wxSizer * >(argp2);
55801 {
55802 arg3 = &temp3;
55803 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
55804 }
55805 {
55806 PyThreadState* __tstate = wxPyBeginAllowThreads();
55807 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
55808 wxPyEndAllowThreads(__tstate);
55809 if (PyErr_Occurred()) SWIG_fail;
55810 }
55811 {
55812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55813 }
55814 return resultobj;
55815 fail:
55816 return NULL;
55817 }
55818
55819
55820 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55821 PyObject *resultobj = 0;
55822 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55823 size_t arg2 ;
55824 wxGBPosition *arg3 = 0 ;
55825 bool result;
55826 void *argp1 = 0 ;
55827 int res1 = 0 ;
55828 size_t val2 ;
55829 int ecode2 = 0 ;
55830 wxGBPosition temp3 ;
55831
55832 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
55833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55834 if (!SWIG_IsOK(res1)) {
55835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55836 }
55837 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55838 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
55839 if (!SWIG_IsOK(ecode2)) {
55840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
55841 }
55842 arg2 = static_cast< size_t >(val2);
55843 {
55844 arg3 = &temp3;
55845 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
55846 }
55847 {
55848 PyThreadState* __tstate = wxPyBeginAllowThreads();
55849 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
55850 wxPyEndAllowThreads(__tstate);
55851 if (PyErr_Occurred()) SWIG_fail;
55852 }
55853 {
55854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55855 }
55856 return resultobj;
55857 fail:
55858 return NULL;
55859 }
55860
55861
55862 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
55863 int argc;
55864 PyObject *argv[4];
55865
55866 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
55867 --argc;
55868 if (argc == 3) {
55869 int _v = 0;
55870 {
55871 void *vptr = 0;
55872 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
55873 _v = SWIG_CheckState(res);
55874 }
55875 if (!_v) goto check_1;
55876 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
55877 }
55878 check_1:
55879
55880 if (argc == 3) {
55881 int _v = 0;
55882 {
55883 void *vptr = 0;
55884 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
55885 _v = SWIG_CheckState(res);
55886 }
55887 if (!_v) goto check_2;
55888 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
55889 }
55890 check_2:
55891
55892 if (argc == 3) {
55893 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
55894 }
55895
55896 fail:
55897 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
55898 return NULL;
55899 }
55900
55901
55902 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55903 PyObject *resultobj = 0;
55904 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55905 wxWindow *arg2 = (wxWindow *) 0 ;
55906 wxGBSpan result;
55907 void *argp1 = 0 ;
55908 int res1 = 0 ;
55909 void *argp2 = 0 ;
55910 int res2 = 0 ;
55911
55912 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
55913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55914 if (!SWIG_IsOK(res1)) {
55915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55916 }
55917 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55918 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55919 if (!SWIG_IsOK(res2)) {
55920 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
55921 }
55922 arg2 = reinterpret_cast< wxWindow * >(argp2);
55923 {
55924 PyThreadState* __tstate = wxPyBeginAllowThreads();
55925 result = (arg1)->GetItemSpan(arg2);
55926 wxPyEndAllowThreads(__tstate);
55927 if (PyErr_Occurred()) SWIG_fail;
55928 }
55929 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
55930 return resultobj;
55931 fail:
55932 return NULL;
55933 }
55934
55935
55936 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55937 PyObject *resultobj = 0;
55938 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55939 wxSizer *arg2 = (wxSizer *) 0 ;
55940 wxGBSpan result;
55941 void *argp1 = 0 ;
55942 int res1 = 0 ;
55943 void *argp2 = 0 ;
55944 int res2 = 0 ;
55945
55946 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
55947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55948 if (!SWIG_IsOK(res1)) {
55949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55950 }
55951 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55952 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
55953 if (!SWIG_IsOK(res2)) {
55954 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
55955 }
55956 arg2 = reinterpret_cast< wxSizer * >(argp2);
55957 {
55958 PyThreadState* __tstate = wxPyBeginAllowThreads();
55959 result = (arg1)->GetItemSpan(arg2);
55960 wxPyEndAllowThreads(__tstate);
55961 if (PyErr_Occurred()) SWIG_fail;
55962 }
55963 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
55964 return resultobj;
55965 fail:
55966 return NULL;
55967 }
55968
55969
55970 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
55971 PyObject *resultobj = 0;
55972 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55973 size_t arg2 ;
55974 wxGBSpan result;
55975 void *argp1 = 0 ;
55976 int res1 = 0 ;
55977 size_t val2 ;
55978 int ecode2 = 0 ;
55979
55980 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
55981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55982 if (!SWIG_IsOK(res1)) {
55983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55984 }
55985 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55986 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
55987 if (!SWIG_IsOK(ecode2)) {
55988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
55989 }
55990 arg2 = static_cast< size_t >(val2);
55991 {
55992 PyThreadState* __tstate = wxPyBeginAllowThreads();
55993 result = (arg1)->GetItemSpan(arg2);
55994 wxPyEndAllowThreads(__tstate);
55995 if (PyErr_Occurred()) SWIG_fail;
55996 }
55997 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
55998 return resultobj;
55999 fail:
56000 return NULL;
56001 }
56002
56003
56004 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
56005 int argc;
56006 PyObject *argv[3];
56007
56008 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
56009 --argc;
56010 if (argc == 2) {
56011 int _v = 0;
56012 {
56013 void *vptr = 0;
56014 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
56015 _v = SWIG_CheckState(res);
56016 }
56017 if (!_v) goto check_1;
56018 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
56019 }
56020 check_1:
56021
56022 if (argc == 2) {
56023 int _v = 0;
56024 {
56025 void *vptr = 0;
56026 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
56027 _v = SWIG_CheckState(res);
56028 }
56029 if (!_v) goto check_2;
56030 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
56031 }
56032 check_2:
56033
56034 if (argc == 2) {
56035 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
56036 }
56037
56038 fail:
56039 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
56040 return NULL;
56041 }
56042
56043
56044 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56045 PyObject *resultobj = 0;
56046 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56047 wxWindow *arg2 = (wxWindow *) 0 ;
56048 wxGBSpan *arg3 = 0 ;
56049 bool result;
56050 void *argp1 = 0 ;
56051 int res1 = 0 ;
56052 void *argp2 = 0 ;
56053 int res2 = 0 ;
56054 wxGBSpan temp3 ;
56055
56056 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56058 if (!SWIG_IsOK(res1)) {
56059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56060 }
56061 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56062 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56063 if (!SWIG_IsOK(res2)) {
56064 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
56065 }
56066 arg2 = reinterpret_cast< wxWindow * >(argp2);
56067 {
56068 arg3 = &temp3;
56069 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
56070 }
56071 {
56072 PyThreadState* __tstate = wxPyBeginAllowThreads();
56073 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
56074 wxPyEndAllowThreads(__tstate);
56075 if (PyErr_Occurred()) SWIG_fail;
56076 }
56077 {
56078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56079 }
56080 return resultobj;
56081 fail:
56082 return NULL;
56083 }
56084
56085
56086 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56087 PyObject *resultobj = 0;
56088 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56089 wxSizer *arg2 = (wxSizer *) 0 ;
56090 wxGBSpan *arg3 = 0 ;
56091 bool result;
56092 void *argp1 = 0 ;
56093 int res1 = 0 ;
56094 void *argp2 = 0 ;
56095 int res2 = 0 ;
56096 wxGBSpan temp3 ;
56097
56098 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56100 if (!SWIG_IsOK(res1)) {
56101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56102 }
56103 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56104 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
56105 if (!SWIG_IsOK(res2)) {
56106 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
56107 }
56108 arg2 = reinterpret_cast< wxSizer * >(argp2);
56109 {
56110 arg3 = &temp3;
56111 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
56112 }
56113 {
56114 PyThreadState* __tstate = wxPyBeginAllowThreads();
56115 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
56116 wxPyEndAllowThreads(__tstate);
56117 if (PyErr_Occurred()) SWIG_fail;
56118 }
56119 {
56120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56121 }
56122 return resultobj;
56123 fail:
56124 return NULL;
56125 }
56126
56127
56128 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56129 PyObject *resultobj = 0;
56130 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56131 size_t arg2 ;
56132 wxGBSpan *arg3 = 0 ;
56133 bool result;
56134 void *argp1 = 0 ;
56135 int res1 = 0 ;
56136 size_t val2 ;
56137 int ecode2 = 0 ;
56138 wxGBSpan temp3 ;
56139
56140 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56142 if (!SWIG_IsOK(res1)) {
56143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56144 }
56145 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56146 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
56147 if (!SWIG_IsOK(ecode2)) {
56148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
56149 }
56150 arg2 = static_cast< size_t >(val2);
56151 {
56152 arg3 = &temp3;
56153 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
56154 }
56155 {
56156 PyThreadState* __tstate = wxPyBeginAllowThreads();
56157 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
56158 wxPyEndAllowThreads(__tstate);
56159 if (PyErr_Occurred()) SWIG_fail;
56160 }
56161 {
56162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56163 }
56164 return resultobj;
56165 fail:
56166 return NULL;
56167 }
56168
56169
56170 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
56171 int argc;
56172 PyObject *argv[4];
56173
56174 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
56175 --argc;
56176 if (argc == 3) {
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_SetItemSpan__SWIG_0(self, argc, argv);
56185 }
56186 check_1:
56187
56188 if (argc == 3) {
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_SetItemSpan__SWIG_1(self, argc, argv);
56197 }
56198 check_2:
56199
56200 if (argc == 3) {
56201 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
56202 }
56203
56204 fail:
56205 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
56206 return NULL;
56207 }
56208
56209
56210 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__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 wxGBSizerItem *result = 0 ;
56215 void *argp1 = 0 ;
56216 int res1 = 0 ;
56217 void *argp2 = 0 ;
56218 int res2 = 0 ;
56219
56220 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56222 if (!SWIG_IsOK(res1)) {
56223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56224 }
56225 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56226 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56227 if (!SWIG_IsOK(res2)) {
56228 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
56229 }
56230 arg2 = reinterpret_cast< wxWindow * >(argp2);
56231 {
56232 PyThreadState* __tstate = wxPyBeginAllowThreads();
56233 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
56234 wxPyEndAllowThreads(__tstate);
56235 if (PyErr_Occurred()) SWIG_fail;
56236 }
56237 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56238 return resultobj;
56239 fail:
56240 return NULL;
56241 }
56242
56243
56244 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56245 PyObject *resultobj = 0;
56246 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56247 wxSizer *arg2 = (wxSizer *) 0 ;
56248 wxGBSizerItem *result = 0 ;
56249 void *argp1 = 0 ;
56250 int res1 = 0 ;
56251 void *argp2 = 0 ;
56252 int res2 = 0 ;
56253
56254 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56256 if (!SWIG_IsOK(res1)) {
56257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56258 }
56259 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56260 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
56261 if (!SWIG_IsOK(res2)) {
56262 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
56263 }
56264 arg2 = reinterpret_cast< wxSizer * >(argp2);
56265 {
56266 PyThreadState* __tstate = wxPyBeginAllowThreads();
56267 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
56268 wxPyEndAllowThreads(__tstate);
56269 if (PyErr_Occurred()) SWIG_fail;
56270 }
56271 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56272 return resultobj;
56273 fail:
56274 return NULL;
56275 }
56276
56277
56278 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
56279 int argc;
56280 PyObject *argv[3];
56281
56282 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
56283 --argc;
56284 if (argc == 2) {
56285 int _v = 0;
56286 {
56287 void *vptr = 0;
56288 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
56289 _v = SWIG_CheckState(res);
56290 }
56291 if (!_v) goto check_1;
56292 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
56293 }
56294 check_1:
56295
56296 if (argc == 2) {
56297 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
56298 }
56299
56300 fail:
56301 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
56302 return NULL;
56303 }
56304
56305
56306 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56307 PyObject *resultobj = 0;
56308 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56309 wxGBPosition *arg2 = 0 ;
56310 wxGBSizerItem *result = 0 ;
56311 void *argp1 = 0 ;
56312 int res1 = 0 ;
56313 wxGBPosition temp2 ;
56314 PyObject * obj0 = 0 ;
56315 PyObject * obj1 = 0 ;
56316 char * kwnames[] = {
56317 (char *) "self",(char *) "pos", NULL
56318 };
56319
56320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
56321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56322 if (!SWIG_IsOK(res1)) {
56323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56324 }
56325 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56326 {
56327 arg2 = &temp2;
56328 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
56329 }
56330 {
56331 PyThreadState* __tstate = wxPyBeginAllowThreads();
56332 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
56333 wxPyEndAllowThreads(__tstate);
56334 if (PyErr_Occurred()) SWIG_fail;
56335 }
56336 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56337 return resultobj;
56338 fail:
56339 return NULL;
56340 }
56341
56342
56343 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56344 PyObject *resultobj = 0;
56345 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56346 wxPoint *arg2 = 0 ;
56347 wxGBSizerItem *result = 0 ;
56348 void *argp1 = 0 ;
56349 int res1 = 0 ;
56350 wxPoint temp2 ;
56351 PyObject * obj0 = 0 ;
56352 PyObject * obj1 = 0 ;
56353 char * kwnames[] = {
56354 (char *) "self",(char *) "pt", NULL
56355 };
56356
56357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
56358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56359 if (!SWIG_IsOK(res1)) {
56360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56361 }
56362 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56363 {
56364 arg2 = &temp2;
56365 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
56366 }
56367 {
56368 PyThreadState* __tstate = wxPyBeginAllowThreads();
56369 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
56370 wxPyEndAllowThreads(__tstate);
56371 if (PyErr_Occurred()) SWIG_fail;
56372 }
56373 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56374 return resultobj;
56375 fail:
56376 return NULL;
56377 }
56378
56379
56380 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56381 PyObject *resultobj = 0;
56382 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56383 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
56384 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
56385 bool result;
56386 void *argp1 = 0 ;
56387 int res1 = 0 ;
56388 void *argp2 = 0 ;
56389 int res2 = 0 ;
56390 void *argp3 = 0 ;
56391 int res3 = 0 ;
56392 PyObject * obj0 = 0 ;
56393 PyObject * obj1 = 0 ;
56394 PyObject * obj2 = 0 ;
56395 char * kwnames[] = {
56396 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
56397 };
56398
56399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56401 if (!SWIG_IsOK(res1)) {
56402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56403 }
56404 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56405 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56406 if (!SWIG_IsOK(res2)) {
56407 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
56408 }
56409 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
56410 if (obj2) {
56411 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56412 if (!SWIG_IsOK(res3)) {
56413 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
56414 }
56415 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
56416 }
56417 {
56418 PyThreadState* __tstate = wxPyBeginAllowThreads();
56419 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
56420 wxPyEndAllowThreads(__tstate);
56421 if (PyErr_Occurred()) SWIG_fail;
56422 }
56423 {
56424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56425 }
56426 return resultobj;
56427 fail:
56428 return NULL;
56429 }
56430
56431
56432 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56433 PyObject *resultobj = 0;
56434 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56435 wxGBPosition *arg2 = 0 ;
56436 wxGBSpan *arg3 = 0 ;
56437 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
56438 bool result;
56439 void *argp1 = 0 ;
56440 int res1 = 0 ;
56441 wxGBPosition temp2 ;
56442 wxGBSpan temp3 ;
56443 void *argp4 = 0 ;
56444 int res4 = 0 ;
56445 PyObject * obj0 = 0 ;
56446 PyObject * obj1 = 0 ;
56447 PyObject * obj2 = 0 ;
56448 PyObject * obj3 = 0 ;
56449 char * kwnames[] = {
56450 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
56451 };
56452
56453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
56454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56455 if (!SWIG_IsOK(res1)) {
56456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56457 }
56458 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56459 {
56460 arg2 = &temp2;
56461 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
56462 }
56463 {
56464 arg3 = &temp3;
56465 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
56466 }
56467 if (obj3) {
56468 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56469 if (!SWIG_IsOK(res4)) {
56470 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
56471 }
56472 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
56473 }
56474 {
56475 PyThreadState* __tstate = wxPyBeginAllowThreads();
56476 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
56477 wxPyEndAllowThreads(__tstate);
56478 if (PyErr_Occurred()) SWIG_fail;
56479 }
56480 {
56481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56482 }
56483 return resultobj;
56484 fail:
56485 return NULL;
56486 }
56487
56488
56489 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56490 PyObject *obj;
56491 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56492 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
56493 return SWIG_Py_Void();
56494 }
56495
56496 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56497 return SWIG_Python_InitShadowInstance(args);
56498 }
56499
56500 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56501 PyObject *resultobj = 0;
56502 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56503 wxRelationship arg2 ;
56504 wxWindow *arg3 = (wxWindow *) 0 ;
56505 wxEdge arg4 ;
56506 int arg5 = (int) 0 ;
56507 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
56508 void *argp1 = 0 ;
56509 int res1 = 0 ;
56510 int val2 ;
56511 int ecode2 = 0 ;
56512 void *argp3 = 0 ;
56513 int res3 = 0 ;
56514 int val4 ;
56515 int ecode4 = 0 ;
56516 int val5 ;
56517 int ecode5 = 0 ;
56518 int val6 ;
56519 int ecode6 = 0 ;
56520 PyObject * obj0 = 0 ;
56521 PyObject * obj1 = 0 ;
56522 PyObject * obj2 = 0 ;
56523 PyObject * obj3 = 0 ;
56524 PyObject * obj4 = 0 ;
56525 PyObject * obj5 = 0 ;
56526 char * kwnames[] = {
56527 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
56528 };
56529
56530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
56531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56532 if (!SWIG_IsOK(res1)) {
56533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56534 }
56535 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56536 ecode2 = SWIG_AsVal_int(obj1, &val2);
56537 if (!SWIG_IsOK(ecode2)) {
56538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
56539 }
56540 arg2 = static_cast< wxRelationship >(val2);
56541 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
56542 if (!SWIG_IsOK(res3)) {
56543 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
56544 }
56545 arg3 = reinterpret_cast< wxWindow * >(argp3);
56546 ecode4 = SWIG_AsVal_int(obj3, &val4);
56547 if (!SWIG_IsOK(ecode4)) {
56548 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
56549 }
56550 arg4 = static_cast< wxEdge >(val4);
56551 if (obj4) {
56552 ecode5 = SWIG_AsVal_int(obj4, &val5);
56553 if (!SWIG_IsOK(ecode5)) {
56554 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
56555 }
56556 arg5 = static_cast< int >(val5);
56557 }
56558 if (obj5) {
56559 ecode6 = SWIG_AsVal_int(obj5, &val6);
56560 if (!SWIG_IsOK(ecode6)) {
56561 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
56562 }
56563 arg6 = static_cast< int >(val6);
56564 }
56565 {
56566 PyThreadState* __tstate = wxPyBeginAllowThreads();
56567 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
56568 wxPyEndAllowThreads(__tstate);
56569 if (PyErr_Occurred()) SWIG_fail;
56570 }
56571 resultobj = SWIG_Py_Void();
56572 return resultobj;
56573 fail:
56574 return NULL;
56575 }
56576
56577
56578 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56579 PyObject *resultobj = 0;
56580 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56581 wxWindow *arg2 = (wxWindow *) 0 ;
56582 int arg3 = (int) 0 ;
56583 void *argp1 = 0 ;
56584 int res1 = 0 ;
56585 void *argp2 = 0 ;
56586 int res2 = 0 ;
56587 int val3 ;
56588 int ecode3 = 0 ;
56589 PyObject * obj0 = 0 ;
56590 PyObject * obj1 = 0 ;
56591 PyObject * obj2 = 0 ;
56592 char * kwnames[] = {
56593 (char *) "self",(char *) "sibling",(char *) "marg", NULL
56594 };
56595
56596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56598 if (!SWIG_IsOK(res1)) {
56599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56600 }
56601 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56602 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56603 if (!SWIG_IsOK(res2)) {
56604 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
56605 }
56606 arg2 = reinterpret_cast< wxWindow * >(argp2);
56607 if (obj2) {
56608 ecode3 = SWIG_AsVal_int(obj2, &val3);
56609 if (!SWIG_IsOK(ecode3)) {
56610 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
56611 }
56612 arg3 = static_cast< int >(val3);
56613 }
56614 {
56615 PyThreadState* __tstate = wxPyBeginAllowThreads();
56616 (arg1)->LeftOf(arg2,arg3);
56617 wxPyEndAllowThreads(__tstate);
56618 if (PyErr_Occurred()) SWIG_fail;
56619 }
56620 resultobj = SWIG_Py_Void();
56621 return resultobj;
56622 fail:
56623 return NULL;
56624 }
56625
56626
56627 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56628 PyObject *resultobj = 0;
56629 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56630 wxWindow *arg2 = (wxWindow *) 0 ;
56631 int arg3 = (int) 0 ;
56632 void *argp1 = 0 ;
56633 int res1 = 0 ;
56634 void *argp2 = 0 ;
56635 int res2 = 0 ;
56636 int val3 ;
56637 int ecode3 = 0 ;
56638 PyObject * obj0 = 0 ;
56639 PyObject * obj1 = 0 ;
56640 PyObject * obj2 = 0 ;
56641 char * kwnames[] = {
56642 (char *) "self",(char *) "sibling",(char *) "marg", NULL
56643 };
56644
56645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56647 if (!SWIG_IsOK(res1)) {
56648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56649 }
56650 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56651 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56652 if (!SWIG_IsOK(res2)) {
56653 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
56654 }
56655 arg2 = reinterpret_cast< wxWindow * >(argp2);
56656 if (obj2) {
56657 ecode3 = SWIG_AsVal_int(obj2, &val3);
56658 if (!SWIG_IsOK(ecode3)) {
56659 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
56660 }
56661 arg3 = static_cast< int >(val3);
56662 }
56663 {
56664 PyThreadState* __tstate = wxPyBeginAllowThreads();
56665 (arg1)->RightOf(arg2,arg3);
56666 wxPyEndAllowThreads(__tstate);
56667 if (PyErr_Occurred()) SWIG_fail;
56668 }
56669 resultobj = SWIG_Py_Void();
56670 return resultobj;
56671 fail:
56672 return NULL;
56673 }
56674
56675
56676 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56677 PyObject *resultobj = 0;
56678 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56679 wxWindow *arg2 = (wxWindow *) 0 ;
56680 int arg3 = (int) 0 ;
56681 void *argp1 = 0 ;
56682 int res1 = 0 ;
56683 void *argp2 = 0 ;
56684 int res2 = 0 ;
56685 int val3 ;
56686 int ecode3 = 0 ;
56687 PyObject * obj0 = 0 ;
56688 PyObject * obj1 = 0 ;
56689 PyObject * obj2 = 0 ;
56690 char * kwnames[] = {
56691 (char *) "self",(char *) "sibling",(char *) "marg", NULL
56692 };
56693
56694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56696 if (!SWIG_IsOK(res1)) {
56697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56698 }
56699 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56700 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56701 if (!SWIG_IsOK(res2)) {
56702 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
56703 }
56704 arg2 = reinterpret_cast< wxWindow * >(argp2);
56705 if (obj2) {
56706 ecode3 = SWIG_AsVal_int(obj2, &val3);
56707 if (!SWIG_IsOK(ecode3)) {
56708 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
56709 }
56710 arg3 = static_cast< int >(val3);
56711 }
56712 {
56713 PyThreadState* __tstate = wxPyBeginAllowThreads();
56714 (arg1)->Above(arg2,arg3);
56715 wxPyEndAllowThreads(__tstate);
56716 if (PyErr_Occurred()) SWIG_fail;
56717 }
56718 resultobj = SWIG_Py_Void();
56719 return resultobj;
56720 fail:
56721 return NULL;
56722 }
56723
56724
56725 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56726 PyObject *resultobj = 0;
56727 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56728 wxWindow *arg2 = (wxWindow *) 0 ;
56729 int arg3 = (int) 0 ;
56730 void *argp1 = 0 ;
56731 int res1 = 0 ;
56732 void *argp2 = 0 ;
56733 int res2 = 0 ;
56734 int val3 ;
56735 int ecode3 = 0 ;
56736 PyObject * obj0 = 0 ;
56737 PyObject * obj1 = 0 ;
56738 PyObject * obj2 = 0 ;
56739 char * kwnames[] = {
56740 (char *) "self",(char *) "sibling",(char *) "marg", NULL
56741 };
56742
56743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56744 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56745 if (!SWIG_IsOK(res1)) {
56746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56747 }
56748 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56749 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56750 if (!SWIG_IsOK(res2)) {
56751 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
56752 }
56753 arg2 = reinterpret_cast< wxWindow * >(argp2);
56754 if (obj2) {
56755 ecode3 = SWIG_AsVal_int(obj2, &val3);
56756 if (!SWIG_IsOK(ecode3)) {
56757 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
56758 }
56759 arg3 = static_cast< int >(val3);
56760 }
56761 {
56762 PyThreadState* __tstate = wxPyBeginAllowThreads();
56763 (arg1)->Below(arg2,arg3);
56764 wxPyEndAllowThreads(__tstate);
56765 if (PyErr_Occurred()) SWIG_fail;
56766 }
56767 resultobj = SWIG_Py_Void();
56768 return resultobj;
56769 fail:
56770 return NULL;
56771 }
56772
56773
56774 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56775 PyObject *resultobj = 0;
56776 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56777 wxWindow *arg2 = (wxWindow *) 0 ;
56778 wxEdge arg3 ;
56779 int arg4 = (int) 0 ;
56780 void *argp1 = 0 ;
56781 int res1 = 0 ;
56782 void *argp2 = 0 ;
56783 int res2 = 0 ;
56784 int val3 ;
56785 int ecode3 = 0 ;
56786 int val4 ;
56787 int ecode4 = 0 ;
56788 PyObject * obj0 = 0 ;
56789 PyObject * obj1 = 0 ;
56790 PyObject * obj2 = 0 ;
56791 PyObject * obj3 = 0 ;
56792 char * kwnames[] = {
56793 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
56794 };
56795
56796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
56797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56798 if (!SWIG_IsOK(res1)) {
56799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56800 }
56801 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56802 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56803 if (!SWIG_IsOK(res2)) {
56804 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
56805 }
56806 arg2 = reinterpret_cast< wxWindow * >(argp2);
56807 ecode3 = SWIG_AsVal_int(obj2, &val3);
56808 if (!SWIG_IsOK(ecode3)) {
56809 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
56810 }
56811 arg3 = static_cast< wxEdge >(val3);
56812 if (obj3) {
56813 ecode4 = SWIG_AsVal_int(obj3, &val4);
56814 if (!SWIG_IsOK(ecode4)) {
56815 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
56816 }
56817 arg4 = static_cast< int >(val4);
56818 }
56819 {
56820 PyThreadState* __tstate = wxPyBeginAllowThreads();
56821 (arg1)->SameAs(arg2,arg3,arg4);
56822 wxPyEndAllowThreads(__tstate);
56823 if (PyErr_Occurred()) SWIG_fail;
56824 }
56825 resultobj = SWIG_Py_Void();
56826 return resultobj;
56827 fail:
56828 return NULL;
56829 }
56830
56831
56832 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56833 PyObject *resultobj = 0;
56834 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56835 wxWindow *arg2 = (wxWindow *) 0 ;
56836 wxEdge arg3 ;
56837 int arg4 ;
56838 void *argp1 = 0 ;
56839 int res1 = 0 ;
56840 void *argp2 = 0 ;
56841 int res2 = 0 ;
56842 int val3 ;
56843 int ecode3 = 0 ;
56844 int val4 ;
56845 int ecode4 = 0 ;
56846 PyObject * obj0 = 0 ;
56847 PyObject * obj1 = 0 ;
56848 PyObject * obj2 = 0 ;
56849 PyObject * obj3 = 0 ;
56850 char * kwnames[] = {
56851 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
56852 };
56853
56854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
56855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56856 if (!SWIG_IsOK(res1)) {
56857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56858 }
56859 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56860 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56861 if (!SWIG_IsOK(res2)) {
56862 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
56863 }
56864 arg2 = reinterpret_cast< wxWindow * >(argp2);
56865 ecode3 = SWIG_AsVal_int(obj2, &val3);
56866 if (!SWIG_IsOK(ecode3)) {
56867 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
56868 }
56869 arg3 = static_cast< wxEdge >(val3);
56870 ecode4 = SWIG_AsVal_int(obj3, &val4);
56871 if (!SWIG_IsOK(ecode4)) {
56872 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
56873 }
56874 arg4 = static_cast< int >(val4);
56875 {
56876 PyThreadState* __tstate = wxPyBeginAllowThreads();
56877 (arg1)->PercentOf(arg2,arg3,arg4);
56878 wxPyEndAllowThreads(__tstate);
56879 if (PyErr_Occurred()) SWIG_fail;
56880 }
56881 resultobj = SWIG_Py_Void();
56882 return resultobj;
56883 fail:
56884 return NULL;
56885 }
56886
56887
56888 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56889 PyObject *resultobj = 0;
56890 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56891 int arg2 ;
56892 void *argp1 = 0 ;
56893 int res1 = 0 ;
56894 int val2 ;
56895 int ecode2 = 0 ;
56896 PyObject * obj0 = 0 ;
56897 PyObject * obj1 = 0 ;
56898 char * kwnames[] = {
56899 (char *) "self",(char *) "val", NULL
56900 };
56901
56902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
56903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56904 if (!SWIG_IsOK(res1)) {
56905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56906 }
56907 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56908 ecode2 = SWIG_AsVal_int(obj1, &val2);
56909 if (!SWIG_IsOK(ecode2)) {
56910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
56911 }
56912 arg2 = static_cast< int >(val2);
56913 {
56914 PyThreadState* __tstate = wxPyBeginAllowThreads();
56915 (arg1)->Absolute(arg2);
56916 wxPyEndAllowThreads(__tstate);
56917 if (PyErr_Occurred()) SWIG_fail;
56918 }
56919 resultobj = SWIG_Py_Void();
56920 return resultobj;
56921 fail:
56922 return NULL;
56923 }
56924
56925
56926 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56927 PyObject *resultobj = 0;
56928 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56929 void *argp1 = 0 ;
56930 int res1 = 0 ;
56931 PyObject *swig_obj[1] ;
56932
56933 if (!args) SWIG_fail;
56934 swig_obj[0] = args;
56935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56936 if (!SWIG_IsOK(res1)) {
56937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56938 }
56939 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56940 {
56941 PyThreadState* __tstate = wxPyBeginAllowThreads();
56942 (arg1)->Unconstrained();
56943 wxPyEndAllowThreads(__tstate);
56944 if (PyErr_Occurred()) SWIG_fail;
56945 }
56946 resultobj = SWIG_Py_Void();
56947 return resultobj;
56948 fail:
56949 return NULL;
56950 }
56951
56952
56953 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56954 PyObject *resultobj = 0;
56955 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56956 void *argp1 = 0 ;
56957 int res1 = 0 ;
56958 PyObject *swig_obj[1] ;
56959
56960 if (!args) SWIG_fail;
56961 swig_obj[0] = args;
56962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56963 if (!SWIG_IsOK(res1)) {
56964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56965 }
56966 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56967 {
56968 PyThreadState* __tstate = wxPyBeginAllowThreads();
56969 (arg1)->AsIs();
56970 wxPyEndAllowThreads(__tstate);
56971 if (PyErr_Occurred()) SWIG_fail;
56972 }
56973 resultobj = SWIG_Py_Void();
56974 return resultobj;
56975 fail:
56976 return NULL;
56977 }
56978
56979
56980 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56981 PyObject *resultobj = 0;
56982 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56983 wxWindow *result = 0 ;
56984 void *argp1 = 0 ;
56985 int res1 = 0 ;
56986 PyObject *swig_obj[1] ;
56987
56988 if (!args) SWIG_fail;
56989 swig_obj[0] = args;
56990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56991 if (!SWIG_IsOK(res1)) {
56992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56993 }
56994 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56995 {
56996 PyThreadState* __tstate = wxPyBeginAllowThreads();
56997 result = (wxWindow *)(arg1)->GetOtherWindow();
56998 wxPyEndAllowThreads(__tstate);
56999 if (PyErr_Occurred()) SWIG_fail;
57000 }
57001 {
57002 resultobj = wxPyMake_wxObject(result, 0);
57003 }
57004 return resultobj;
57005 fail:
57006 return NULL;
57007 }
57008
57009
57010 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57011 PyObject *resultobj = 0;
57012 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57013 wxEdge result;
57014 void *argp1 = 0 ;
57015 int res1 = 0 ;
57016 PyObject *swig_obj[1] ;
57017
57018 if (!args) SWIG_fail;
57019 swig_obj[0] = args;
57020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57021 if (!SWIG_IsOK(res1)) {
57022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57023 }
57024 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57025 {
57026 PyThreadState* __tstate = wxPyBeginAllowThreads();
57027 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
57028 wxPyEndAllowThreads(__tstate);
57029 if (PyErr_Occurred()) SWIG_fail;
57030 }
57031 resultobj = SWIG_From_int(static_cast< int >(result));
57032 return resultobj;
57033 fail:
57034 return NULL;
57035 }
57036
57037
57038 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57039 PyObject *resultobj = 0;
57040 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57041 wxEdge arg2 ;
57042 void *argp1 = 0 ;
57043 int res1 = 0 ;
57044 int val2 ;
57045 int ecode2 = 0 ;
57046 PyObject * obj0 = 0 ;
57047 PyObject * obj1 = 0 ;
57048 char * kwnames[] = {
57049 (char *) "self",(char *) "which", NULL
57050 };
57051
57052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
57053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57054 if (!SWIG_IsOK(res1)) {
57055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57056 }
57057 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57058 ecode2 = SWIG_AsVal_int(obj1, &val2);
57059 if (!SWIG_IsOK(ecode2)) {
57060 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
57061 }
57062 arg2 = static_cast< wxEdge >(val2);
57063 {
57064 PyThreadState* __tstate = wxPyBeginAllowThreads();
57065 (arg1)->SetEdge(arg2);
57066 wxPyEndAllowThreads(__tstate);
57067 if (PyErr_Occurred()) SWIG_fail;
57068 }
57069 resultobj = SWIG_Py_Void();
57070 return resultobj;
57071 fail:
57072 return NULL;
57073 }
57074
57075
57076 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57077 PyObject *resultobj = 0;
57078 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57079 int arg2 ;
57080 void *argp1 = 0 ;
57081 int res1 = 0 ;
57082 int val2 ;
57083 int ecode2 = 0 ;
57084 PyObject * obj0 = 0 ;
57085 PyObject * obj1 = 0 ;
57086 char * kwnames[] = {
57087 (char *) "self",(char *) "v", NULL
57088 };
57089
57090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
57091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57092 if (!SWIG_IsOK(res1)) {
57093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57094 }
57095 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57096 ecode2 = SWIG_AsVal_int(obj1, &val2);
57097 if (!SWIG_IsOK(ecode2)) {
57098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
57099 }
57100 arg2 = static_cast< int >(val2);
57101 {
57102 PyThreadState* __tstate = wxPyBeginAllowThreads();
57103 (arg1)->SetValue(arg2);
57104 wxPyEndAllowThreads(__tstate);
57105 if (PyErr_Occurred()) SWIG_fail;
57106 }
57107 resultobj = SWIG_Py_Void();
57108 return resultobj;
57109 fail:
57110 return NULL;
57111 }
57112
57113
57114 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57115 PyObject *resultobj = 0;
57116 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57117 int result;
57118 void *argp1 = 0 ;
57119 int res1 = 0 ;
57120 PyObject *swig_obj[1] ;
57121
57122 if (!args) SWIG_fail;
57123 swig_obj[0] = args;
57124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57125 if (!SWIG_IsOK(res1)) {
57126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57127 }
57128 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57129 {
57130 PyThreadState* __tstate = wxPyBeginAllowThreads();
57131 result = (int)(arg1)->GetMargin();
57132 wxPyEndAllowThreads(__tstate);
57133 if (PyErr_Occurred()) SWIG_fail;
57134 }
57135 resultobj = SWIG_From_int(static_cast< int >(result));
57136 return resultobj;
57137 fail:
57138 return NULL;
57139 }
57140
57141
57142 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57143 PyObject *resultobj = 0;
57144 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57145 int arg2 ;
57146 void *argp1 = 0 ;
57147 int res1 = 0 ;
57148 int val2 ;
57149 int ecode2 = 0 ;
57150 PyObject * obj0 = 0 ;
57151 PyObject * obj1 = 0 ;
57152 char * kwnames[] = {
57153 (char *) "self",(char *) "m", NULL
57154 };
57155
57156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
57157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57158 if (!SWIG_IsOK(res1)) {
57159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57160 }
57161 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57162 ecode2 = SWIG_AsVal_int(obj1, &val2);
57163 if (!SWIG_IsOK(ecode2)) {
57164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
57165 }
57166 arg2 = static_cast< int >(val2);
57167 {
57168 PyThreadState* __tstate = wxPyBeginAllowThreads();
57169 (arg1)->SetMargin(arg2);
57170 wxPyEndAllowThreads(__tstate);
57171 if (PyErr_Occurred()) SWIG_fail;
57172 }
57173 resultobj = SWIG_Py_Void();
57174 return resultobj;
57175 fail:
57176 return NULL;
57177 }
57178
57179
57180 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57181 PyObject *resultobj = 0;
57182 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57183 int result;
57184 void *argp1 = 0 ;
57185 int res1 = 0 ;
57186 PyObject *swig_obj[1] ;
57187
57188 if (!args) SWIG_fail;
57189 swig_obj[0] = args;
57190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57191 if (!SWIG_IsOK(res1)) {
57192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57193 }
57194 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57195 {
57196 PyThreadState* __tstate = wxPyBeginAllowThreads();
57197 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
57198 wxPyEndAllowThreads(__tstate);
57199 if (PyErr_Occurred()) SWIG_fail;
57200 }
57201 resultobj = SWIG_From_int(static_cast< int >(result));
57202 return resultobj;
57203 fail:
57204 return NULL;
57205 }
57206
57207
57208 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57209 PyObject *resultobj = 0;
57210 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57211 int result;
57212 void *argp1 = 0 ;
57213 int res1 = 0 ;
57214 PyObject *swig_obj[1] ;
57215
57216 if (!args) SWIG_fail;
57217 swig_obj[0] = args;
57218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57219 if (!SWIG_IsOK(res1)) {
57220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57221 }
57222 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57223 {
57224 PyThreadState* __tstate = wxPyBeginAllowThreads();
57225 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
57226 wxPyEndAllowThreads(__tstate);
57227 if (PyErr_Occurred()) SWIG_fail;
57228 }
57229 resultobj = SWIG_From_int(static_cast< int >(result));
57230 return resultobj;
57231 fail:
57232 return NULL;
57233 }
57234
57235
57236 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57237 PyObject *resultobj = 0;
57238 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57239 int result;
57240 void *argp1 = 0 ;
57241 int res1 = 0 ;
57242 PyObject *swig_obj[1] ;
57243
57244 if (!args) SWIG_fail;
57245 swig_obj[0] = args;
57246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57247 if (!SWIG_IsOK(res1)) {
57248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57249 }
57250 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57251 {
57252 PyThreadState* __tstate = wxPyBeginAllowThreads();
57253 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
57254 wxPyEndAllowThreads(__tstate);
57255 if (PyErr_Occurred()) SWIG_fail;
57256 }
57257 resultobj = SWIG_From_int(static_cast< int >(result));
57258 return resultobj;
57259 fail:
57260 return NULL;
57261 }
57262
57263
57264 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57265 PyObject *resultobj = 0;
57266 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57267 bool result;
57268 void *argp1 = 0 ;
57269 int res1 = 0 ;
57270 PyObject *swig_obj[1] ;
57271
57272 if (!args) SWIG_fail;
57273 swig_obj[0] = args;
57274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57275 if (!SWIG_IsOK(res1)) {
57276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57277 }
57278 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57279 {
57280 PyThreadState* __tstate = wxPyBeginAllowThreads();
57281 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
57282 wxPyEndAllowThreads(__tstate);
57283 if (PyErr_Occurred()) SWIG_fail;
57284 }
57285 {
57286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57287 }
57288 return resultobj;
57289 fail:
57290 return NULL;
57291 }
57292
57293
57294 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57295 PyObject *resultobj = 0;
57296 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57297 bool arg2 ;
57298 void *argp1 = 0 ;
57299 int res1 = 0 ;
57300 bool val2 ;
57301 int ecode2 = 0 ;
57302 PyObject * obj0 = 0 ;
57303 PyObject * obj1 = 0 ;
57304 char * kwnames[] = {
57305 (char *) "self",(char *) "d", NULL
57306 };
57307
57308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
57309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57310 if (!SWIG_IsOK(res1)) {
57311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57312 }
57313 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57314 ecode2 = SWIG_AsVal_bool(obj1, &val2);
57315 if (!SWIG_IsOK(ecode2)) {
57316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
57317 }
57318 arg2 = static_cast< bool >(val2);
57319 {
57320 PyThreadState* __tstate = wxPyBeginAllowThreads();
57321 (arg1)->SetDone(arg2);
57322 wxPyEndAllowThreads(__tstate);
57323 if (PyErr_Occurred()) SWIG_fail;
57324 }
57325 resultobj = SWIG_Py_Void();
57326 return resultobj;
57327 fail:
57328 return NULL;
57329 }
57330
57331
57332 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57333 PyObject *resultobj = 0;
57334 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57335 wxRelationship result;
57336 void *argp1 = 0 ;
57337 int res1 = 0 ;
57338 PyObject *swig_obj[1] ;
57339
57340 if (!args) SWIG_fail;
57341 swig_obj[0] = args;
57342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57343 if (!SWIG_IsOK(res1)) {
57344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57345 }
57346 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57347 {
57348 PyThreadState* __tstate = wxPyBeginAllowThreads();
57349 result = (wxRelationship)(arg1)->GetRelationship();
57350 wxPyEndAllowThreads(__tstate);
57351 if (PyErr_Occurred()) SWIG_fail;
57352 }
57353 resultobj = SWIG_From_int(static_cast< int >(result));
57354 return resultobj;
57355 fail:
57356 return NULL;
57357 }
57358
57359
57360 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57361 PyObject *resultobj = 0;
57362 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57363 wxRelationship arg2 ;
57364 void *argp1 = 0 ;
57365 int res1 = 0 ;
57366 int val2 ;
57367 int ecode2 = 0 ;
57368 PyObject * obj0 = 0 ;
57369 PyObject * obj1 = 0 ;
57370 char * kwnames[] = {
57371 (char *) "self",(char *) "r", NULL
57372 };
57373
57374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
57375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57376 if (!SWIG_IsOK(res1)) {
57377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57378 }
57379 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57380 ecode2 = SWIG_AsVal_int(obj1, &val2);
57381 if (!SWIG_IsOK(ecode2)) {
57382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
57383 }
57384 arg2 = static_cast< wxRelationship >(val2);
57385 {
57386 PyThreadState* __tstate = wxPyBeginAllowThreads();
57387 (arg1)->SetRelationship(arg2);
57388 wxPyEndAllowThreads(__tstate);
57389 if (PyErr_Occurred()) SWIG_fail;
57390 }
57391 resultobj = SWIG_Py_Void();
57392 return resultobj;
57393 fail:
57394 return NULL;
57395 }
57396
57397
57398 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57399 PyObject *resultobj = 0;
57400 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57401 wxWindow *arg2 = (wxWindow *) 0 ;
57402 bool result;
57403 void *argp1 = 0 ;
57404 int res1 = 0 ;
57405 void *argp2 = 0 ;
57406 int res2 = 0 ;
57407 PyObject * obj0 = 0 ;
57408 PyObject * obj1 = 0 ;
57409 char * kwnames[] = {
57410 (char *) "self",(char *) "otherW", NULL
57411 };
57412
57413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
57414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57415 if (!SWIG_IsOK(res1)) {
57416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57417 }
57418 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57419 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57420 if (!SWIG_IsOK(res2)) {
57421 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
57422 }
57423 arg2 = reinterpret_cast< wxWindow * >(argp2);
57424 {
57425 PyThreadState* __tstate = wxPyBeginAllowThreads();
57426 result = (bool)(arg1)->ResetIfWin(arg2);
57427 wxPyEndAllowThreads(__tstate);
57428 if (PyErr_Occurred()) SWIG_fail;
57429 }
57430 {
57431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57432 }
57433 return resultobj;
57434 fail:
57435 return NULL;
57436 }
57437
57438
57439 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57440 PyObject *resultobj = 0;
57441 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57442 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
57443 wxWindow *arg3 = (wxWindow *) 0 ;
57444 bool result;
57445 void *argp1 = 0 ;
57446 int res1 = 0 ;
57447 void *argp2 = 0 ;
57448 int res2 = 0 ;
57449 void *argp3 = 0 ;
57450 int res3 = 0 ;
57451 PyObject * obj0 = 0 ;
57452 PyObject * obj1 = 0 ;
57453 PyObject * obj2 = 0 ;
57454 char * kwnames[] = {
57455 (char *) "self",(char *) "constraints",(char *) "win", NULL
57456 };
57457
57458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
57459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57460 if (!SWIG_IsOK(res1)) {
57461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57462 }
57463 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57464 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57465 if (!SWIG_IsOK(res2)) {
57466 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
57467 }
57468 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
57469 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
57470 if (!SWIG_IsOK(res3)) {
57471 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
57472 }
57473 arg3 = reinterpret_cast< wxWindow * >(argp3);
57474 {
57475 PyThreadState* __tstate = wxPyBeginAllowThreads();
57476 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
57477 wxPyEndAllowThreads(__tstate);
57478 if (PyErr_Occurred()) SWIG_fail;
57479 }
57480 {
57481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57482 }
57483 return resultobj;
57484 fail:
57485 return NULL;
57486 }
57487
57488
57489 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57490 PyObject *resultobj = 0;
57491 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57492 wxEdge arg2 ;
57493 wxWindow *arg3 = (wxWindow *) 0 ;
57494 wxWindow *arg4 = (wxWindow *) 0 ;
57495 int result;
57496 void *argp1 = 0 ;
57497 int res1 = 0 ;
57498 int val2 ;
57499 int ecode2 = 0 ;
57500 void *argp3 = 0 ;
57501 int res3 = 0 ;
57502 void *argp4 = 0 ;
57503 int res4 = 0 ;
57504 PyObject * obj0 = 0 ;
57505 PyObject * obj1 = 0 ;
57506 PyObject * obj2 = 0 ;
57507 PyObject * obj3 = 0 ;
57508 char * kwnames[] = {
57509 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
57510 };
57511
57512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
57513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57514 if (!SWIG_IsOK(res1)) {
57515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57516 }
57517 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57518 ecode2 = SWIG_AsVal_int(obj1, &val2);
57519 if (!SWIG_IsOK(ecode2)) {
57520 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
57521 }
57522 arg2 = static_cast< wxEdge >(val2);
57523 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
57524 if (!SWIG_IsOK(res3)) {
57525 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
57526 }
57527 arg3 = reinterpret_cast< wxWindow * >(argp3);
57528 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
57529 if (!SWIG_IsOK(res4)) {
57530 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
57531 }
57532 arg4 = reinterpret_cast< wxWindow * >(argp4);
57533 {
57534 PyThreadState* __tstate = wxPyBeginAllowThreads();
57535 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
57536 wxPyEndAllowThreads(__tstate);
57537 if (PyErr_Occurred()) SWIG_fail;
57538 }
57539 resultobj = SWIG_From_int(static_cast< int >(result));
57540 return resultobj;
57541 fail:
57542 return NULL;
57543 }
57544
57545
57546 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57547 PyObject *obj;
57548 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
57549 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
57550 return SWIG_Py_Void();
57551 }
57552
57553 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57554 PyObject *resultobj = 0;
57555 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57556 wxIndividualLayoutConstraint *result = 0 ;
57557 void *argp1 = 0 ;
57558 int res1 = 0 ;
57559 PyObject *swig_obj[1] ;
57560
57561 if (!args) SWIG_fail;
57562 swig_obj[0] = args;
57563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57564 if (!SWIG_IsOK(res1)) {
57565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57566 }
57567 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57568 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
57569 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57570 return resultobj;
57571 fail:
57572 return NULL;
57573 }
57574
57575
57576 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57577 PyObject *resultobj = 0;
57578 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57579 wxIndividualLayoutConstraint *result = 0 ;
57580 void *argp1 = 0 ;
57581 int res1 = 0 ;
57582 PyObject *swig_obj[1] ;
57583
57584 if (!args) SWIG_fail;
57585 swig_obj[0] = args;
57586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57587 if (!SWIG_IsOK(res1)) {
57588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57589 }
57590 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57591 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
57592 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57593 return resultobj;
57594 fail:
57595 return NULL;
57596 }
57597
57598
57599 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57600 PyObject *resultobj = 0;
57601 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57602 wxIndividualLayoutConstraint *result = 0 ;
57603 void *argp1 = 0 ;
57604 int res1 = 0 ;
57605 PyObject *swig_obj[1] ;
57606
57607 if (!args) SWIG_fail;
57608 swig_obj[0] = args;
57609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57610 if (!SWIG_IsOK(res1)) {
57611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57612 }
57613 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57614 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
57615 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57616 return resultobj;
57617 fail:
57618 return NULL;
57619 }
57620
57621
57622 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57623 PyObject *resultobj = 0;
57624 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57625 wxIndividualLayoutConstraint *result = 0 ;
57626 void *argp1 = 0 ;
57627 int res1 = 0 ;
57628 PyObject *swig_obj[1] ;
57629
57630 if (!args) SWIG_fail;
57631 swig_obj[0] = args;
57632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57633 if (!SWIG_IsOK(res1)) {
57634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57635 }
57636 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57637 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
57638 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57639 return resultobj;
57640 fail:
57641 return NULL;
57642 }
57643
57644
57645 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57646 PyObject *resultobj = 0;
57647 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57648 wxIndividualLayoutConstraint *result = 0 ;
57649 void *argp1 = 0 ;
57650 int res1 = 0 ;
57651 PyObject *swig_obj[1] ;
57652
57653 if (!args) SWIG_fail;
57654 swig_obj[0] = args;
57655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57656 if (!SWIG_IsOK(res1)) {
57657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57658 }
57659 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57660 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
57661 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57662 return resultobj;
57663 fail:
57664 return NULL;
57665 }
57666
57667
57668 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57669 PyObject *resultobj = 0;
57670 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57671 wxIndividualLayoutConstraint *result = 0 ;
57672 void *argp1 = 0 ;
57673 int res1 = 0 ;
57674 PyObject *swig_obj[1] ;
57675
57676 if (!args) SWIG_fail;
57677 swig_obj[0] = args;
57678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57679 if (!SWIG_IsOK(res1)) {
57680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57681 }
57682 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57683 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
57684 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57685 return resultobj;
57686 fail:
57687 return NULL;
57688 }
57689
57690
57691 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57692 PyObject *resultobj = 0;
57693 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57694 wxIndividualLayoutConstraint *result = 0 ;
57695 void *argp1 = 0 ;
57696 int res1 = 0 ;
57697 PyObject *swig_obj[1] ;
57698
57699 if (!args) SWIG_fail;
57700 swig_obj[0] = args;
57701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57702 if (!SWIG_IsOK(res1)) {
57703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57704 }
57705 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57706 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
57707 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57708 return resultobj;
57709 fail:
57710 return NULL;
57711 }
57712
57713
57714 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57715 PyObject *resultobj = 0;
57716 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57717 wxIndividualLayoutConstraint *result = 0 ;
57718 void *argp1 = 0 ;
57719 int res1 = 0 ;
57720 PyObject *swig_obj[1] ;
57721
57722 if (!args) SWIG_fail;
57723 swig_obj[0] = args;
57724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57725 if (!SWIG_IsOK(res1)) {
57726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57727 }
57728 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57729 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
57730 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57731 return resultobj;
57732 fail:
57733 return NULL;
57734 }
57735
57736
57737 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57738 PyObject *resultobj = 0;
57739 wxLayoutConstraints *result = 0 ;
57740
57741 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
57742 {
57743 PyThreadState* __tstate = wxPyBeginAllowThreads();
57744 result = (wxLayoutConstraints *)new wxLayoutConstraints();
57745 wxPyEndAllowThreads(__tstate);
57746 if (PyErr_Occurred()) SWIG_fail;
57747 }
57748 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
57749 return resultobj;
57750 fail:
57751 return NULL;
57752 }
57753
57754
57755 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57756 PyObject *resultobj = 0;
57757 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57758 void *argp1 = 0 ;
57759 int res1 = 0 ;
57760 PyObject *swig_obj[1] ;
57761
57762 if (!args) SWIG_fail;
57763 swig_obj[0] = args;
57764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
57765 if (!SWIG_IsOK(res1)) {
57766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57767 }
57768 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57769 {
57770 PyThreadState* __tstate = wxPyBeginAllowThreads();
57771 delete arg1;
57772
57773 wxPyEndAllowThreads(__tstate);
57774 if (PyErr_Occurred()) SWIG_fail;
57775 }
57776 resultobj = SWIG_Py_Void();
57777 return resultobj;
57778 fail:
57779 return NULL;
57780 }
57781
57782
57783 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57784 PyObject *resultobj = 0;
57785 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57786 wxWindow *arg2 = (wxWindow *) 0 ;
57787 int *arg3 = (int *) 0 ;
57788 bool result;
57789 void *argp1 = 0 ;
57790 int res1 = 0 ;
57791 void *argp2 = 0 ;
57792 int res2 = 0 ;
57793 int temp3 ;
57794 int res3 = SWIG_TMPOBJ ;
57795 PyObject * obj0 = 0 ;
57796 PyObject * obj1 = 0 ;
57797 char * kwnames[] = {
57798 (char *) "self",(char *) "win", NULL
57799 };
57800
57801 arg3 = &temp3;
57802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
57803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57804 if (!SWIG_IsOK(res1)) {
57805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
57806 }
57807 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57808 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57809 if (!SWIG_IsOK(res2)) {
57810 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
57811 }
57812 arg2 = reinterpret_cast< wxWindow * >(argp2);
57813 {
57814 PyThreadState* __tstate = wxPyBeginAllowThreads();
57815 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
57816 wxPyEndAllowThreads(__tstate);
57817 if (PyErr_Occurred()) SWIG_fail;
57818 }
57819 {
57820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57821 }
57822 if (SWIG_IsTmpObj(res3)) {
57823 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
57824 } else {
57825 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
57826 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
57827 }
57828 return resultobj;
57829 fail:
57830 return NULL;
57831 }
57832
57833
57834 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57835 PyObject *resultobj = 0;
57836 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
57837 bool result;
57838 void *argp1 = 0 ;
57839 int res1 = 0 ;
57840 PyObject *swig_obj[1] ;
57841
57842 if (!args) SWIG_fail;
57843 swig_obj[0] = args;
57844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57845 if (!SWIG_IsOK(res1)) {
57846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
57847 }
57848 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
57849 {
57850 PyThreadState* __tstate = wxPyBeginAllowThreads();
57851 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
57852 wxPyEndAllowThreads(__tstate);
57853 if (PyErr_Occurred()) SWIG_fail;
57854 }
57855 {
57856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57857 }
57858 return resultobj;
57859 fail:
57860 return NULL;
57861 }
57862
57863
57864 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57865 PyObject *obj;
57866 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
57867 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
57868 return SWIG_Py_Void();
57869 }
57870
57871 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57872 return SWIG_Python_InitShadowInstance(args);
57873 }
57874
57875 static PyMethodDef SwigMethods[] = {
57876 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
57877 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
57878 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
57879 { (char *)"Object_IsSameAs", (PyCFunction) _wrap_Object_IsSameAs, METH_VARARGS | METH_KEYWORDS, NULL},
57880 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
57881 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
57882 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
57883 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
57884 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
57885 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
57886 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
57887 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57888 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57889 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
57890 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
57891 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
57892 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
57893 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
57894 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
57895 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
57896 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57897 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
57898 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
57899 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
57900 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
57901 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
57902 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
57903 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
57904 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
57905 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
57906 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
57907 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
57908 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
57909 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
57910 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57911 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
57912 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57913 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57914 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
57915 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
57916 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57917 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
57918 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
57919 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
57920 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
57921 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
57922 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
57923 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
57924 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
57925 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
57926 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57927 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57928 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
57929 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
57930 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
57931 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
57932 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57933 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
57934 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
57935 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
57936 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
57937 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
57938 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
57939 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
57940 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
57941 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
57942 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
57943 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
57944 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
57945 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
57946 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
57947 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
57948 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
57949 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
57950 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57951 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
57952 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57953 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
57954 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
57955 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
57956 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
57957 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
57958 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
57959 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
57960 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
57961 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
57962 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
57963 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
57964 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
57965 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
57966 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
57967 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
57968 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
57969 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
57970 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
57971 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
57972 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
57973 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
57974 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
57975 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
57976 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
57977 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
57978 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57979 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57980 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
57981 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
57982 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
57983 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
57984 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
57985 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
57986 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
57987 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
57988 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
57989 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
57990 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
57991 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
57992 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
57993 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57994 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
57995 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
57996 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
57997 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
57998 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
57999 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
58000 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
58001 { (char *)"delete_Point2D", (PyCFunction)_wrap_delete_Point2D, METH_O, NULL},
58002 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
58003 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
58004 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
58005 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
58006 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
58007 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
58008 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
58009 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
58010 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
58011 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
58012 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
58013 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
58014 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
58015 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
58016 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
58017 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58018 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58019 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
58020 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
58021 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
58022 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
58023 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58024 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
58025 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
58026 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
58027 { (char *)"new_Rect2D", (PyCFunction) _wrap_new_Rect2D, METH_VARARGS | METH_KEYWORDS, NULL},
58028 { (char *)"delete_Rect2D", (PyCFunction)_wrap_delete_Rect2D, METH_O, NULL},
58029 { (char *)"Rect2D_GetPosition", (PyCFunction)_wrap_Rect2D_GetPosition, METH_O, NULL},
58030 { (char *)"Rect2D_GetSize", (PyCFunction)_wrap_Rect2D_GetSize, METH_O, NULL},
58031 { (char *)"Rect2D_GetLeft", (PyCFunction)_wrap_Rect2D_GetLeft, METH_O, NULL},
58032 { (char *)"Rect2D_SetLeft", (PyCFunction) _wrap_Rect2D_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
58033 { (char *)"Rect2D_MoveLeftTo", (PyCFunction) _wrap_Rect2D_MoveLeftTo, METH_VARARGS | METH_KEYWORDS, NULL},
58034 { (char *)"Rect2D_GetTop", (PyCFunction)_wrap_Rect2D_GetTop, METH_O, NULL},
58035 { (char *)"Rect2D_SetTop", (PyCFunction) _wrap_Rect2D_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
58036 { (char *)"Rect2D_MoveTopTo", (PyCFunction) _wrap_Rect2D_MoveTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
58037 { (char *)"Rect2D_GetBottom", (PyCFunction)_wrap_Rect2D_GetBottom, METH_O, NULL},
58038 { (char *)"Rect2D_SetBottom", (PyCFunction) _wrap_Rect2D_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
58039 { (char *)"Rect2D_MoveBottomTo", (PyCFunction) _wrap_Rect2D_MoveBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
58040 { (char *)"Rect2D_GetRight", (PyCFunction)_wrap_Rect2D_GetRight, METH_O, NULL},
58041 { (char *)"Rect2D_SetRight", (PyCFunction) _wrap_Rect2D_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
58042 { (char *)"Rect2D_MoveRightTo", (PyCFunction) _wrap_Rect2D_MoveRightTo, METH_VARARGS | METH_KEYWORDS, NULL},
58043 { (char *)"Rect2D_GetLeftTop", (PyCFunction)_wrap_Rect2D_GetLeftTop, METH_O, NULL},
58044 { (char *)"Rect2D_SetLeftTop", (PyCFunction) _wrap_Rect2D_SetLeftTop, METH_VARARGS | METH_KEYWORDS, NULL},
58045 { (char *)"Rect2D_MoveLeftTopTo", (PyCFunction) _wrap_Rect2D_MoveLeftTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
58046 { (char *)"Rect2D_GetLeftBottom", (PyCFunction)_wrap_Rect2D_GetLeftBottom, METH_O, NULL},
58047 { (char *)"Rect2D_SetLeftBottom", (PyCFunction) _wrap_Rect2D_SetLeftBottom, METH_VARARGS | METH_KEYWORDS, NULL},
58048 { (char *)"Rect2D_MoveLeftBottomTo", (PyCFunction) _wrap_Rect2D_MoveLeftBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
58049 { (char *)"Rect2D_GetRightTop", (PyCFunction)_wrap_Rect2D_GetRightTop, METH_O, NULL},
58050 { (char *)"Rect2D_SetRightTop", (PyCFunction) _wrap_Rect2D_SetRightTop, METH_VARARGS | METH_KEYWORDS, NULL},
58051 { (char *)"Rect2D_MoveRightTopTo", (PyCFunction) _wrap_Rect2D_MoveRightTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
58052 { (char *)"Rect2D_GetRightBottom", (PyCFunction)_wrap_Rect2D_GetRightBottom, METH_O, NULL},
58053 { (char *)"Rect2D_SetRightBottom", (PyCFunction) _wrap_Rect2D_SetRightBottom, METH_VARARGS | METH_KEYWORDS, NULL},
58054 { (char *)"Rect2D_MoveRightBottomTo", (PyCFunction) _wrap_Rect2D_MoveRightBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
58055 { (char *)"Rect2D_GetCentre", (PyCFunction)_wrap_Rect2D_GetCentre, METH_O, NULL},
58056 { (char *)"Rect2D_SetCentre", (PyCFunction) _wrap_Rect2D_SetCentre, METH_VARARGS | METH_KEYWORDS, NULL},
58057 { (char *)"Rect2D_MoveCentreTo", (PyCFunction) _wrap_Rect2D_MoveCentreTo, METH_VARARGS | METH_KEYWORDS, NULL},
58058 { (char *)"Rect2D_GetOutcode", (PyCFunction) _wrap_Rect2D_GetOutcode, METH_VARARGS | METH_KEYWORDS, NULL},
58059 { (char *)"Rect2D_Contains", (PyCFunction) _wrap_Rect2D_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
58060 { (char *)"Rect2D_ContainsRect", (PyCFunction) _wrap_Rect2D_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
58061 { (char *)"Rect2D_IsEmpty", (PyCFunction)_wrap_Rect2D_IsEmpty, METH_O, NULL},
58062 { (char *)"Rect2D_HaveEqualSize", (PyCFunction) _wrap_Rect2D_HaveEqualSize, METH_VARARGS | METH_KEYWORDS, NULL},
58063 { (char *)"Rect2D_Inset", _wrap_Rect2D_Inset, METH_VARARGS, NULL},
58064 { (char *)"Rect2D_Offset", (PyCFunction) _wrap_Rect2D_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
58065 { (char *)"Rect2D_ConstrainTo", (PyCFunction) _wrap_Rect2D_ConstrainTo, METH_VARARGS | METH_KEYWORDS, NULL},
58066 { (char *)"Rect2D_Interpolate", (PyCFunction) _wrap_Rect2D_Interpolate, METH_VARARGS | METH_KEYWORDS, NULL},
58067 { (char *)"Rect2D_Intersect", (PyCFunction) _wrap_Rect2D_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
58068 { (char *)"Rect2D_CreateIntersection", (PyCFunction) _wrap_Rect2D_CreateIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
58069 { (char *)"Rect2D_Intersects", (PyCFunction) _wrap_Rect2D_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
58070 { (char *)"Rect2D_Union", (PyCFunction) _wrap_Rect2D_Union, METH_VARARGS | METH_KEYWORDS, NULL},
58071 { (char *)"Rect2D_CreateUnion", (PyCFunction) _wrap_Rect2D_CreateUnion, METH_VARARGS | METH_KEYWORDS, NULL},
58072 { (char *)"Rect2D_Scale", _wrap_Rect2D_Scale, METH_VARARGS, NULL},
58073 { (char *)"Rect2D___eq__", (PyCFunction) _wrap_Rect2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58074 { (char *)"Rect2D___ne__", (PyCFunction) _wrap_Rect2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58075 { (char *)"Rect2D_x_set", _wrap_Rect2D_x_set, METH_VARARGS, NULL},
58076 { (char *)"Rect2D_x_get", (PyCFunction)_wrap_Rect2D_x_get, METH_O, NULL},
58077 { (char *)"Rect2D_y_set", _wrap_Rect2D_y_set, METH_VARARGS, NULL},
58078 { (char *)"Rect2D_y_get", (PyCFunction)_wrap_Rect2D_y_get, METH_O, NULL},
58079 { (char *)"Rect2D_width_set", _wrap_Rect2D_width_set, METH_VARARGS, NULL},
58080 { (char *)"Rect2D_width_get", (PyCFunction)_wrap_Rect2D_width_get, METH_O, NULL},
58081 { (char *)"Rect2D_height_set", _wrap_Rect2D_height_set, METH_VARARGS, NULL},
58082 { (char *)"Rect2D_height_get", (PyCFunction)_wrap_Rect2D_height_get, METH_O, NULL},
58083 { (char *)"Rect2D_Set", (PyCFunction) _wrap_Rect2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58084 { (char *)"Rect2D_Get", (PyCFunction)_wrap_Rect2D_Get, METH_O, NULL},
58085 { (char *)"Rect2D_swigregister", Rect2D_swigregister, METH_VARARGS, NULL},
58086 { (char *)"Rect2D_swiginit", Rect2D_swiginit, METH_VARARGS, NULL},
58087 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
58088 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
58089 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
58090 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
58091 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
58092 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
58093 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
58094 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
58095 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
58096 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
58097 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
58098 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
58099 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
58100 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
58101 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
58102 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
58103 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
58104 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
58105 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
58106 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
58107 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
58108 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
58109 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
58110 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
58111 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
58112 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
58113 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
58114 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
58115 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
58116 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
58117 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
58118 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
58119 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
58120 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
58121 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
58122 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
58123 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
58124 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
58125 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58126 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
58127 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
58128 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
58129 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
58130 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
58131 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
58132 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
58133 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
58134 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
58135 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
58136 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
58137 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
58138 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
58139 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58140 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
58141 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
58142 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58143 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58144 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
58145 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
58146 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
58147 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
58148 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
58149 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
58150 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
58151 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58152 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
58153 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
58154 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
58155 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
58156 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58157 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
58158 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
58159 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
58160 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
58161 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
58162 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58163 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
58164 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
58165 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
58166 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
58167 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58168 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
58169 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
58170 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
58171 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
58172 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
58173 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
58174 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
58175 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
58176 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
58177 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
58178 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
58179 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
58180 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
58181 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
58182 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
58183 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
58184 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
58185 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
58186 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
58187 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
58188 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
58189 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
58190 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
58191 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
58192 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
58193 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
58194 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
58195 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
58196 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
58197 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
58198 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
58199 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
58200 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
58201 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
58202 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
58203 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
58204 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
58205 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
58206 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
58207 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
58208 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
58209 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
58210 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
58211 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
58212 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
58213 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
58214 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
58215 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
58216 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
58217 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
58218 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
58219 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58220 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
58221 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58222 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
58223 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
58224 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
58225 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
58226 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
58227 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
58228 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
58229 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
58230 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
58231 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
58232 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
58233 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
58234 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
58235 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
58236 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
58237 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
58238 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58239 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58240 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
58241 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
58242 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
58243 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
58244 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
58245 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58246 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
58247 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
58248 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
58249 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
58250 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
58251 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
58252 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
58253 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
58254 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
58255 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
58256 { (char *)"Image_IsOk", (PyCFunction)_wrap_Image_IsOk, METH_O, NULL},
58257 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
58258 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
58259 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
58260 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
58261 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
58262 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
58263 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
58264 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
58265 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
58266 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
58267 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
58268 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
58269 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
58270 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
58271 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
58272 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
58273 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
58274 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
58275 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
58276 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
58277 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
58278 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
58279 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
58280 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
58281 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
58282 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
58283 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
58284 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
58285 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
58286 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
58287 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
58288 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
58289 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
58290 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
58291 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
58292 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58293 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58294 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58295 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
58296 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
58297 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58298 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58299 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
58300 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
58301 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
58302 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
58303 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
58304 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
58305 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
58306 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
58307 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
58308 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
58309 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
58310 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
58311 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
58312 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
58313 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
58314 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
58315 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
58316 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
58317 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
58318 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
58319 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
58320 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
58321 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
58322 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
58323 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
58324 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
58325 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
58326 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
58327 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
58328 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
58329 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
58330 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
58331 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
58332 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
58333 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
58334 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
58335 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
58336 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
58337 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
58338 { (char *)"new_TGAHandler", (PyCFunction)_wrap_new_TGAHandler, METH_NOARGS, NULL},
58339 { (char *)"TGAHandler_swigregister", TGAHandler_swigregister, METH_VARARGS, NULL},
58340 { (char *)"TGAHandler_swiginit", TGAHandler_swiginit, METH_VARARGS, NULL},
58341 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
58342 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
58343 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
58344 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
58345 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
58346 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58347 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58348 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
58349 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
58350 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58351 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58352 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
58353 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
58354 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
58355 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
58356 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
58357 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
58358 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
58359 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
58360 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
58361 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
58362 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
58363 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
58364 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
58365 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
58366 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
58367 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
58368 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
58369 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
58370 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
58371 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
58372 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
58373 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
58374 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
58375 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
58376 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
58377 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
58378 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
58379 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
58380 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
58381 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
58382 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
58383 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
58384 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58385 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
58386 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
58387 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
58388 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
58389 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
58390 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
58391 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
58392 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
58393 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
58394 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
58395 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
58396 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
58397 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
58398 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
58399 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58400 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
58401 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
58402 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
58403 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
58404 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
58405 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58406 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
58407 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
58408 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
58409 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58410 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
58411 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
58412 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58413 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
58414 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
58415 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
58416 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58417 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
58418 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
58419 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58420 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
58421 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
58422 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
58423 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
58424 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
58425 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
58426 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
58427 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
58428 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
58429 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
58430 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
58431 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
58432 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
58433 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
58434 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
58435 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
58436 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
58437 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
58438 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
58439 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
58440 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
58441 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
58442 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
58443 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
58444 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
58445 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
58446 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
58447 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
58448 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
58449 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
58450 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58451 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
58452 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
58453 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
58454 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
58455 { (char *)"MouseEvent_GetWheelAxis", (PyCFunction)_wrap_MouseEvent_GetWheelAxis, METH_O, NULL},
58456 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
58457 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
58458 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
58459 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
58460 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
58461 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
58462 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
58463 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
58464 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
58465 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
58466 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
58467 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
58468 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
58469 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
58470 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
58471 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
58472 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
58473 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
58474 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
58475 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
58476 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
58477 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
58478 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
58479 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
58480 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
58481 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
58482 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
58483 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
58484 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58485 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
58486 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
58487 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
58488 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
58489 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
58490 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
58491 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
58492 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58493 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
58494 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
58495 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
58496 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
58497 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
58498 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
58499 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
58500 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
58501 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
58502 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
58503 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
58504 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
58505 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
58506 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
58507 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
58508 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
58509 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
58510 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
58511 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
58512 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
58513 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
58514 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
58515 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
58516 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
58517 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
58518 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
58519 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
58520 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
58521 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
58522 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
58523 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
58524 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
58525 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
58526 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
58527 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
58528 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
58529 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
58530 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
58531 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58532 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
58533 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
58534 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
58535 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
58536 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
58537 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
58538 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
58539 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
58540 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
58541 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
58542 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58543 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
58544 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
58545 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
58546 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58547 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
58548 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
58549 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58550 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
58551 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
58552 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58553 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
58554 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
58555 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58556 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
58557 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
58558 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
58559 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58560 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
58561 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
58562 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
58563 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
58564 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58565 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
58566 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
58567 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
58568 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58569 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
58570 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
58571 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
58572 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58573 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
58574 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
58575 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58576 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
58577 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
58578 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
58579 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
58580 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
58581 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58582 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
58583 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
58584 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
58585 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
58586 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
58587 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
58588 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
58589 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
58590 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58591 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
58592 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
58593 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
58594 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
58595 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58596 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
58597 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
58598 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
58599 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58600 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
58601 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
58602 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
58603 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
58604 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
58605 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
58606 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58607 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
58608 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
58609 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
58610 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
58611 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
58612 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
58613 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
58614 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
58615 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
58616 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
58617 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
58618 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
58619 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
58620 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
58621 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
58622 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
58623 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
58624 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
58625 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
58626 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
58627 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
58628 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
58629 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
58630 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58631 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
58632 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
58633 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
58634 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58635 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
58636 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
58637 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
58638 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
58639 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
58640 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58641 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
58642 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
58643 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
58644 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
58645 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58646 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
58647 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
58648 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
58649 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
58650 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
58651 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
58652 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
58653 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
58654 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
58655 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
58656 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
58657 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
58658 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
58659 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
58660 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
58661 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
58662 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58663 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
58664 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
58665 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
58666 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58667 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
58668 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
58669 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
58670 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58671 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
58672 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58673 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
58674 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
58675 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
58676 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
58677 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
58678 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
58679 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
58680 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
58681 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
58682 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
58683 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58684 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
58685 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
58686 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58687 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
58688 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
58689 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
58690 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
58691 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
58692 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58693 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
58694 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
58695 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
58696 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
58697 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
58698 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58699 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
58700 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
58701 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
58702 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
58703 { (char *)"new_EventBlocker", (PyCFunction) _wrap_new_EventBlocker, METH_VARARGS | METH_KEYWORDS, NULL},
58704 { (char *)"delete_EventBlocker", (PyCFunction)_wrap_delete_EventBlocker, METH_O, NULL},
58705 { (char *)"EventBlocker_Block", (PyCFunction) _wrap_EventBlocker_Block, METH_VARARGS | METH_KEYWORDS, NULL},
58706 { (char *)"EventBlocker_swigregister", EventBlocker_swigregister, METH_VARARGS, NULL},
58707 { (char *)"EventBlocker_swiginit", EventBlocker_swiginit, METH_VARARGS, NULL},
58708 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
58709 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
58710 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
58711 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
58712 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
58713 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
58714 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
58715 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
58716 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
58717 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
58718 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
58719 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
58720 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
58721 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
58722 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
58723 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
58724 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
58725 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
58726 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
58727 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
58728 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
58729 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
58730 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
58731 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
58732 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
58733 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
58734 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
58735 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
58736 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
58737 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
58738 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
58739 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
58740 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
58741 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
58742 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
58743 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
58744 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
58745 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
58746 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
58747 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
58748 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
58749 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
58750 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
58751 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
58752 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
58753 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
58754 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
58755 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
58756 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
58757 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
58758 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
58759 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
58760 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
58761 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58762 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
58763 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
58764 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
58765 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
58766 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
58767 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
58768 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
58769 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
58770 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
58771 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
58772 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
58773 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
58774 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
58775 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
58776 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
58777 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
58778 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
58779 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
58780 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
58781 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
58782 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
58783 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58784 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
58785 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
58786 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
58787 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
58788 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
58789 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
58790 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
58791 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
58792 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
58793 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
58794 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
58795 { (char *)"AcceleratorTable_IsOk", (PyCFunction)_wrap_AcceleratorTable_IsOk, METH_O, NULL},
58796 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
58797 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
58798 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
58799 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
58800 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
58801 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
58802 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
58803 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
58804 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
58805 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
58806 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
58807 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
58808 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
58809 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
58810 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
58811 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
58812 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
58813 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
58814 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
58815 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
58816 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
58817 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
58818 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
58819 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
58820 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
58821 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
58822 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
58823 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
58824 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
58825 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
58826 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
58827 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
58828 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
58829 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
58830 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
58831 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
58832 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
58833 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
58834 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
58835 { (char *)"Window_SetInitialSize", (PyCFunction) _wrap_Window_SetInitialSize, METH_VARARGS | METH_KEYWORDS, NULL},
58836 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
58837 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
58838 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
58839 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
58840 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
58841 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
58842 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
58843 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
58844 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
58845 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
58846 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
58847 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
58848 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
58849 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
58850 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
58851 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
58852 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
58853 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
58854 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
58855 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
58856 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
58857 { (char *)"Window_GetEffectiveMinSize", (PyCFunction)_wrap_Window_GetEffectiveMinSize, METH_O, NULL},
58858 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
58859 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
58860 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
58861 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
58862 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
58863 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
58864 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
58865 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
58866 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
58867 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
58868 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
58869 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
58870 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
58871 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
58872 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
58873 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
58874 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
58875 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
58876 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
58877 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
58878 { (char *)"Window_GetWindowBorderSize", (PyCFunction)_wrap_Window_GetWindowBorderSize, METH_O, NULL},
58879 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
58880 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
58881 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
58882 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
58883 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
58884 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
58885 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
58886 { (char *)"Window_IsThisEnabled", (PyCFunction)_wrap_Window_IsThisEnabled, METH_O, NULL},
58887 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
58888 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
58889 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
58890 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
58891 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
58892 { (char *)"Window_ToggleWindowStyle", (PyCFunction) _wrap_Window_ToggleWindowStyle, METH_VARARGS | METH_KEYWORDS, NULL},
58893 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
58894 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
58895 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
58896 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
58897 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
58898 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
58899 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
58900 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
58901 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
58902 { (char *)"Window_CanAcceptFocus", (PyCFunction)_wrap_Window_CanAcceptFocus, METH_O, NULL},
58903 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
58904 { (char *)"Window_CanAcceptFocusFromKeyboard", (PyCFunction)_wrap_Window_CanAcceptFocusFromKeyboard, METH_O, NULL},
58905 { (char *)"Window_NavigateIn", (PyCFunction) _wrap_Window_NavigateIn, METH_VARARGS | METH_KEYWORDS, NULL},
58906 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
58907 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
58908 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
58909 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
58910 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
58911 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
58912 { (char *)"Window_GetTopLevelParent", (PyCFunction)_wrap_Window_GetTopLevelParent, METH_O, NULL},
58913 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
58914 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
58915 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
58916 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
58917 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
58918 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
58919 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
58920 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
58921 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58922 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58923 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58924 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58925 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
58926 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
58927 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
58928 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
58929 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
58930 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
58931 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
58932 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
58933 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
58934 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
58935 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
58936 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
58937 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
58938 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
58939 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
58940 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
58941 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
58942 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
58943 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
58944 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
58945 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
58946 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
58947 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
58948 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
58949 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
58950 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
58951 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
58952 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
58953 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
58954 { (char *)"Window_IsDoubleBuffered", (PyCFunction)_wrap_Window_IsDoubleBuffered, METH_O, NULL},
58955 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
58956 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
58957 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
58958 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
58959 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
58960 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
58961 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
58962 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
58963 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
58964 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
58965 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
58966 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
58967 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
58968 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
58969 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
58970 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
58971 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
58972 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
58973 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
58974 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
58975 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
58976 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
58977 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
58978 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
58979 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
58980 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
58981 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
58982 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
58983 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
58984 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
58985 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
58986 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
58987 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
58988 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
58989 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
58990 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
58991 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
58992 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
58993 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
58994 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
58995 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
58996 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
58997 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
58998 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
58999 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
59000 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
59001 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
59002 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
59003 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
59004 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
59005 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59006 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
59007 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
59008 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
59009 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
59010 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
59011 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
59012 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
59013 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
59014 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
59015 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
59016 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
59017 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
59018 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
59019 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
59020 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
59021 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
59022 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
59023 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
59024 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
59025 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
59026 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
59027 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59028 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
59029 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
59030 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59031 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
59032 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
59033 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
59034 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
59035 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
59036 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
59037 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
59038 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
59039 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
59040 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59041 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
59042 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
59043 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
59044 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
59045 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
59046 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
59047 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
59048 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
59049 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59050 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
59051 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
59052 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
59053 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
59054 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
59055 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
59056 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
59057 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
59058 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
59059 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
59060 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
59061 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
59062 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
59063 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59064 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59065 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
59066 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
59067 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
59068 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
59069 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
59070 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
59071 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
59072 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
59073 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59074 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
59075 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
59076 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
59077 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
59078 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59079 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
59080 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
59081 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
59082 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
59083 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
59084 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
59085 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
59086 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
59087 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
59088 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
59089 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
59090 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59091 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
59092 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
59093 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
59094 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
59095 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59096 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59097 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
59098 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
59099 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
59100 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
59101 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
59102 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
59103 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59104 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
59105 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
59106 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
59107 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
59108 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
59109 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
59110 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
59111 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
59112 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
59113 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
59114 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
59115 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
59116 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
59117 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
59118 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
59119 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59120 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
59121 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
59122 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
59123 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
59124 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
59125 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
59126 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
59127 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
59128 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59129 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
59130 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
59131 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
59132 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
59133 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59134 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59135 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
59136 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
59137 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
59138 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
59139 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
59140 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
59141 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
59142 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59143 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
59144 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
59145 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
59146 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
59147 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
59148 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
59149 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59150 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
59151 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
59152 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
59153 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
59154 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
59155 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
59156 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
59157 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
59158 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
59159 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
59160 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
59161 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
59162 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59163 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
59164 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
59165 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
59166 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
59167 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
59168 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
59169 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
59170 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
59171 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
59172 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
59173 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
59174 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
59175 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
59176 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
59177 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
59178 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
59179 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
59180 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
59181 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
59182 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
59183 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
59184 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
59185 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
59186 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
59187 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
59188 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
59189 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
59190 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
59191 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
59192 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
59193 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
59194 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
59195 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
59196 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
59197 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
59198 { (char *)"Control_RemoveMnemonics", (PyCFunction) _wrap_Control_RemoveMnemonics, METH_VARARGS | METH_KEYWORDS, NULL},
59199 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
59200 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
59201 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
59202 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
59203 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
59204 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
59205 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
59206 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
59207 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
59208 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
59209 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
59210 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
59211 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
59212 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
59213 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
59214 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
59215 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
59216 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
59217 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
59218 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
59219 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
59220 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
59221 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
59222 { (char *)"new_SizerFlags", (PyCFunction) _wrap_new_SizerFlags, METH_VARARGS | METH_KEYWORDS, NULL},
59223 { (char *)"delete_SizerFlags", (PyCFunction)_wrap_delete_SizerFlags, METH_O, NULL},
59224 { (char *)"SizerFlags_Proportion", (PyCFunction) _wrap_SizerFlags_Proportion, METH_VARARGS | METH_KEYWORDS, NULL},
59225 { (char *)"SizerFlags_Align", (PyCFunction) _wrap_SizerFlags_Align, METH_VARARGS | METH_KEYWORDS, NULL},
59226 { (char *)"SizerFlags_Expand", (PyCFunction)_wrap_SizerFlags_Expand, METH_O, NULL},
59227 { (char *)"SizerFlags_Centre", (PyCFunction)_wrap_SizerFlags_Centre, METH_O, NULL},
59228 { (char *)"SizerFlags_Center", (PyCFunction)_wrap_SizerFlags_Center, METH_O, NULL},
59229 { (char *)"SizerFlags_Left", (PyCFunction)_wrap_SizerFlags_Left, METH_O, NULL},
59230 { (char *)"SizerFlags_Right", (PyCFunction)_wrap_SizerFlags_Right, METH_O, NULL},
59231 { (char *)"SizerFlags_Top", (PyCFunction)_wrap_SizerFlags_Top, METH_O, NULL},
59232 { (char *)"SizerFlags_Bottom", (PyCFunction)_wrap_SizerFlags_Bottom, METH_O, NULL},
59233 { (char *)"SizerFlags_Shaped", (PyCFunction)_wrap_SizerFlags_Shaped, METH_O, NULL},
59234 { (char *)"SizerFlags_FixedMinSize", (PyCFunction)_wrap_SizerFlags_FixedMinSize, METH_O, NULL},
59235 { (char *)"SizerFlags_Border", (PyCFunction) _wrap_SizerFlags_Border, METH_VARARGS | METH_KEYWORDS, NULL},
59236 { (char *)"SizerFlags_DoubleBorder", (PyCFunction) _wrap_SizerFlags_DoubleBorder, METH_VARARGS | METH_KEYWORDS, NULL},
59237 { (char *)"SizerFlags_TripleBorder", (PyCFunction) _wrap_SizerFlags_TripleBorder, METH_VARARGS | METH_KEYWORDS, NULL},
59238 { (char *)"SizerFlags_HorzBorder", (PyCFunction)_wrap_SizerFlags_HorzBorder, METH_O, NULL},
59239 { (char *)"SizerFlags_DoubleHorzBorder", (PyCFunction)_wrap_SizerFlags_DoubleHorzBorder, METH_O, NULL},
59240 { (char *)"SizerFlags_GetDefaultBorder", (PyCFunction)_wrap_SizerFlags_GetDefaultBorder, METH_NOARGS, NULL},
59241 { (char *)"SizerFlags_GetProportion", (PyCFunction)_wrap_SizerFlags_GetProportion, METH_O, NULL},
59242 { (char *)"SizerFlags_GetFlags", (PyCFunction)_wrap_SizerFlags_GetFlags, METH_O, NULL},
59243 { (char *)"SizerFlags_GetBorderInPixels", (PyCFunction)_wrap_SizerFlags_GetBorderInPixels, METH_O, NULL},
59244 { (char *)"SizerFlags_swigregister", SizerFlags_swigregister, METH_VARARGS, NULL},
59245 { (char *)"SizerFlags_swiginit", SizerFlags_swiginit, METH_VARARGS, NULL},
59246 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
59247 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
59248 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59249 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59250 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59251 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
59252 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
59253 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
59254 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
59255 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
59256 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
59257 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
59258 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
59259 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
59260 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
59261 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
59262 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
59263 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
59264 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
59265 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
59266 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
59267 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
59268 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
59269 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
59270 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
59271 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
59272 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
59273 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
59274 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
59275 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
59276 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59277 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59278 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59279 { (char *)"SizerItem_AssignWindow", (PyCFunction) _wrap_SizerItem_AssignWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59280 { (char *)"SizerItem_AssignSizer", (PyCFunction) _wrap_SizerItem_AssignSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59281 { (char *)"SizerItem_AssignSpacer", (PyCFunction) _wrap_SizerItem_AssignSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59282 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
59283 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
59284 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
59285 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
59286 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
59287 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
59288 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
59289 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
59290 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
59291 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
59292 { (char *)"Sizer_AddF", (PyCFunction) _wrap_Sizer_AddF, METH_VARARGS | METH_KEYWORDS, NULL},
59293 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
59294 { (char *)"Sizer_InsertF", (PyCFunction) _wrap_Sizer_InsertF, METH_VARARGS | METH_KEYWORDS, NULL},
59295 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
59296 { (char *)"Sizer_PrependF", (PyCFunction) _wrap_Sizer_PrependF, METH_VARARGS | METH_KEYWORDS, NULL},
59297 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
59298 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
59299 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
59300 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
59301 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
59302 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59303 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
59304 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59305 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
59306 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
59307 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
59308 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
59309 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
59310 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
59311 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
59312 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
59313 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
59314 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
59315 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
59316 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
59317 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
59318 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
59319 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
59320 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
59321 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
59322 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
59323 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
59324 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
59325 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
59326 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
59327 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
59328 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
59329 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
59330 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
59331 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
59332 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59333 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
59334 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
59335 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
59336 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
59337 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59338 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
59339 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
59340 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
59341 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59342 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
59343 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
59344 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
59345 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
59346 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
59347 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
59348 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
59349 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
59350 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
59351 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
59352 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59353 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
59354 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
59355 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
59356 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
59357 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
59358 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
59359 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
59360 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
59361 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
59362 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
59363 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
59364 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
59365 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
59366 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
59367 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
59368 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
59369 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
59370 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
59371 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
59372 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
59373 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
59374 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
59375 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
59376 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
59377 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
59378 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59379 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
59380 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
59381 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
59382 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
59383 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
59384 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
59385 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
59386 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
59387 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
59388 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
59389 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
59390 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
59391 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
59392 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
59393 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
59394 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
59395 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
59396 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
59397 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
59398 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
59399 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
59400 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
59401 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
59402 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
59403 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
59404 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59405 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59406 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59407 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
59408 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
59409 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
59410 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
59411 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
59412 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
59413 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
59414 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
59415 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59416 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
59417 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
59418 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59419 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
59420 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
59421 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
59422 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
59423 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
59424 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
59425 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
59426 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
59427 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
59428 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
59429 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59430 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
59431 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
59432 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
59433 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
59434 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
59435 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
59436 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
59437 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
59438 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
59439 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
59440 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
59441 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
59442 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
59443 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
59444 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
59445 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
59446 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
59447 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
59448 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
59449 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
59450 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
59451 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
59452 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
59453 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
59454 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
59455 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
59456 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
59457 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
59458 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
59459 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
59460 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
59461 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
59462 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
59463 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
59464 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
59465 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
59466 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
59467 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
59468 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
59469 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
59470 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
59471 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
59472 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
59473 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
59474 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
59475 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
59476 { NULL, NULL, 0, NULL }
59477 };
59478
59479
59480 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
59481
59482 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
59483 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
59484 }
59485 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
59486 return (void *)((wxEvent *) ((wxMenuEvent *) x));
59487 }
59488 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
59489 return (void *)((wxEvent *) ((wxCloseEvent *) x));
59490 }
59491 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
59492 return (void *)((wxEvent *) ((wxMouseEvent *) x));
59493 }
59494 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
59495 return (void *)((wxEvent *) ((wxEraseEvent *) x));
59496 }
59497 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
59498 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
59499 }
59500 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
59501 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
59502 }
59503 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
59504 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
59505 }
59506 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
59507 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
59508 }
59509 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
59510 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
59511 }
59512 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
59513 return (void *)((wxEvent *) ((wxPyEvent *) x));
59514 }
59515 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
59516 return (void *)((wxEvent *) ((wxIdleEvent *) x));
59517 }
59518 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
59519 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
59520 }
59521 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
59522 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
59523 }
59524 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
59525 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
59526 }
59527 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
59528 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
59529 }
59530 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
59531 return (void *)((wxEvent *) ((wxActivateEvent *) x));
59532 }
59533 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
59534 return (void *)((wxEvent *) ((wxSizeEvent *) x));
59535 }
59536 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
59537 return (void *)((wxEvent *) ((wxMoveEvent *) x));
59538 }
59539 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
59540 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
59541 }
59542 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
59543 return (void *)((wxEvent *) ((wxPaintEvent *) x));
59544 }
59545 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
59546 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
59547 }
59548 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
59549 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
59550 }
59551 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
59552 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
59553 }
59554 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
59555 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
59556 }
59557 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
59558 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
59559 }
59560 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
59561 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
59562 }
59563 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
59564 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
59565 }
59566 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
59567 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
59568 }
59569 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
59570 return (void *)((wxEvent *) ((wxFocusEvent *) x));
59571 }
59572 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
59573 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
59574 }
59575 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
59576 return (void *)((wxEvent *) ((wxShowEvent *) x));
59577 }
59578 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
59579 return (void *)((wxEvent *) ((wxCommandEvent *) x));
59580 }
59581 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
59582 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
59583 }
59584 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
59585 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
59586 }
59587 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
59588 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
59589 }
59590 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
59591 return (void *)((wxEvent *) ((wxKeyEvent *) x));
59592 }
59593 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
59594 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
59595 }
59596 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
59597 return (void *)((wxValidator *) ((wxPyValidator *) x));
59598 }
59599 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
59600 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
59601 }
59602 static void *_p_wxEventBlockerTo_p_wxObject(void *x) {
59603 return (void *)((wxObject *) (wxEvtHandler *) ((wxEventBlocker *) x));
59604 }
59605 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
59606 return (void *)((wxObject *) ((wxSizerItem *) x));
59607 }
59608 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
59609 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
59610 }
59611 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
59612 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
59613 }
59614 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
59615 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
59616 }
59617 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
59618 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
59619 }
59620 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
59621 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
59622 }
59623 static void *_p_wxSizerTo_p_wxObject(void *x) {
59624 return (void *)((wxObject *) ((wxSizer *) x));
59625 }
59626 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
59627 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
59628 }
59629 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
59630 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
59631 }
59632 static void *_p_wxEventTo_p_wxObject(void *x) {
59633 return (void *)((wxObject *) ((wxEvent *) x));
59634 }
59635 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
59636 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
59637 }
59638 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
59639 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
59640 }
59641 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
59642 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
59643 }
59644 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
59645 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
59646 }
59647 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
59648 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
59649 }
59650 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
59651 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
59652 }
59653 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
59654 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
59655 }
59656 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
59657 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
59658 }
59659 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
59660 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
59661 }
59662 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
59663 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
59664 }
59665 static void *_p_wxControlTo_p_wxObject(void *x) {
59666 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
59667 }
59668 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
59669 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
59670 }
59671 static void *_p_wxFSFileTo_p_wxObject(void *x) {
59672 return (void *)((wxObject *) ((wxFSFile *) x));
59673 }
59674 static void *_p_wxPySizerTo_p_wxObject(void *x) {
59675 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
59676 }
59677 static void *_p_wxPyEventTo_p_wxObject(void *x) {
59678 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
59679 }
59680 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
59681 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
59682 }
59683 static void *_p_wxShowEventTo_p_wxObject(void *x) {
59684 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
59685 }
59686 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
59687 return (void *)((wxObject *) ((wxMenuItem *) x));
59688 }
59689 static void *_p_wxDateEventTo_p_wxObject(void *x) {
59690 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
59691 }
59692 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
59693 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
59694 }
59695 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
59696 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
59697 }
59698 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
59699 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
59700 }
59701 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
59702 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
59703 }
59704 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
59705 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
59706 }
59707 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
59708 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
59709 }
59710 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
59711 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
59712 }
59713 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
59714 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
59715 }
59716 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
59717 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
59718 }
59719 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
59720 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
59721 }
59722 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
59723 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
59724 }
59725 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
59726 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
59727 }
59728 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
59729 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
59730 }
59731 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
59732 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
59733 }
59734 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
59735 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
59736 }
59737 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
59738 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
59739 }
59740 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
59741 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
59742 }
59743 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
59744 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
59745 }
59746 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
59747 return (void *)((wxObject *) ((wxImageHandler *) x));
59748 }
59749 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
59750 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
59751 }
59752 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
59753 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
59754 }
59755 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
59756 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
59757 }
59758 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
59759 return (void *)((wxObject *) ((wxEvtHandler *) x));
59760 }
59761 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
59762 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
59763 }
59764 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
59765 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
59766 }
59767 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
59768 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
59769 }
59770 static void *_p_wxImageTo_p_wxObject(void *x) {
59771 return (void *)((wxObject *) ((wxImage *) x));
59772 }
59773 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
59774 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
59775 }
59776 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
59777 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
59778 }
59779 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
59780 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
59781 }
59782 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
59783 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
59784 }
59785 static void *_p_wxWindowTo_p_wxObject(void *x) {
59786 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
59787 }
59788 static void *_p_wxMenuTo_p_wxObject(void *x) {
59789 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
59790 }
59791 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
59792 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
59793 }
59794 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
59795 return (void *)((wxObject *) ((wxFileSystem *) x));
59796 }
59797 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
59798 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
59799 }
59800 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
59801 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
59802 }
59803 static void *_p_wxPyAppTo_p_wxObject(void *x) {
59804 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
59805 }
59806 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
59807 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
59808 }
59809 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
59810 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
59811 }
59812 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
59813 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
59814 }
59815 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
59816 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
59817 }
59818 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
59819 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
59820 }
59821 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
59822 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
59823 }
59824 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
59825 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
59826 }
59827 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
59828 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
59829 }
59830 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
59831 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
59832 }
59833 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
59834 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
59835 }
59836 static void *_p_wxValidatorTo_p_wxObject(void *x) {
59837 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
59838 }
59839 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
59840 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
59841 }
59842 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
59843 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
59844 }
59845 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
59846 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
59847 }
59848 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
59849 return (void *)((wxControl *) ((wxControlWithItems *) x));
59850 }
59851 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
59852 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
59853 }
59854 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
59855 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
59856 }
59857 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
59858 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
59859 }
59860 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
59861 return (void *)((wxSizer *) ((wxBoxSizer *) x));
59862 }
59863 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
59864 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
59865 }
59866 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
59867 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
59868 }
59869 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
59870 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
59871 }
59872 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
59873 return (void *)((wxSizer *) ((wxGridSizer *) x));
59874 }
59875 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
59876 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
59877 }
59878 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
59879 return (void *)((wxSizer *) ((wxPySizer *) x));
59880 }
59881 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
59882 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
59883 }
59884 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
59885 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
59886 }
59887 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
59888 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
59889 }
59890 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
59891 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
59892 }
59893 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
59894 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
59895 }
59896 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
59897 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
59898 }
59899 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
59900 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
59901 }
59902 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
59903 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
59904 }
59905 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
59906 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
59907 }
59908 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
59909 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
59910 }
59911 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
59912 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
59913 }
59914 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
59915 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
59916 }
59917 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
59918 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
59919 }
59920 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
59921 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
59922 }
59923 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
59924 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
59925 }
59926 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
59927 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
59928 }
59929 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
59930 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
59931 }
59932 static void *_p_wxTGAHandlerTo_p_wxImageHandler(void *x) {
59933 return (void *)((wxImageHandler *) ((wxTGAHandler *) x));
59934 }
59935 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
59936 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
59937 }
59938 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
59939 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
59940 }
59941 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
59942 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
59943 }
59944 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
59945 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
59946 }
59947 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
59948 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
59949 }
59950 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
59951 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
59952 }
59953 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
59954 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
59955 }
59956 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
59957 return (void *)((wxEvtHandler *) ((wxWindow *) x));
59958 }
59959 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
59960 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
59961 }
59962 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
59963 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
59964 }
59965 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
59966 return (void *)((wxEvtHandler *) ((wxValidator *) x));
59967 }
59968 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
59969 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
59970 }
59971 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
59972 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
59973 }
59974 static void *_p_wxEventBlockerTo_p_wxEvtHandler(void *x) {
59975 return (void *)((wxEvtHandler *) ((wxEventBlocker *) x));
59976 }
59977 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
59978 return (void *)((wxEvtHandler *) ((wxMenu *) x));
59979 }
59980 static void *_p_wxControlTo_p_wxWindow(void *x) {
59981 return (void *)((wxWindow *) ((wxControl *) x));
59982 }
59983 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
59984 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
59985 }
59986 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
59987 return (void *)((wxWindow *) ((wxMenuBar *) x));
59988 }
59989 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
59990 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
59991 }
59992 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
59993 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
59994 }
59995 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
59996 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
59997 }
59998 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
59999 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
60000 }
60001 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
60002 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
60003 }
60004 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
60005 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
60006 }
60007 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
60008 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
60009 }
60010 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
60011 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
60012 }
60013 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
60014 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
60015 }
60016 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
60017 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
60018 }
60019 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
60020 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
60021 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};
60022 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
60023 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
60024 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
60025 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
60026 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
60027 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
60028 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
60029 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
60030 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
60031 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
60032 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
60033 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
60034 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
60035 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
60036 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
60037 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
60038 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
60039 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
60040 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
60041 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
60042 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
60043 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
60044 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
60045 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
60046 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
60047 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
60048 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
60049 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
60050 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
60051 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
60052 static swig_type_info _swigt__p_wxDouble = {"_p_wxDouble", "wxDouble *", 0, 0, (void*)0, 0};
60053 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
60054 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
60055 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
60056 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
60057 static swig_type_info _swigt__p_wxEventBlocker = {"_p_wxEventBlocker", "wxEventBlocker *", 0, 0, (void*)0, 0};
60058 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
60059 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
60060 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
60061 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
60062 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
60063 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
60064 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
60065 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
60066 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
60067 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
60068 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
60069 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
60070 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
60071 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
60072 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
60073 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
60074 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
60075 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
60076 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
60077 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
60078 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
60079 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
60080 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
60081 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
60082 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
60083 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
60084 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
60085 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
60086 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
60087 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
60088 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
60089 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
60090 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
60091 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
60092 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
60093 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
60094 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
60095 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
60096 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
60097 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
60098 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
60099 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
60100 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
60101 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
60102 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
60103 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
60104 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
60105 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
60106 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
60107 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
60108 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
60109 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
60110 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
60111 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
60112 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
60113 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
60114 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
60115 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
60116 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
60117 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
60118 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
60119 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
60120 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
60121 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
60122 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
60123 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
60124 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
60125 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
60126 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
60127 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
60128 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
60129 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
60130 static swig_type_info _swigt__p_wxRect2D = {"_p_wxRect2D", "wxRect2D *", 0, 0, (void*)0, 0};
60131 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
60132 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
60133 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
60134 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
60135 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
60136 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
60137 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
60138 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
60139 static swig_type_info _swigt__p_wxSizerFlags = {"_p_wxSizerFlags", "wxSizerFlags *", 0, 0, (void*)0, 0};
60140 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
60141 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
60142 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
60143 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
60144 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
60145 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", "wxTGAHandler *", 0, 0, (void*)0, 0};
60146 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
60147 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
60148 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
60149 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
60150 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
60151 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
60152 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
60153 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
60154 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
60155 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
60156
60157 static swig_type_info *swig_type_initial[] = {
60158 &_swigt__p_buffer,
60159 &_swigt__p_char,
60160 &_swigt__p_form_ops_t,
60161 &_swigt__p_int,
60162 &_swigt__p_long,
60163 &_swigt__p_unsigned_char,
60164 &_swigt__p_unsigned_int,
60165 &_swigt__p_unsigned_long,
60166 &_swigt__p_wxANIHandler,
60167 &_swigt__p_wxAcceleratorEntry,
60168 &_swigt__p_wxAcceleratorTable,
60169 &_swigt__p_wxActivateEvent,
60170 &_swigt__p_wxAppTraits,
60171 &_swigt__p_wxArrayString,
60172 &_swigt__p_wxBMPHandler,
60173 &_swigt__p_wxBitmap,
60174 &_swigt__p_wxBoxSizer,
60175 &_swigt__p_wxButton,
60176 &_swigt__p_wxCURHandler,
60177 &_swigt__p_wxCaret,
60178 &_swigt__p_wxChildFocusEvent,
60179 &_swigt__p_wxClipboardTextEvent,
60180 &_swigt__p_wxCloseEvent,
60181 &_swigt__p_wxColour,
60182 &_swigt__p_wxCommandEvent,
60183 &_swigt__p_wxContextMenuEvent,
60184 &_swigt__p_wxControl,
60185 &_swigt__p_wxControlWithItems,
60186 &_swigt__p_wxCursor,
60187 &_swigt__p_wxDC,
60188 &_swigt__p_wxDateEvent,
60189 &_swigt__p_wxDateTime,
60190 &_swigt__p_wxDisplayChangedEvent,
60191 &_swigt__p_wxDouble,
60192 &_swigt__p_wxDropFilesEvent,
60193 &_swigt__p_wxDuplexMode,
60194 &_swigt__p_wxEraseEvent,
60195 &_swigt__p_wxEvent,
60196 &_swigt__p_wxEventBlocker,
60197 &_swigt__p_wxEventLoop,
60198 &_swigt__p_wxEventLoopActivator,
60199 &_swigt__p_wxEvtHandler,
60200 &_swigt__p_wxFSFile,
60201 &_swigt__p_wxFileSystem,
60202 &_swigt__p_wxFileSystemHandler,
60203 &_swigt__p_wxFlexGridSizer,
60204 &_swigt__p_wxFocusEvent,
60205 &_swigt__p_wxFont,
60206 &_swigt__p_wxFrame,
60207 &_swigt__p_wxGBPosition,
60208 &_swigt__p_wxGBSizerItem,
60209 &_swigt__p_wxGBSpan,
60210 &_swigt__p_wxGIFHandler,
60211 &_swigt__p_wxGridBagSizer,
60212 &_swigt__p_wxGridSizer,
60213 &_swigt__p_wxHelpEvent__Origin,
60214 &_swigt__p_wxICOHandler,
60215 &_swigt__p_wxIconizeEvent,
60216 &_swigt__p_wxIdleEvent,
60217 &_swigt__p_wxImage,
60218 &_swigt__p_wxImageHandler,
60219 &_swigt__p_wxImageHistogram,
60220 &_swigt__p_wxImage_HSVValue,
60221 &_swigt__p_wxImage_RGBValue,
60222 &_swigt__p_wxIndividualLayoutConstraint,
60223 &_swigt__p_wxInitDialogEvent,
60224 &_swigt__p_wxInputStream,
60225 &_swigt__p_wxInternetFSHandler,
60226 &_swigt__p_wxItemContainer,
60227 &_swigt__p_wxJPEGHandler,
60228 &_swigt__p_wxKeyEvent,
60229 &_swigt__p_wxLayoutConstraints,
60230 &_swigt__p_wxMaximizeEvent,
60231 &_swigt__p_wxMemoryFSHandler,
60232 &_swigt__p_wxMenu,
60233 &_swigt__p_wxMenuBar,
60234 &_swigt__p_wxMenuBarBase,
60235 &_swigt__p_wxMenuEvent,
60236 &_swigt__p_wxMenuItem,
60237 &_swigt__p_wxMouseCaptureChangedEvent,
60238 &_swigt__p_wxMouseCaptureLostEvent,
60239 &_swigt__p_wxMouseEvent,
60240 &_swigt__p_wxMoveEvent,
60241 &_swigt__p_wxNavigationKeyEvent,
60242 &_swigt__p_wxNcPaintEvent,
60243 &_swigt__p_wxNotifyEvent,
60244 &_swigt__p_wxObject,
60245 &_swigt__p_wxOutputStream,
60246 &_swigt__p_wxPCXHandler,
60247 &_swigt__p_wxPNGHandler,
60248 &_swigt__p_wxPNMHandler,
60249 &_swigt__p_wxPaintEvent,
60250 &_swigt__p_wxPaletteChangedEvent,
60251 &_swigt__p_wxPaperSize,
60252 &_swigt__p_wxPoint,
60253 &_swigt__p_wxPoint2D,
60254 &_swigt__p_wxPropagateOnce,
60255 &_swigt__p_wxPropagationDisabler,
60256 &_swigt__p_wxPyApp,
60257 &_swigt__p_wxPyCommandEvent,
60258 &_swigt__p_wxPyDropTarget,
60259 &_swigt__p_wxPyEvent,
60260 &_swigt__p_wxPyFileSystemHandler,
60261 &_swigt__p_wxPyImageHandler,
60262 &_swigt__p_wxPyInputStream,
60263 &_swigt__p_wxPySizer,
60264 &_swigt__p_wxPyValidator,
60265 &_swigt__p_wxQuantize,
60266 &_swigt__p_wxQueryNewPaletteEvent,
60267 &_swigt__p_wxRealPoint,
60268 &_swigt__p_wxRect,
60269 &_swigt__p_wxRect2D,
60270 &_swigt__p_wxRegion,
60271 &_swigt__p_wxScrollEvent,
60272 &_swigt__p_wxScrollWinEvent,
60273 &_swigt__p_wxSetCursorEvent,
60274 &_swigt__p_wxShowEvent,
60275 &_swigt__p_wxSize,
60276 &_swigt__p_wxSizeEvent,
60277 &_swigt__p_wxSizer,
60278 &_swigt__p_wxSizerFlags,
60279 &_swigt__p_wxSizerItem,
60280 &_swigt__p_wxStaticBox,
60281 &_swigt__p_wxStaticBoxSizer,
60282 &_swigt__p_wxStdDialogButtonSizer,
60283 &_swigt__p_wxSysColourChangedEvent,
60284 &_swigt__p_wxTGAHandler,
60285 &_swigt__p_wxTIFFHandler,
60286 &_swigt__p_wxToolTip,
60287 &_swigt__p_wxUpdateUIEvent,
60288 &_swigt__p_wxValidator,
60289 &_swigt__p_wxVisualAttributes,
60290 &_swigt__p_wxWindow,
60291 &_swigt__p_wxWindowCreateEvent,
60292 &_swigt__p_wxWindowDestroyEvent,
60293 &_swigt__p_wxXPMHandler,
60294 &_swigt__p_wxZipFSHandler,
60295 };
60296
60297 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
60298 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
60299 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
60300 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
60301 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
60302 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
60303 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
60304 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
60305 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
60306 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
60307 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
60308 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
60309 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
60310 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
60311 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}};
60312 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
60313 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}};
60314 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
60315 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}};
60316 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
60317 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
60318 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
60319 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
60320 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
60321 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}};
60322 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
60323 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}};
60324 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
60325 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
60326 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
60327 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
60328 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
60329 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60330 static swig_cast_info _swigc__p_wxDouble[] = { {&_swigt__p_wxDouble, 0, 0, 0},{0, 0, 0, 0}};
60331 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
60332 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
60333 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
60334 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}};
60335 static swig_cast_info _swigc__p_wxEventBlocker[] = { {&_swigt__p_wxEventBlocker, 0, 0, 0},{0, 0, 0, 0}};
60336 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
60337 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
60338 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}};
60339 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
60340 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
60341 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}};
60342 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}};
60343 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
60344 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
60345 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
60346 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
60347 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
60348 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
60349 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
60350 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
60351 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}};
60352 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
60353 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}};
60354 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
60355 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
60356 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
60357 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}};
60358 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
60359 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
60360 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
60361 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
60362 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
60363 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
60364 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
60365 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}};
60366 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
60367 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
60368 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
60369 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
60370 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
60371 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
60372 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
60373 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
60374 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
60375 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
60376 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60377 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
60378 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
60379 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
60380 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
60381 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
60382 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
60383 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}};
60384 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
60385 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
60386 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
60387 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
60388 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
60389 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60390 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
60391 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
60392 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
60393 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
60394 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
60395 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
60396 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
60397 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
60398 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
60399 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
60400 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
60401 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
60402 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
60403 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
60404 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
60405 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
60406 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
60407 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
60408 static swig_cast_info _swigc__p_wxRect2D[] = { {&_swigt__p_wxRect2D, 0, 0, 0},{0, 0, 0, 0}};
60409 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
60410 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
60411 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
60412 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
60413 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
60414 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
60415 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
60416 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}};
60417 static swig_cast_info _swigc__p_wxSizerFlags[] = { {&_swigt__p_wxSizerFlags, 0, 0, 0},{0, 0, 0, 0}};
60418 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}};
60419 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
60420 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
60421 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
60422 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60423 static swig_cast_info _swigc__p_wxTGAHandler[] = { {&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
60424 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
60425 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
60426 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
60427 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}};
60428 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
60429 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}};
60430 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
60431 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
60432 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
60433 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
60434
60435 static swig_cast_info *swig_cast_initial[] = {
60436 _swigc__p_buffer,
60437 _swigc__p_char,
60438 _swigc__p_form_ops_t,
60439 _swigc__p_int,
60440 _swigc__p_long,
60441 _swigc__p_unsigned_char,
60442 _swigc__p_unsigned_int,
60443 _swigc__p_unsigned_long,
60444 _swigc__p_wxANIHandler,
60445 _swigc__p_wxAcceleratorEntry,
60446 _swigc__p_wxAcceleratorTable,
60447 _swigc__p_wxActivateEvent,
60448 _swigc__p_wxAppTraits,
60449 _swigc__p_wxArrayString,
60450 _swigc__p_wxBMPHandler,
60451 _swigc__p_wxBitmap,
60452 _swigc__p_wxBoxSizer,
60453 _swigc__p_wxButton,
60454 _swigc__p_wxCURHandler,
60455 _swigc__p_wxCaret,
60456 _swigc__p_wxChildFocusEvent,
60457 _swigc__p_wxClipboardTextEvent,
60458 _swigc__p_wxCloseEvent,
60459 _swigc__p_wxColour,
60460 _swigc__p_wxCommandEvent,
60461 _swigc__p_wxContextMenuEvent,
60462 _swigc__p_wxControl,
60463 _swigc__p_wxControlWithItems,
60464 _swigc__p_wxCursor,
60465 _swigc__p_wxDC,
60466 _swigc__p_wxDateEvent,
60467 _swigc__p_wxDateTime,
60468 _swigc__p_wxDisplayChangedEvent,
60469 _swigc__p_wxDouble,
60470 _swigc__p_wxDropFilesEvent,
60471 _swigc__p_wxDuplexMode,
60472 _swigc__p_wxEraseEvent,
60473 _swigc__p_wxEvent,
60474 _swigc__p_wxEventBlocker,
60475 _swigc__p_wxEventLoop,
60476 _swigc__p_wxEventLoopActivator,
60477 _swigc__p_wxEvtHandler,
60478 _swigc__p_wxFSFile,
60479 _swigc__p_wxFileSystem,
60480 _swigc__p_wxFileSystemHandler,
60481 _swigc__p_wxFlexGridSizer,
60482 _swigc__p_wxFocusEvent,
60483 _swigc__p_wxFont,
60484 _swigc__p_wxFrame,
60485 _swigc__p_wxGBPosition,
60486 _swigc__p_wxGBSizerItem,
60487 _swigc__p_wxGBSpan,
60488 _swigc__p_wxGIFHandler,
60489 _swigc__p_wxGridBagSizer,
60490 _swigc__p_wxGridSizer,
60491 _swigc__p_wxHelpEvent__Origin,
60492 _swigc__p_wxICOHandler,
60493 _swigc__p_wxIconizeEvent,
60494 _swigc__p_wxIdleEvent,
60495 _swigc__p_wxImage,
60496 _swigc__p_wxImageHandler,
60497 _swigc__p_wxImageHistogram,
60498 _swigc__p_wxImage_HSVValue,
60499 _swigc__p_wxImage_RGBValue,
60500 _swigc__p_wxIndividualLayoutConstraint,
60501 _swigc__p_wxInitDialogEvent,
60502 _swigc__p_wxInputStream,
60503 _swigc__p_wxInternetFSHandler,
60504 _swigc__p_wxItemContainer,
60505 _swigc__p_wxJPEGHandler,
60506 _swigc__p_wxKeyEvent,
60507 _swigc__p_wxLayoutConstraints,
60508 _swigc__p_wxMaximizeEvent,
60509 _swigc__p_wxMemoryFSHandler,
60510 _swigc__p_wxMenu,
60511 _swigc__p_wxMenuBar,
60512 _swigc__p_wxMenuBarBase,
60513 _swigc__p_wxMenuEvent,
60514 _swigc__p_wxMenuItem,
60515 _swigc__p_wxMouseCaptureChangedEvent,
60516 _swigc__p_wxMouseCaptureLostEvent,
60517 _swigc__p_wxMouseEvent,
60518 _swigc__p_wxMoveEvent,
60519 _swigc__p_wxNavigationKeyEvent,
60520 _swigc__p_wxNcPaintEvent,
60521 _swigc__p_wxNotifyEvent,
60522 _swigc__p_wxObject,
60523 _swigc__p_wxOutputStream,
60524 _swigc__p_wxPCXHandler,
60525 _swigc__p_wxPNGHandler,
60526 _swigc__p_wxPNMHandler,
60527 _swigc__p_wxPaintEvent,
60528 _swigc__p_wxPaletteChangedEvent,
60529 _swigc__p_wxPaperSize,
60530 _swigc__p_wxPoint,
60531 _swigc__p_wxPoint2D,
60532 _swigc__p_wxPropagateOnce,
60533 _swigc__p_wxPropagationDisabler,
60534 _swigc__p_wxPyApp,
60535 _swigc__p_wxPyCommandEvent,
60536 _swigc__p_wxPyDropTarget,
60537 _swigc__p_wxPyEvent,
60538 _swigc__p_wxPyFileSystemHandler,
60539 _swigc__p_wxPyImageHandler,
60540 _swigc__p_wxPyInputStream,
60541 _swigc__p_wxPySizer,
60542 _swigc__p_wxPyValidator,
60543 _swigc__p_wxQuantize,
60544 _swigc__p_wxQueryNewPaletteEvent,
60545 _swigc__p_wxRealPoint,
60546 _swigc__p_wxRect,
60547 _swigc__p_wxRect2D,
60548 _swigc__p_wxRegion,
60549 _swigc__p_wxScrollEvent,
60550 _swigc__p_wxScrollWinEvent,
60551 _swigc__p_wxSetCursorEvent,
60552 _swigc__p_wxShowEvent,
60553 _swigc__p_wxSize,
60554 _swigc__p_wxSizeEvent,
60555 _swigc__p_wxSizer,
60556 _swigc__p_wxSizerFlags,
60557 _swigc__p_wxSizerItem,
60558 _swigc__p_wxStaticBox,
60559 _swigc__p_wxStaticBoxSizer,
60560 _swigc__p_wxStdDialogButtonSizer,
60561 _swigc__p_wxSysColourChangedEvent,
60562 _swigc__p_wxTGAHandler,
60563 _swigc__p_wxTIFFHandler,
60564 _swigc__p_wxToolTip,
60565 _swigc__p_wxUpdateUIEvent,
60566 _swigc__p_wxValidator,
60567 _swigc__p_wxVisualAttributes,
60568 _swigc__p_wxWindow,
60569 _swigc__p_wxWindowCreateEvent,
60570 _swigc__p_wxWindowDestroyEvent,
60571 _swigc__p_wxXPMHandler,
60572 _swigc__p_wxZipFSHandler,
60573 };
60574
60575
60576 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
60577
60578 static swig_const_info swig_const_table[] = {
60579 {0, 0, 0, 0.0, 0, 0}};
60580
60581 #ifdef __cplusplus
60582 }
60583 #endif
60584 /* -----------------------------------------------------------------------------
60585 * Type initialization:
60586 * This problem is tough by the requirement that no dynamic
60587 * memory is used. Also, since swig_type_info structures store pointers to
60588 * swig_cast_info structures and swig_cast_info structures store pointers back
60589 * to swig_type_info structures, we need some lookup code at initialization.
60590 * The idea is that swig generates all the structures that are needed.
60591 * The runtime then collects these partially filled structures.
60592 * The SWIG_InitializeModule function takes these initial arrays out of
60593 * swig_module, and does all the lookup, filling in the swig_module.types
60594 * array with the correct data and linking the correct swig_cast_info
60595 * structures together.
60596 *
60597 * The generated swig_type_info structures are assigned staticly to an initial
60598 * array. We just loop though that array, and handle each type individually.
60599 * First we lookup if this type has been already loaded, and if so, use the
60600 * loaded structure instead of the generated one. Then we have to fill in the
60601 * cast linked list. The cast data is initially stored in something like a
60602 * two-dimensional array. Each row corresponds to a type (there are the same
60603 * number of rows as there are in the swig_type_initial array). Each entry in
60604 * a column is one of the swig_cast_info structures for that type.
60605 * The cast_initial array is actually an array of arrays, because each row has
60606 * a variable number of columns. So to actually build the cast linked list,
60607 * we find the array of casts associated with the type, and loop through it
60608 * adding the casts to the list. The one last trick we need to do is making
60609 * sure the type pointer in the swig_cast_info struct is correct.
60610 *
60611 * First off, we lookup the cast->type name to see if it is already loaded.
60612 * There are three cases to handle:
60613 * 1) If the cast->type has already been loaded AND the type we are adding
60614 * casting info to has not been loaded (it is in this module), THEN we
60615 * replace the cast->type pointer with the type pointer that has already
60616 * been loaded.
60617 * 2) If BOTH types (the one we are adding casting info to, and the
60618 * cast->type) are loaded, THEN the cast info has already been loaded by
60619 * the previous module so we just ignore it.
60620 * 3) Finally, if cast->type has not already been loaded, then we add that
60621 * swig_cast_info to the linked list (because the cast->type) pointer will
60622 * be correct.
60623 * ----------------------------------------------------------------------------- */
60624
60625 #ifdef __cplusplus
60626 extern "C" {
60627 #if 0
60628 } /* c-mode */
60629 #endif
60630 #endif
60631
60632 #if 0
60633 #define SWIGRUNTIME_DEBUG
60634 #endif
60635
60636 SWIGRUNTIME void
60637 SWIG_InitializeModule(void *clientdata) {
60638 size_t i;
60639 swig_module_info *module_head;
60640 static int init_run = 0;
60641
60642 clientdata = clientdata;
60643
60644 if (init_run) return;
60645 init_run = 1;
60646
60647 /* Initialize the swig_module */
60648 swig_module.type_initial = swig_type_initial;
60649 swig_module.cast_initial = swig_cast_initial;
60650
60651 /* Try and load any already created modules */
60652 module_head = SWIG_GetModule(clientdata);
60653 if (module_head) {
60654 swig_module.next = module_head->next;
60655 module_head->next = &swig_module;
60656 } else {
60657 /* This is the first module loaded */
60658 swig_module.next = &swig_module;
60659 SWIG_SetModule(clientdata, &swig_module);
60660 }
60661
60662 /* Now work on filling in swig_module.types */
60663 #ifdef SWIGRUNTIME_DEBUG
60664 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
60665 #endif
60666 for (i = 0; i < swig_module.size; ++i) {
60667 swig_type_info *type = 0;
60668 swig_type_info *ret;
60669 swig_cast_info *cast;
60670
60671 #ifdef SWIGRUNTIME_DEBUG
60672 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
60673 #endif
60674
60675 /* if there is another module already loaded */
60676 if (swig_module.next != &swig_module) {
60677 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
60678 }
60679 if (type) {
60680 /* Overwrite clientdata field */
60681 #ifdef SWIGRUNTIME_DEBUG
60682 printf("SWIG_InitializeModule: found type %s\n", type->name);
60683 #endif
60684 if (swig_module.type_initial[i]->clientdata) {
60685 type->clientdata = swig_module.type_initial[i]->clientdata;
60686 #ifdef SWIGRUNTIME_DEBUG
60687 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
60688 #endif
60689 }
60690 } else {
60691 type = swig_module.type_initial[i];
60692 }
60693
60694 /* Insert casting types */
60695 cast = swig_module.cast_initial[i];
60696 while (cast->type) {
60697 /* Don't need to add information already in the list */
60698 ret = 0;
60699 #ifdef SWIGRUNTIME_DEBUG
60700 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
60701 #endif
60702 if (swig_module.next != &swig_module) {
60703 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
60704 #ifdef SWIGRUNTIME_DEBUG
60705 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
60706 #endif
60707 }
60708 if (ret) {
60709 if (type == swig_module.type_initial[i]) {
60710 #ifdef SWIGRUNTIME_DEBUG
60711 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
60712 #endif
60713 cast->type = ret;
60714 ret = 0;
60715 } else {
60716 /* Check for casting already in the list */
60717 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
60718 #ifdef SWIGRUNTIME_DEBUG
60719 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
60720 #endif
60721 if (!ocast) ret = 0;
60722 }
60723 }
60724
60725 if (!ret) {
60726 #ifdef SWIGRUNTIME_DEBUG
60727 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
60728 #endif
60729 if (type->cast) {
60730 type->cast->prev = cast;
60731 cast->next = type->cast;
60732 }
60733 type->cast = cast;
60734 }
60735 cast++;
60736 }
60737 /* Set entry in modules->types array equal to the type */
60738 swig_module.types[i] = type;
60739 }
60740 swig_module.types[i] = 0;
60741
60742 #ifdef SWIGRUNTIME_DEBUG
60743 printf("**** SWIG_InitializeModule: Cast List ******\n");
60744 for (i = 0; i < swig_module.size; ++i) {
60745 int j = 0;
60746 swig_cast_info *cast = swig_module.cast_initial[i];
60747 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
60748 while (cast->type) {
60749 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
60750 cast++;
60751 ++j;
60752 }
60753 printf("---- Total casts: %d\n",j);
60754 }
60755 printf("**** SWIG_InitializeModule: Cast List ******\n");
60756 #endif
60757 }
60758
60759 /* This function will propagate the clientdata field of type to
60760 * any new swig_type_info structures that have been added into the list
60761 * of equivalent types. It is like calling
60762 * SWIG_TypeClientData(type, clientdata) a second time.
60763 */
60764 SWIGRUNTIME void
60765 SWIG_PropagateClientData(void) {
60766 size_t i;
60767 swig_cast_info *equiv;
60768 static int init_run = 0;
60769
60770 if (init_run) return;
60771 init_run = 1;
60772
60773 for (i = 0; i < swig_module.size; i++) {
60774 if (swig_module.types[i]->clientdata) {
60775 equiv = swig_module.types[i]->cast;
60776 while (equiv) {
60777 if (!equiv->converter) {
60778 if (equiv->type && !equiv->type->clientdata)
60779 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
60780 }
60781 equiv = equiv->next;
60782 }
60783 }
60784 }
60785 }
60786
60787 #ifdef __cplusplus
60788 #if 0
60789 {
60790 /* c-mode */
60791 #endif
60792 }
60793 #endif
60794
60795
60796
60797 #ifdef __cplusplus
60798 extern "C" {
60799 #endif
60800
60801 /* Python-specific SWIG API */
60802 #define SWIG_newvarlink() SWIG_Python_newvarlink()
60803 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
60804 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
60805
60806 /* -----------------------------------------------------------------------------
60807 * global variable support code.
60808 * ----------------------------------------------------------------------------- */
60809
60810 typedef struct swig_globalvar {
60811 char *name; /* Name of global variable */
60812 PyObject *(*get_attr)(void); /* Return the current value */
60813 int (*set_attr)(PyObject *); /* Set the value */
60814 struct swig_globalvar *next;
60815 } swig_globalvar;
60816
60817 typedef struct swig_varlinkobject {
60818 PyObject_HEAD
60819 swig_globalvar *vars;
60820 } swig_varlinkobject;
60821
60822 SWIGINTERN PyObject *
60823 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
60824 return PyString_FromString("<Swig global variables>");
60825 }
60826
60827 SWIGINTERN PyObject *
60828 swig_varlink_str(swig_varlinkobject *v) {
60829 PyObject *str = PyString_FromString("(");
60830 swig_globalvar *var;
60831 for (var = v->vars; var; var=var->next) {
60832 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
60833 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
60834 }
60835 PyString_ConcatAndDel(&str,PyString_FromString(")"));
60836 return str;
60837 }
60838
60839 SWIGINTERN int
60840 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
60841 PyObject *str = swig_varlink_str(v);
60842 fprintf(fp,"Swig global variables ");
60843 fprintf(fp,"%s\n", PyString_AsString(str));
60844 Py_DECREF(str);
60845 return 0;
60846 }
60847
60848 SWIGINTERN void
60849 swig_varlink_dealloc(swig_varlinkobject *v) {
60850 swig_globalvar *var = v->vars;
60851 while (var) {
60852 swig_globalvar *n = var->next;
60853 free(var->name);
60854 free(var);
60855 var = n;
60856 }
60857 }
60858
60859 SWIGINTERN PyObject *
60860 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
60861 PyObject *res = NULL;
60862 swig_globalvar *var = v->vars;
60863 while (var) {
60864 if (strcmp(var->name,n) == 0) {
60865 res = (*var->get_attr)();
60866 break;
60867 }
60868 var = var->next;
60869 }
60870 if (res == NULL && !PyErr_Occurred()) {
60871 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
60872 }
60873 return res;
60874 }
60875
60876 SWIGINTERN int
60877 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
60878 int res = 1;
60879 swig_globalvar *var = v->vars;
60880 while (var) {
60881 if (strcmp(var->name,n) == 0) {
60882 res = (*var->set_attr)(p);
60883 break;
60884 }
60885 var = var->next;
60886 }
60887 if (res == 1 && !PyErr_Occurred()) {
60888 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
60889 }
60890 return res;
60891 }
60892
60893 SWIGINTERN PyTypeObject*
60894 swig_varlink_type(void) {
60895 static char varlink__doc__[] = "Swig var link object";
60896 static PyTypeObject varlink_type;
60897 static int type_init = 0;
60898 if (!type_init) {
60899 const PyTypeObject tmp
60900 = {
60901 PyObject_HEAD_INIT(NULL)
60902 0, /* Number of items in variable part (ob_size) */
60903 (char *)"swigvarlink", /* Type name (tp_name) */
60904 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
60905 0, /* Itemsize (tp_itemsize) */
60906 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
60907 (printfunc) swig_varlink_print, /* Print (tp_print) */
60908 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
60909 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
60910 0, /* tp_compare */
60911 (reprfunc) swig_varlink_repr, /* tp_repr */
60912 0, /* tp_as_number */
60913 0, /* tp_as_sequence */
60914 0, /* tp_as_mapping */
60915 0, /* tp_hash */
60916 0, /* tp_call */
60917 (reprfunc)swig_varlink_str, /* tp_str */
60918 0, /* tp_getattro */
60919 0, /* tp_setattro */
60920 0, /* tp_as_buffer */
60921 0, /* tp_flags */
60922 varlink__doc__, /* tp_doc */
60923 0, /* tp_traverse */
60924 0, /* tp_clear */
60925 0, /* tp_richcompare */
60926 0, /* tp_weaklistoffset */
60927 #if PY_VERSION_HEX >= 0x02020000
60928 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
60929 #endif
60930 #if PY_VERSION_HEX >= 0x02030000
60931 0, /* tp_del */
60932 #endif
60933 #ifdef COUNT_ALLOCS
60934 0,0,0,0 /* tp_alloc -> tp_next */
60935 #endif
60936 };
60937 varlink_type = tmp;
60938 varlink_type.ob_type = &PyType_Type;
60939 type_init = 1;
60940 }
60941 return &varlink_type;
60942 }
60943
60944 /* Create a variable linking object for use later */
60945 SWIGINTERN PyObject *
60946 SWIG_Python_newvarlink(void) {
60947 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
60948 if (result) {
60949 result->vars = 0;
60950 }
60951 return ((PyObject*) result);
60952 }
60953
60954 SWIGINTERN void
60955 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
60956 swig_varlinkobject *v = (swig_varlinkobject *) p;
60957 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
60958 if (gv) {
60959 size_t size = strlen(name)+1;
60960 gv->name = (char *)malloc(size);
60961 if (gv->name) {
60962 strncpy(gv->name,name,size);
60963 gv->get_attr = get_attr;
60964 gv->set_attr = set_attr;
60965 gv->next = v->vars;
60966 }
60967 }
60968 v->vars = gv;
60969 }
60970
60971 SWIGINTERN PyObject *
60972 SWIG_globals() {
60973 static PyObject *_SWIG_globals = 0;
60974 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
60975 return _SWIG_globals;
60976 }
60977
60978 /* -----------------------------------------------------------------------------
60979 * constants/methods manipulation
60980 * ----------------------------------------------------------------------------- */
60981
60982 /* Install Constants */
60983 SWIGINTERN void
60984 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
60985 PyObject *obj = 0;
60986 size_t i;
60987 for (i = 0; constants[i].type; ++i) {
60988 switch(constants[i].type) {
60989 case SWIG_PY_POINTER:
60990 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
60991 break;
60992 case SWIG_PY_BINARY:
60993 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
60994 break;
60995 default:
60996 obj = 0;
60997 break;
60998 }
60999 if (obj) {
61000 PyDict_SetItemString(d, constants[i].name, obj);
61001 Py_DECREF(obj);
61002 }
61003 }
61004 }
61005
61006 /* -----------------------------------------------------------------------------*/
61007 /* Fix SwigMethods to carry the callback ptrs when needed */
61008 /* -----------------------------------------------------------------------------*/
61009
61010 SWIGINTERN void
61011 SWIG_Python_FixMethods(PyMethodDef *methods,
61012 swig_const_info *const_table,
61013 swig_type_info **types,
61014 swig_type_info **types_initial) {
61015 size_t i;
61016 for (i = 0; methods[i].ml_name; ++i) {
61017 const char *c = methods[i].ml_doc;
61018 if (c && (c = strstr(c, "swig_ptr: "))) {
61019 int j;
61020 swig_const_info *ci = 0;
61021 const char *name = c + 10;
61022 for (j = 0; const_table[j].type; ++j) {
61023 if (strncmp(const_table[j].name, name,
61024 strlen(const_table[j].name)) == 0) {
61025 ci = &(const_table[j]);
61026 break;
61027 }
61028 }
61029 if (ci) {
61030 size_t shift = (ci->ptype) - types;
61031 swig_type_info *ty = types_initial[shift];
61032 size_t ldoc = (c - methods[i].ml_doc);
61033 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
61034 char *ndoc = (char*)malloc(ldoc + lptr + 10);
61035 if (ndoc) {
61036 char *buff = ndoc;
61037 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
61038 if (ptr) {
61039 strncpy(buff, methods[i].ml_doc, ldoc);
61040 buff += ldoc;
61041 strncpy(buff, "swig_ptr: ", 10);
61042 buff += 10;
61043 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
61044 methods[i].ml_doc = ndoc;
61045 }
61046 }
61047 }
61048 }
61049 }
61050 }
61051
61052 #ifdef __cplusplus
61053 }
61054 #endif
61055
61056 /* -----------------------------------------------------------------------------*
61057 * Partial Init method
61058 * -----------------------------------------------------------------------------*/
61059
61060 #ifdef __cplusplus
61061 extern "C"
61062 #endif
61063 SWIGEXPORT void SWIG_init(void) {
61064 PyObject *m, *d;
61065
61066 /* Fix SwigMethods to carry the callback ptrs when needed */
61067 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
61068
61069 m = Py_InitModule((char *) SWIG_name, SwigMethods);
61070 d = PyModule_GetDict(m);
61071
61072 SWIG_InitializeModule(0);
61073 SWIG_InstallConstants(d,swig_const_table);
61074
61075
61076
61077 #ifndef wxPyUSE_EXPORT
61078 // Make our API structure a CObject so other modules can import it
61079 // from this module.
61080 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
61081 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
61082 Py_XDECREF(cobj);
61083 #endif
61084
61085 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
61086 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
61087 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
61088 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
61089 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
61090 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
61091 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
61092 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
61093 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
61094 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
61095 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
61096 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
61097 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
61098 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
61099 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
61100 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
61101 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
61102 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
61103 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
61104 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
61105 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
61106 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
61107 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
61108 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
61109 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
61110 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
61111 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
61112 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
61113 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
61114 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
61115 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
61116 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
61117 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
61118 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
61119 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
61120 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
61121 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
61122 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
61123 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
61124 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
61125 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
61126 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
61127 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
61128 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
61129 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
61130 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
61131 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
61132 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
61133 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
61134 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
61135 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
61136 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
61137 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
61138 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
61139 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
61140 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
61141 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
61142 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
61143 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
61144 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
61145 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
61146 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
61147 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
61148 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
61149 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
61150 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
61151 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
61152 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
61153 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
61154 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
61155 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
61156 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
61157 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
61158 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
61159 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
61160 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
61161 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
61162 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
61163 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
61164 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
61165 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
61166 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
61167 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
61168 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
61169 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
61170 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
61171 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
61172 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
61173 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
61174 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
61175 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
61176 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
61177 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
61178 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
61179 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
61180 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
61181 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
61182 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
61183 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
61184 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
61185 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
61186 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
61187 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
61188 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
61189 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
61190 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
61191 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
61192 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
61193 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
61194 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
61195 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
61196 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
61197 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
61198 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
61199 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
61200 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
61201 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
61202 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
61203 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
61204 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
61205 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
61206 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
61207 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
61208 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
61209 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
61210 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
61211 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
61212 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
61213 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
61214 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
61215 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
61216 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
61217 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
61218 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
61219 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
61220 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
61221 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
61222 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
61223 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
61224 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
61225 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
61226 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
61227 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
61228 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
61229 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
61230 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
61231 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
61232 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
61233 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
61234 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
61235 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
61236 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
61237 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
61238 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
61239 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
61240 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
61241 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
61242 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
61243 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
61244 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
61245 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
61246 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
61247 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
61248 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
61249 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
61250 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
61251 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
61252 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
61253 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
61254 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
61255 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
61256 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
61257 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
61258 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
61259 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
61260 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
61261 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
61262 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
61263 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
61264 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
61265 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
61266 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
61267 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
61268 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
61269 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
61270 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
61271 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
61272 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
61273 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
61274 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
61275 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
61276 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
61277 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
61278 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
61279 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
61280 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
61281 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
61282 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
61283 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
61284 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
61285 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
61286 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
61287 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
61288 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
61289 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
61290 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
61291 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
61292 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
61293 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
61294 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
61295 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
61296 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
61297 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
61298 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
61299 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
61300 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
61301 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
61302 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
61303 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
61304 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
61305 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
61306 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
61307 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
61308 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
61309 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
61310 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
61311 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
61312 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
61313 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
61314 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
61315 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
61316 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
61317 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
61318 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
61319 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
61320 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
61321 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
61322 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
61323 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
61324 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
61325 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
61326 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
61327 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
61328 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
61329 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
61330 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
61331 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
61332 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
61333 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
61334 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
61335 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
61336 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
61337 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
61338 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
61339 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
61340 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
61341 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
61342 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
61343 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
61344 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
61345 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
61346 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
61347 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
61348 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
61349 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
61350 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
61351 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
61352 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
61353 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
61354 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
61355 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
61356 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
61357 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
61358 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
61359 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
61360 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
61361 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
61362 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
61363 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
61364 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
61365 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
61366 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
61367 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
61368 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
61369 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
61370 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
61371 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
61372 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
61373 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
61374 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
61375 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
61376 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
61377 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
61378 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
61379 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
61380 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
61381 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
61382 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
61383 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
61384 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
61385 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
61386 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
61387 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
61388 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
61389 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
61390 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
61391 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
61392 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
61393 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
61394 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
61395 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
61396 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
61397 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
61398 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
61399 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
61400 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
61401 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
61402 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
61403 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
61404 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
61405 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
61406 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
61407 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
61408 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
61409 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
61410 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
61411 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
61412 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
61413 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
61414 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
61415 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
61416 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
61417 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
61418 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
61419 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
61420 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
61421 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
61422 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
61423 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
61424 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
61425 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
61426 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
61427 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
61428 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
61429 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
61430 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
61431 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
61432 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
61433 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
61434 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
61435 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
61436 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
61437 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
61438 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
61439 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
61440 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
61441 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
61442 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
61443 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
61444 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
61445 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
61446 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
61447 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
61448 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
61449 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
61450 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
61451 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
61452 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
61453 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
61454 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
61455 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
61456 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
61457 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
61458 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
61459 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
61460 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
61461 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
61462 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
61463 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
61464 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
61465 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
61466 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
61467 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
61468 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
61469 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
61470 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
61471 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
61472 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
61473 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
61474 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
61475 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
61476 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
61477 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
61478 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
61479 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
61480 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
61481 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
61482 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
61483 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
61484 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
61485 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
61486 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
61487 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
61488 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
61489 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
61490 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
61491 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
61492 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
61493 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
61494 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
61495 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
61496 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
61497 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
61498 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
61499 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
61500 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
61501 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
61502 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
61503 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
61504 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
61505 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
61506 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
61507 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
61508 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
61509 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
61510 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
61511 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
61512 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
61513 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
61514 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
61515 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
61516 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
61517 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
61518 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
61519 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
61520 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
61521 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
61522 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
61523 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
61524 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
61525 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
61526 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
61527 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
61528 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
61529 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
61530 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
61531 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
61532 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
61533 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
61534 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
61535 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
61536 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
61537 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
61538 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
61539 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
61540 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
61541 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
61542 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
61543 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
61544 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
61545 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
61546 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
61547 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
61548 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
61549 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
61550 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
61551 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
61552 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
61553 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
61554 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
61555 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
61556 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
61557 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
61558 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
61559 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
61560 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
61561 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
61562 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
61563 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
61564 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
61565 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
61566 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
61567 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
61568 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
61569 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
61570 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
61571 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
61572 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
61573 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
61574 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
61575 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
61576 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
61577 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
61578 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
61579 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
61580 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
61581 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
61582 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
61583 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
61584 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
61585 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
61586 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
61587 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
61588 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
61589 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
61590 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
61591 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
61592 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
61593 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
61594 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
61595 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
61596 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
61597 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
61598 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
61599 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
61600 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
61601 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
61602 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
61603 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
61604 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
61605 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
61606 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
61607 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
61608 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
61609 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
61610 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
61611 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
61612 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
61613 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
61614 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
61615 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
61616 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
61617 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
61618 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
61619 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
61620 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
61621 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
61622 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
61623 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
61624 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
61625 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
61626 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
61627 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
61628 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
61629 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
61630 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
61631 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
61632 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
61633 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
61634 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
61635 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
61636 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
61637 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
61638 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
61639 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
61640 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
61641 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
61642 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
61643 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
61644 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
61645 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
61646 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
61647 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
61648 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
61649 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
61650 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
61651 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
61652 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
61653 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
61654 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
61655 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
61656 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
61657 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
61658 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
61659 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
61660 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
61661 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
61662 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
61663 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
61664 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
61665 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
61666 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
61667 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
61668 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
61669 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
61670 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
61671 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
61672 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
61673 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
61674 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
61675 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
61676 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
61677 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
61678 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
61679 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
61680 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
61681 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
61682 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
61683 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
61684 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
61685 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
61686 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
61687 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
61688 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
61689 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
61690 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
61691 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
61692 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
61693 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
61694 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
61695 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
61696 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TGA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TGA)));
61697 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
61698 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
61699 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
61700 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
61701 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
61702 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
61703 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
61704 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
61705 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
61706 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
61707 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
61708 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
61709 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
61710 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
61711 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
61712 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
61713 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
61714 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
61715 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
61716 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
61717 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
61718 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
61719 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
61720 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
61721 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
61722 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
61723 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
61724 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
61725 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
61726 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
61727 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
61728 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
61729 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
61730 SWIG_Python_SetConstant(d, "Inside",SWIG_From_int(static_cast< int >(wxInside)));
61731 SWIG_Python_SetConstant(d, "OutLeft",SWIG_From_int(static_cast< int >(wxOutLeft)));
61732 SWIG_Python_SetConstant(d, "OutRight",SWIG_From_int(static_cast< int >(wxOutRight)));
61733 SWIG_Python_SetConstant(d, "OutTop",SWIG_From_int(static_cast< int >(wxOutTop)));
61734 SWIG_Python_SetConstant(d, "OutBottom",SWIG_From_int(static_cast< int >(wxOutBottom)));
61735 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
61736 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
61737 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
61738 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
61739 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
61740
61741 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
61742
61743
61744 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
61745
61746 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
61747 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
61748 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
61749 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
61750 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
61751 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
61752 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
61753 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
61754 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
61755 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
61756 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
61757 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
61758 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
61759 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
61760 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
61761 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
61762 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
61763 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
61764 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
61765 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
61766 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
61767 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
61768 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
61769 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
61770 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
61771 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
61772 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
61773 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
61774 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
61775 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
61776 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
61777 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
61778 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
61779 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
61780 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
61781 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
61782 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
61783 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
61784 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
61785 PyDict_SetItemString(d, "wxEVT_ANY", PyInt_FromLong(wxEVT_ANY));
61786 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
61787 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
61788 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
61789 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
61790 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
61791 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
61792 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
61793 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
61794 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
61795 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
61796 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
61797 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
61798 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
61799 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
61800 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
61801 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
61802 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
61803 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
61804 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
61805 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
61806 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
61807 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
61808 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
61809 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
61810 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
61811 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
61812 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
61813 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
61814 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
61815 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
61816 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
61817 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
61818 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
61819 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
61820 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
61821 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
61822 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
61823 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
61824 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
61825 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
61826 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
61827 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
61828 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
61829 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
61830 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
61831 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
61832 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
61833 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
61834 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
61835 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
61836 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
61837 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
61838 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
61839 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
61840 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
61841 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
61842 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
61843 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
61844 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
61845 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
61846 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
61847 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
61848 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
61849 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
61850 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
61851 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
61852 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
61853 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
61854 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
61855 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
61856 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
61857 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
61858 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
61859 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
61860 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
61861 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
61862 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
61863 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
61864 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
61865 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
61866 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
61867 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
61868 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
61869 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
61870 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
61871 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
61872 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
61873 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
61874 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
61875 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
61876 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
61877 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
61878 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
61879 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
61880 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
61881 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
61882 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
61883 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
61884 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
61885 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
61886 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
61887 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
61888 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
61889 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
61890 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
61891 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
61892 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
61893 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
61894 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
61895 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
61896 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
61897 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
61898 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
61899 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
61900 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
61901 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
61902 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
61903 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
61904 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
61905 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
61906 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
61907 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
61908 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
61909 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
61910 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
61911 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
61912 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
61913 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
61914 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
61915 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
61916 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
61917 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
61918 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
61919 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
61920 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
61921 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
61922 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
61923 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
61924 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
61925 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
61926 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
61927 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
61928 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
61929 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
61930 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
61931 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
61932 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
61933 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
61934 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
61935 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
61936 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
61937 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
61938 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
61939 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
61940 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
61941 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
61942 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
61943 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
61944 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
61945 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
61946 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
61947 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
61948 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
61949 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
61950 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
61951 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
61952 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
61953 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
61954 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
61955 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
61956 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
61957 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
61958 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
61959 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
61960 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
61961
61962 // Initialize threading, some globals and such
61963 __wxPyPreStart(d);
61964
61965
61966 // Although these are defined in __version__ they need to be here too so
61967 // that an assert can be done to ensure that the wxPython and the wxWindows
61968 // versions match.
61969 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
61970 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
61971 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
61972
61973 }
61974
wxWidgets (Impactor)